[libc++] Add custom clang-tidy checks

[ldionne]

This is really interesting! If you can get me more details about what FindClang.cmake looks like (I wasn't able to find after searching quickly), I might be able to provide more guidance on how to integrate it.

libcxx/test/configs/cmake-bridge.cfg.in

33

Instead, maybe we could introduce a directory where we install build tools like this and use --load=%{build-tools}/libcxx-tidy.*?

libcxx/test/libcxx/clang_tidy_checks/CMakeLists.txt

16 ↗

(On Diff #452985)

This relies on the fact that we used AddLLVM in the top-level CMake. This is like a weird hybrid between using the system-installed clang-tidy and the one we have in the monorepo. I think we should do the former. I would expect something like this (pseudo code):

// In the Dockerfile
sudo apt-get install clang-devel # that installs development headers and stuff for clang/clang-tidy/etc

// In the CMake
find_package(Clang)

add_library(libcxx_tidy SHARED ${SOURCES})
target_link_libraries(libcxx_tidy PUBLIC Clang::clang-tidy-lib)

I actually expect that something like this should be all that's needed if Clang does provide a working FindClang.cmake (IDK whether it does, though).

libcxx/utils/libcxx/test/features.py

160

Instead, has-clang-tidy should represent whether we have clang-tidy *AND* the development headers have been installed. That way, we can check for has-clang-tidy only in the tests.

[philnik]

• Address some comments

[ldionne]

I think we have to options here:

1. Use the clang-tidy in the LLVM monorepo.
2. Use a system-provided clang-tidy if there is one, and disable these tests otherwise.

I think (1) is a non-starter, because we can't start depending on clang-tidy (which depends on clang, LLVM, etc.) inside libc++. That would require doing a bootstrapping build every time we want to run the tests.

So I think we have to to (2), and simply make sure that our Docker image in the CI does have the development packages for clang-tidy.

libcxx/test/tools/clang_tidy_checks/CMakeLists.txt

10

Instead, let's do

if(NOT Clang_FOUND OR ${LLVM_VERSION_MAJOR} LESS 15)
  message(STATUS "Could not find a suitable version of the Clang development package, custom libc++ clang-tidy checks will not be available.")
  return()
endif()

And in fact, we need to also bail out if we *do* find Clang, but if the development package is not installed. Otherwise, the includes and .a files needed below won't be found.

11–12

12

I would like to make it really clear that we're not using the in-tree version of headers/libraries. I suggest we add a target like this (since find_package(Clang) does not seem to do that):

add_library(clang-tidy-devel IMPORTED)
set_target_properties(clang-tidy-devel PROPERTIES IMPORTED_LOCATION "${?????}/libclangTidy.a")
target_include_directories(clang-tidy-devel INTERFACE "${LLVM_INCLUDE_DIRS}" 
                                                 "${CLANG_INCLUDE_DIRS}"
                                                 "${LLVM_MAIN_INCLUDE_DIR}/../../clang-tools-extra")
target_compile_options(clang-tidy-devel INTERFACE -fno-rtti)

Then, we can link cxx-tidy against clang-tidy-devel.

14–16

I'm not sure why we'd need those. We already set that at the top-level.

[ldionne]

libcxx/CMakeLists.txt

316–318 ↗

(On Diff #455594)

Let's remove this and make this automatic based on whether we have the dev packages. Basically, I don't see a reason to disable this if we can have them enabled.

libcxx/test/tools/clang_tidy_checks/CMakeLists.txt

6

Does this render our other tests for robustness against ADL obsolete? If so, we should take one of those, make it regress, and confirm that this clang-tidy check will catch it. If it doesn't, we should understand why.

Basically, I'd like us to have a clear understanding of whether we need to write manual tests for ADL robustness or not.

19

This can be removed if we have the INTERFACE flag suggested above.

25

Based on the CMake documentation, this should already be the default. I don't understand why this is needed -- can we try removing it and see how it fails?

26

Also, how about using .plugin instead? It's more platform agnostic.

libcxx/utils/libcxx/test/features.py

24

That doesn't work. You're manually expanding the substitution, but substitutions can contains substitutions themselves and so on. We should instead do:

int(re.search('[0-9]+', commandOutput(cfg, ['clang-tidy --version'])).group()) >= 13 and
runScriptExitCode(['stat %{test-tools}/clang_tidy_checks/libcxx-tidy.plugin']) == 0

[philnik]

• Rebased
• Address comments

libcxx/test/tools/clang_tidy_checks/CMakeLists.txt

6

I think we should do that in a follow-up where we remove the current ADL tests and make sure clang-tidy catches all the cases. If clang-tidy doesn't catch something we should find out why and fix the clang-tidy check.

14–16

We use

set_target_properties(${target} PROPERTIES
    CXX_STANDARD 20
    CXX_STANDARD_REQUIRED YES
    CXX_EXTENSIONS NO)

at the top level. Should I do the same here?

25

When I remove it the output file is set as /home/nikolask/llvm-projects/default/build/lib/libcxx-tidy.plugin. I don't know why it doesn't put it in the normal location.

[Mordante]

Could this be done with clang-query instead of a clang-tidy plugin?

libcxx/include/charconv

302

Why is this code moved? I am working on this header so the changes probably cause merge conflicts.

In general I dislike moving code in these kind of patches since they may cause unneeded merge conflicts.

Would it be possible to exclude this file and add a TODO so we can fix this after the consexpr version of charconv is done?

libcxx/utils/libcxx/test/features.py

24

I think it would be better when the user specifies the path to clang-tidy in CMake. Our Docker image contains multiple versions of clang-tidy; one for main and one for the release branch. To be able to use both branches the build bot configuration should be able to select the proper version.

It is already intended to remove the symlinks from the Docker file for that reason.

[philnik]

In D131963#3754059, @Mordante wrote:

Could this be done with clang-query instead of a clang-tidy plugin?

No. With a clang-tidy plugin we can get all the information in the AST, which we can't through clang-query. See AST_MATCHER(...) in robust_against_adl.cpp for examples. Using a clang-tidy plugin also has the benefit of getting proper error messages and (potentially) IDE integration. If we're ambitious maybe even fixit hints.

libcxx/include/charconv

302

It's moved because it calls the __to_chars_itoa in line 295. This wasn't checked before until the functions is called I think.

libcxx/utils/libcxx/test/features.py

24

Ok, but what has that to do with this change?

[avogelsgesang]

is there a reason why we add our own clang-tidy plugin instead of upstreaming this to clang-tidy itself? I could imagine that other library developers could also benefit from this clang-tidy check, if we make the list of allowed customization points a configuration option

[philnik]

In D131963#3754318, @avogelsgesang wrote:

is there a reason why we add our own clang-tidy plugin instead of upstreaming this to clang-tidy itself? I could imagine that other library developers could also benefit from this clang-tidy check, if we make the list of allowed customization points a configuration option

We can definitely do this for some checks, but I don't think it makes sense for all checks. I'd like to extend our _LIBCPP_HIDE_FROM_ABI check for example, but that check probably doesn't make sense for any other project. Upstreaming a check would also mean that we'd have to wait up to six months before being able to enforce it.

[Mordante]

In D131963#3754322, @philnik wrote:

In D131963#3754318, @avogelsgesang wrote:

is there a reason why we add our own clang-tidy plugin instead of upstreaming this to clang-tidy itself? I could imagine that other library developers could also benefit from this clang-tidy check, if we make the list of allowed customization points a configuration option

We can definitely do this for some checks, but I don't think it makes sense for all checks. I'd like to extend our _LIBCPP_HIDE_FROM_ABI check for example, but that check probably doesn't make sense for any other project. Upstreaming a check would also mean that we'd have to wait up to six months before being able to enforce it.

I too prefer to upstream useful changes; _LIBCPP_HIDE_FROM_ABI is indeed not one of them. I disagree with your assessment. We can do both, implement it locally and upstream it at the same time. That way we can use it directly and remove the local version half a year later.

libcxx/include/charconv

302

Can we exclude this file as asked above?

libcxx/utils/libcxx/test/features.py

24

I thought it changed the clang-tidy version use.

[philnik]

In D131963#3755717, @Mordante wrote:

In D131963#3754322, @philnik wrote:

In D131963#3754318, @avogelsgesang wrote:

is there a reason why we add our own clang-tidy plugin instead of upstreaming this to clang-tidy itself? I could imagine that other library developers could also benefit from this clang-tidy check, if we make the list of allowed customization points a configuration option

We can definitely do this for some checks, but I don't think it makes sense for all checks. I'd like to extend our _LIBCPP_HIDE_FROM_ABI check for example, but that check probably doesn't make sense for any other project. Upstreaming a check would also mean that we'd have to wait up to six months before being able to enforce it.

I too prefer to upstream useful changes; _LIBCPP_HIDE_FROM_ABI is indeed not one of them. I disagree with your assessment. We can do both, implement it locally and upstream it at the same time. That way we can use it directly and remove the local version half a year later.

I didn't mean that we should never upstream it. I meant that if we didn't add a clang-tidy plugin that we'd have to wait up to six months before enabling a check. I'd also rather wait to upstream this check, since it's not very well tested yet. I'd like to check if it catches all ADL that the current ADL tests catch and if not improve the check in a follow-up.

libcxx/include/charconv

302

I'll do that if this lands before your patches, which I don't really expect. There is a reason I didn't consider the comment done yet.

[tschuett]

The LLVM libc has "official" clang tidy checks:
https://github.com/llvm/llvm-project/tree/main/clang-tools-extra/clang-tidy/llvmlibc
I guess there is a buildbot that builds libc and clang-tools-extra.
Even with their own documentation:
https://libc.llvm.org/clang_tidy_checks.html

[ldionne]

libcxx/test/tools/clang_tidy_checks/CMakeLists.txt

3

You should be able to skip the version check below that way.

We'll also have to fix the ClangConfig.cmake file, I don't see a good way of moving forward without that.

14–16

Yes, that seems like the correct thing to do to me.

33

libcxx/utils/ci/run-buildbot

507 ↗

(On Diff #455921)

This looks like a leftover.

[philnik]

• Rebased
• Address comments

[philnik]

• Rebased
• Try to fix CI

[ldionne]

I'd be fine with this as-is if it works in the CI.

IIUC, the current blocker for this is that the ClangConfig.cmake installed by LLVM is not robust to the dev packages missing. If you do find_package(Clang 16.0), it will error out if the dev packages are not present, since it will try to reference static libraries (and other artifacts) that don't exist and try to create IMPORTED targets for those. @smeenai @beanz do you know more about that, or do you know someone that does? Do you know who set up the CMake config files so that find_package(Clang) would work in the first place? I'd also welcome your input on the ClangConfigVersion.cmake.in changes.

Just for the context, what we're trying to do here is simply use clang-tidy's development packages from the libc++ build to add our own custom clang-tidy checks.

Accepting because this LGTM, although we do have some stuff to resolve before this can be shipped.

libcxx/test/tools/clang_tidy_checks/CMakeLists.txt

40

libcxx/test/tools/clang_tidy_checks/robust_against_adl.cpp

23

This is funny, I actually saw a LWG issue about that go by a few weeks ago. I'll try to get more details.

[Mordante]

libcxx/test/tools/clang_tidy_checks/robust_against_adl.cpp

23

@ldionne @jwakely posted this bug report about it https://github.com/llvm/llvm-project/issues/57614

[jwakely]

libcxx/test/tools/clang_tidy_checks/robust_against_adl.cpp

23

They're definitely customization points. If they weren't, specializing is_error_code_enum and is_error_condition_enum would be completely useless and serve no purpose.

LWG confirmed that and LWG 3629 is Tentatively Ready now.

[philnik]

Poke CI

[jwakely]

libcxx/test/tools/clang_tidy_checks/robust_against_adl.cpp

23

I created https://reviews.llvm.org/D134943 to fix those customization points.

[smeenai]

In D131963#3811811, @ldionne wrote:

I'd be fine with this as-is if it works in the CI.

IIUC, the current blocker for this is that the ClangConfig.cmake installed by LLVM is not robust to the dev packages missing. If you do find_package(Clang 16.0), it will error out if the dev packages are not present, since it will try to reference static libraries (and other artifacts) that don't exist and try to create IMPORTED targets for those. @smeenai @beanz do you know more about that, or do you know someone that does? Do you know who set up the CMake config files so that find_package(Clang) would work in the first place? I'd also welcome your input on the ClangConfigVersion.cmake.in changes.

Just for the context, what we're trying to do here is simply use clang-tidy's development packages from the libc++ build to add our own custom clang-tidy checks.

Accepting because this LGTM, although we do have some stuff to resolve before this can be shipped.

IIRC, the intended solution was to use LLVM_DISTRIBUTION_COMPONENTS (https://llvm.org/docs/BuildingADistribution.html). When you use that option, the generated CMake package files (at least in the install tree; I'm not sure about the ones in the build tree) should only contain imported targets that were part of your distribution. Multi-distribution support extends this even further, where the file defining the imported targets for a distribution is only imported if it's present, so things should work as expected both with and without the dev packages. Is that workable for your use case?

[philnik]

In D131963#3831786, @smeenai wrote:

In D131963#3811811, @ldionne wrote:

I'd be fine with this as-is if it works in the CI.

IIUC, the current blocker for this is that the ClangConfig.cmake installed by LLVM is not robust to the dev packages missing. If you do find_package(Clang 16.0), it will error out if the dev packages are not present, since it will try to reference static libraries (and other artifacts) that don't exist and try to create IMPORTED targets for those. @smeenai @beanz do you know more about that, or do you know someone that does? Do you know who set up the CMake config files so that find_package(Clang) would work in the first place? I'd also welcome your input on the ClangConfigVersion.cmake.in changes.

Just for the context, what we're trying to do here is simply use clang-tidy's development packages from the libc++ build to add our own custom clang-tidy checks.

Accepting because this LGTM, although we do have some stuff to resolve before this can be shipped.

IIRC, the intended solution was to use LLVM_DISTRIBUTION_COMPONENTS (https://llvm.org/docs/BuildingADistribution.html). When you use that option, the generated CMake package files (at least in the install tree; I'm not sure about the ones in the build tree) should only contain imported targets that were part of your distribution. Multi-distribution support extends this even further, where the file defining the imported targets for a distribution is only imported if it's present, so things should work as expected both with and without the dev packages. Is that workable for your use case?

That's a thing the vendor has to change, right? If we only get the targets which are actually available it should work just fine.

libcxx/test/tools/clang_tidy_checks/robust_against_adl.cpp

23

Thanks for the info and patch @jwakely!

[smeenai]

In D131963#3845092, @philnik wrote:

In D131963#3831786, @smeenai wrote:

In D131963#3811811, @ldionne wrote:

I'd be fine with this as-is if it works in the CI.

IIUC, the current blocker for this is that the ClangConfig.cmake installed by LLVM is not robust to the dev packages missing. If you do find_package(Clang 16.0), it will error out if the dev packages are not present, since it will try to reference static libraries (and other artifacts) that don't exist and try to create IMPORTED targets for those. @smeenai @beanz do you know more about that, or do you know someone that does? Do you know who set up the CMake config files so that find_package(Clang) would work in the first place? I'd also welcome your input on the ClangConfigVersion.cmake.in changes.

Just for the context, what we're trying to do here is simply use clang-tidy's development packages from the libc++ build to add our own custom clang-tidy checks.

Accepting because this LGTM, although we do have some stuff to resolve before this can be shipped.

IIRC, the intended solution was to use LLVM_DISTRIBUTION_COMPONENTS (https://llvm.org/docs/BuildingADistribution.html). When you use that option, the generated CMake package files (at least in the install tree; I'm not sure about the ones in the build tree) should only contain imported targets that were part of your distribution. Multi-distribution support extends this even further, where the file defining the imported targets for a distribution is only imported if it's present, so things should work as expected both with and without the dev packages. Is that workable for your use case?

That's a thing the vendor has to change, right? If we only get the targets which are actually available it should work just fine.

Correct, that would have to be set up by whoever distributes the LLVM package you're using.

[ldionne]

Let's make those checks optional until we can figure out the packaging stuff, and land this (with green CI). This is going to become way too stale otherwise.

clang/cmake/modules/ClangConfigVersion.cmake.in

2

This has been added in main now.

[philnik]

• Address comments
• Make the checks optional for now

[philnik]

Use the latest llvm-dev version

[philnik]

Rebased

[philnik]

Try to fix CI

[philnik]

Rebased

[philnik]

Try to fix CI

[philnik]

Next try

[philnik]

Only run clang-tidy in some configurations

[philnik]

Next try

[Mordante]

libcxx/test/libcxx/clang_tidy.sh.cpp

15

I actually think it would be better to do this is a separate script.

Is there any documentation on how to run this test?

clang/cmake/modules/ClangConfigVersion.cmake.in

+set(PACKAGE_VERSION "@PACKAGE_VERSION@")
+
+# LLVM is API-compatible only with matching major.minor versions
+# and patch versions not less than that requested.
+if("@CLANG_VERSION_MAJOR@.@CLANG_VERSION_MINOR@" VERSION_EQUAL
+    "${PACKAGE_FIND_VERSION_MAJOR}.${PACKAGE_FIND_VERSION_MINOR}"
+   AND NOT "@CLANG_VERSION_PATCH@" VERSION_LESS "${PACKAGE_FIND_VERSION_PATCH}")
+  set(PACKAGE_VERSION_COMPATIBLE 1)
+  if("@CLANG_VERSION_PATCH@" VERSION_EQUAL
+      "${PACKAGE_FIND_VERSION_PATCH}")
+    set(PACKAGE_VERSION_EXACT 1)
+  endif()
+endif()

libcxx/include/__algorithm/ranges_search_n.h

_LIBCPP_HIDE_FROM_ABI static constexpr subrange<_Iter1> __ranges_search_n_impl(
     if constexpr (sized_sentinel_for<_Sent1, _Iter1>) {
       auto __size = ranges::distance(__first, __last);
       if (__size < __count) {
         ranges::advance(__first, __last);
         return {__first, __first};
       }
 
       if constexpr (random_access_iterator<_Iter1>) {
-        auto __ret = __search_n_random_access_impl<_RangeAlgPolicy>(__first, __last,
-                                                                    __count,
-                                                                    __value,
-                                                                    __pred,
-                                                                    __proj,
-                                                                    __size);
+        auto __ret = std::__search_n_random_access_impl<_RangeAlgPolicy>(
+            __first, __last, __count, __value, __pred, __proj, __size);
         return {std::move(__ret.first), std::move(__ret.second)};
       }
     }
 
     auto __ret = std::__search_n_forward_impl<_RangeAlgPolicy>(__first, __last,
                                                                __count,
                                                                __value,
                                                                __pred,

libcxx/include/__algorithm/sort.h

while (__n > 1) {
     __n >>= 1;
   }
   return __log2;
 }
 
 template <class _WrappedComp, class _RandomAccessIterator>
 _LIBCPP_HIDDEN void __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _WrappedComp __wrapped_comp) {
   typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
-  difference_type __depth_limit = 2 * __log2i(__last - __first);
+  difference_type __depth_limit = 2 * std::__log2i(__last - __first);
 
   using _Unwrap = _UnwrapAlgPolicy<_WrappedComp>;
   using _AlgPolicy = typename _Unwrap::_AlgPolicy;
   using _Compare = typename _Unwrap::_Comp;
   _Compare __comp = _Unwrap::__get_comp(__wrapped_comp);
   std::__introsort<_AlgPolicy, _Compare>(__first, __last, __comp, __depth_limit);
 }
 

libcxx/include/__bit_reference

 #endif
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
     __bit_reference& operator=(const __bit_reference& __x) _NOEXCEPT
         {return operator=(static_cast<bool>(__x));}
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void flip() _NOEXCEPT {*__seg_ ^= __mask_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator<_Cp, false> operator&() const _NOEXCEPT
-        {return __bit_iterator<_Cp, false>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));}
+        {return __bit_iterator<_Cp, false>(__seg_, static_cast<unsigned>(std::__libcpp_ctz(__mask_)));}
 private:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
     explicit __bit_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
         : __seg_(__s), __mask_(__m) {}
 };
 
 template <class _Cp>
 class __bit_reference<_Cp, false>
public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
     __bit_const_reference(const __bit_reference<_Cp>& __x) _NOEXCEPT
         : __seg_(__x.__seg_), __mask_(__x.__mask_) {}
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR operator bool() const _NOEXCEPT
         {return static_cast<bool>(*__seg_ & __mask_);}
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator<_Cp, true> operator&() const _NOEXCEPT
-        {return __bit_iterator<_Cp, true>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));}
+        {return __bit_iterator<_Cp, true>(__seg_, static_cast<unsigned>(std::__libcpp_ctz(__mask_)));}
 private:
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR
     explicit __bit_const_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
         : __seg_(__s), __mask_(__m) {}
 
     __bit_const_reference& operator=(const __bit_const_reference&) = delete;
 };

libcxx/include/__chrono/duration.h

 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename enable_if
 <
     __is_duration<_ToDuration>::value,
     _ToDuration
 >::type
 floor(const duration<_Rep, _Period>& __d)
 {
-    _ToDuration __t = duration_cast<_ToDuration>(__d);
+    _ToDuration __t = chrono::duration_cast<_ToDuration>(__d);
     if (__t > __d)
         __t = __t - _ToDuration{1};
     return __t;
 }
 
 template <class _ToDuration, class _Rep, class _Period>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename enable_if
 <
     __is_duration<_ToDuration>::value,
     _ToDuration
 >::type
 ceil(const duration<_Rep, _Period>& __d)
 {
-    _ToDuration __t = duration_cast<_ToDuration>(__d);
+    _ToDuration __t = chrono::duration_cast<_ToDuration>(__d);
     if (__t < __d)
         __t = __t + _ToDuration{1};
     return __t;
 }
 
 template <class _ToDuration, class _Rep, class _Period>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename enable_if
 <
     __is_duration<_ToDuration>::value,
     _ToDuration
 >::type
 round(const duration<_Rep, _Period>& __d)
 {
-    _ToDuration __lower = floor<_ToDuration>(__d);
+    _ToDuration __lower = chrono::floor<_ToDuration>(__d);
     _ToDuration __upper = __lower + _ToDuration{1};
     auto __lowerDiff = __d - __lower;
     auto __upperDiff = __upper - __d;
     if (__lowerDiff < __upperDiff)
         return __lower;
     if (__lowerDiff > __upperDiff)
         return __upper;
     return __lower.count() & 1 ? __upper : __lower;

libcxx/include/__chrono/hh_mm_ss.h

public:
     _LIBCPP_HIDE_FROM_ABI static unsigned constexpr fractional_width = __width(__CommonType::period::den) < 19 ?
                                                  __width(__CommonType::period::den) : 6u;
     using precision = duration<typename __CommonType::rep, ratio<1, __pow10(fractional_width)>>;
 
     _LIBCPP_HIDE_FROM_ABI constexpr hh_mm_ss() noexcept : hh_mm_ss{_Duration::zero()} {}
 
     _LIBCPP_HIDE_FROM_ABI constexpr explicit hh_mm_ss(_Duration __d) noexcept :
         __is_neg_(__d < _Duration(0)),
-        __h_(duration_cast<chrono::hours>  (abs(__d))),
-        __m_(duration_cast<chrono::minutes>(abs(__d) - hours())),
-        __s_(duration_cast<chrono::seconds>(abs(__d) - hours() - minutes())),
-        __f_(duration_cast<precision>      (abs(__d) - hours() - minutes() - seconds()))
+        __h_(chrono::duration_cast<chrono::hours>  (chrono::abs(__d))),
+        __m_(chrono::duration_cast<chrono::minutes>(chrono::abs(__d) - hours())),
+        __s_(chrono::duration_cast<chrono::seconds>(chrono::abs(__d) - hours() - minutes())),
+        __f_(chrono::duration_cast<precision>      (chrono::abs(__d) - hours() - minutes() - seconds()))
         {}
 
     _LIBCPP_HIDE_FROM_ABI constexpr bool is_negative()        const noexcept { return __is_neg_; }
     _LIBCPP_HIDE_FROM_ABI constexpr chrono::hours hours()     const noexcept { return __h_; }
     _LIBCPP_HIDE_FROM_ABI constexpr chrono::minutes minutes() const noexcept { return __m_; }
     _LIBCPP_HIDE_FROM_ABI constexpr chrono::seconds seconds() const noexcept { return __s_; }
     _LIBCPP_HIDE_FROM_ABI constexpr precision subseconds()    const noexcept { return __f_; }
 

libcxx/include/__chrono/time_point.h

 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename enable_if
 <
     __is_duration<_ToDuration>::value,
     time_point<_Clock, _ToDuration>
 >::type
 floor(const time_point<_Clock, _Duration>& __t)
 {
-    return time_point<_Clock, _ToDuration>{floor<_ToDuration>(__t.time_since_epoch())};
+    return time_point<_Clock, _ToDuration>{chrono::floor<_ToDuration>(__t.time_since_epoch())};
 }
 
 template <class _ToDuration, class _Clock, class _Duration>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename enable_if
 <
     __is_duration<_ToDuration>::value,
     time_point<_Clock, _ToDuration>
 >::type
 ceil(const time_point<_Clock, _Duration>& __t)
 {
-    return time_point<_Clock, _ToDuration>{ceil<_ToDuration>(__t.time_since_epoch())};
+    return time_point<_Clock, _ToDuration>{chrono::ceil<_ToDuration>(__t.time_since_epoch())};
 }
 
 template <class _ToDuration, class _Clock, class _Duration>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename enable_if
 <
     __is_duration<_ToDuration>::value,
     time_point<_Clock, _ToDuration>
 >::type
 round(const time_point<_Clock, _Duration>& __t)
 {
-    return time_point<_Clock, _ToDuration>{round<_ToDuration>(__t.time_since_epoch())};
+    return time_point<_Clock, _ToDuration>{chrono::round<_ToDuration>(__t.time_since_epoch())};
 }
 
 template <class _Rep, class _Period>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename enable_if
 <
     numeric_limits<_Rep>::is_signed,
     duration<_Rep, _Period>

libcxx/include/__compare/common_comparison_category.h

__compute_comp_type(const _ClassifyCompCategory (&__types)[_Size]) {
   return _StrongOrd;
 }
 
 template <class ..._Ts, bool _False = false>
 _LIBCPP_HIDE_FROM_ABI
 constexpr auto __get_comp_type() {
   using _CCC = _ClassifyCompCategory;
   constexpr _CCC __type_kinds[] = {_StrongOrd, __type_to_enum<_Ts>()...};
-  constexpr _CCC _Cat = __compute_comp_type(__type_kinds);
+  constexpr _CCC _Cat = __comp_detail::__compute_comp_type(__type_kinds);
   if constexpr (_Cat == _None)
     return void();
   else if constexpr (_Cat == _PartialOrd)
     return partial_ordering::equivalent;
   else if constexpr (_Cat == _WeakOrd)
     return weak_ordering::equivalent;
   else if constexpr (_Cat == _StrongOrd)
     return strong_ordering::equivalent;

libcxx/include/__compare/partial_order.h

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 // [cmp.alg]
 namespace __partial_order {
     struct __fn {
+    // NOLINTBEGIN(libcpp-robust-against-adl) partial_order should use ADL, but only here
         template<class _Tp, class _Up>
             requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
         _LIBCPP_HIDE_FROM_ABI static constexpr auto
         __go(_Tp&& __t, _Up&& __u, __priority_tag<2>)
             noexcept(noexcept(partial_ordering(partial_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
             -> decltype(      partial_ordering(partial_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
             { return          partial_ordering(partial_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
+    // NOLINTEND(libcpp-robust-against-adl)
 
         template<class _Tp, class _Up>
             requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
         _LIBCPP_HIDE_FROM_ABI static constexpr auto
         __go(_Tp&& __t, _Up&& __u, __priority_tag<1>)
             noexcept(noexcept(partial_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
             -> decltype(      partial_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
             { return          partial_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }

libcxx/include/__compare/strong_order.h

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 // [cmp.alg]
 namespace __strong_order {
     struct __fn {
+    // NOLINTBEGIN(libcpp-robust-against-adl) strong_order should use ADL, but only here
         template<class _Tp, class _Up>
             requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
         _LIBCPP_HIDE_FROM_ABI static constexpr auto
         __go(_Tp&& __t, _Up&& __u, __priority_tag<2>)
             noexcept(noexcept(strong_ordering(strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
             -> decltype(      strong_ordering(strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
             { return          strong_ordering(strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
+    // NOLINTEND(libcpp-robust-against-adl)
 
         template<class _Tp, class _Up, class _Dp = decay_t<_Tp>>
             requires is_same_v<_Dp, decay_t<_Up>> && is_floating_point_v<_Dp>
         _LIBCPP_HIDE_FROM_ABI static constexpr strong_ordering
         __go(_Tp&& __t, _Up&& __u, __priority_tag<1>) noexcept
         {
             if constexpr (numeric_limits<_Dp>::is_iec559 && sizeof(_Dp) == sizeof(int32_t)) {
                 int32_t __rx = _VSTD::bit_cast<int32_t>(__t);

libcxx/include/__compare/weak_order.h

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 // [cmp.alg]
 namespace __weak_order {
     struct __fn {
+    // NOLINTBEGIN(libcpp-robust-against-adl) weak_order should use ADL, but only here
         template<class _Tp, class _Up>
             requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
         _LIBCPP_HIDE_FROM_ABI static constexpr auto
         __go(_Tp&& __t, _Up&& __u, __priority_tag<3>)
             noexcept(noexcept(weak_ordering(weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
             -> decltype(      weak_ordering(weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
             { return          weak_ordering(weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
+    // NOLINTEND(libcpp-robust-against-adl)
 
         template<class _Tp, class _Up, class _Dp = decay_t<_Tp>>
             requires is_same_v<_Dp, decay_t<_Up>> && is_floating_point_v<_Dp>
         _LIBCPP_HIDE_FROM_ABI static constexpr weak_ordering
         __go(_Tp&& __t, _Up&& __u, __priority_tag<2>) noexcept
         {
             partial_ordering __po = (__t <=> __u);
             if (__po == partial_ordering::less) {

libcxx/include/__filesystem/path.h

operator/=(const _Source& __src) {
     return this->append(__src);
   }
 
   template <class _Source>
   _LIBCPP_HIDE_FROM_ABI
   _EnableIfPathable<_Source> append(const _Source& __src) {
     using _Traits = __is_pathable<_Source>;
     using _CVT = _PathCVT<_SourceChar<_Source> >;
-    bool __source_is_absolute = __is_separator(_Traits::__first_or_null(__src));
+    bool __source_is_absolute = _VSTD_FS::__is_separator(_Traits::__first_or_null(__src));
     if (__source_is_absolute)
       __pn_.clear();
     else if (has_filename())
       __pn_ += preferred_separator;
     _CVT::__append_source(__pn_, __src);
     return *this;
   }
 
   template <class _InputIt>
   _LIBCPP_HIDE_FROM_ABI
   path& append(_InputIt __first, _InputIt __last) {
     typedef typename iterator_traits<_InputIt>::value_type _ItVal;
     static_assert(__can_convert_char<_ItVal>::value, "Must convertible");
     using _CVT = _PathCVT<_ItVal>;
-    if (__first != __last && __is_separator(*__first))
+    if (__first != __last && _VSTD_FS::__is_separator(*__first))
       __pn_.clear();
     else if (has_filename())
       __pn_ += preferred_separator;
     _CVT::__append_range(__pn_, __first, __last);
     return *this;
   }
 #endif
 
template <class _ECharT, class _Traits = char_traits<_ECharT>,
             class _Allocator = allocator<_ECharT> >
   _LIBCPP_HIDE_FROM_ABI
   basic_string<_ECharT, _Traits, _Allocator>
   string(const _Allocator& __a = _Allocator()) const {
     using _CVT = __widen_from_utf8<sizeof(_ECharT) * __CHAR_BIT__>;
     using _Str = basic_string<_ECharT, _Traits, _Allocator>;
     _Str __s(__a);
     __s.reserve(__pn_.size());
-    _CVT()(back_inserter(__s), __pn_.data(), __pn_.data() + __pn_.size());
+    _CVT()(std::back_inserter(__s), __pn_.data(), __pn_.data() + __pn_.size());
     return __s;
   }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
   _LIBCPP_HIDE_FROM_ABI _VSTD::wstring wstring() const {
     return string<wchar_t>();
   }
 #endif

libcxx/include/__format/format_arg_store.h

 }
 
 template <class _Context, class... _Args>
 _LIBCPP_HIDE_FROM_ABI void __create_packed_storage(uint64_t& __types, __basic_format_arg_value<_Context>* __values,
                                                    _Args&&... __args) noexcept {
   int __shift = 0;
   (
       [&] {
-        basic_format_arg<_Context> __arg = __create_format_arg<_Context>(__args);
+        basic_format_arg<_Context> __arg = __format::__create_format_arg<_Context>(__args);
         if (__shift != 0)
           __types |= static_cast<uint64_t>(__arg.__type_) << __shift;
         else
           // Assigns the initial value.
           __types = static_cast<uint64_t>(__arg.__type_);
         __shift += __packed_arg_t_bits;
         *__values++ = __arg.__value_;
       }(),
       ...);
 }
 
 template <class _Context, class... _Args>
 _LIBCPP_HIDE_FROM_ABI void __store_basic_format_arg(basic_format_arg<_Context>* __data, _Args&&... __args) noexcept {
-  ([&] { *__data++ = __create_format_arg<_Context>(__args); }(), ...);
+  ([&] { *__data++ = __format::__create_format_arg<_Context>(__args); }(), ...);
 }
 
 template <class _Context, size_t N>
 struct __packed_format_arg_store {
   __basic_format_arg_value<_Context> __values_[N];
   uint64_t __types_;
 };
 

libcxx/include/__format/format_string.h

_LIBCPP_ASSERT(__value <= __number_max,
                  "Compilers don't support this number of arguments");
 
   return {__begin, uint32_t(__value)};
 }
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI constexpr __parse_number_result<_CharT>
 __parse_manual(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
-  __parse_number_result<_CharT> __r = __parse_number(__begin, __end);
+  __parse_number_result<_CharT> __r = __format::__parse_number(__begin, __end);
   __parse_ctx.check_arg_id(__r.__value);
   return __r;
 }
 
 } // namespace __detail
 
 /**
  * Parses a number.

libcxx/include/__format/formatter_floating_point.h

 #  ifndef _LIBCPP_HAS_NO_LOCALIZATION
 template <class _OutIt, class _Fp, class _CharT>
 _LIBCPP_HIDE_FROM_ABI _OutIt __format_locale_specific_form(
     _OutIt __out_it,
     const __float_buffer<_Fp>& __buffer,
     const __float_result& __result,
     _VSTD::locale __loc,
     __format_spec::__parsed_specifications<_CharT> __specs) {
-  const auto& __np = use_facet<numpunct<_CharT>>(__loc);
+  const auto& __np = std::use_facet<numpunct<_CharT>>(__loc);
   string __grouping = __np.grouping();
   char* __first = __result.__integral;
   // When no radix point or exponent are present __last will be __result.__last.
   char* __last = _VSTD::min(__result.__radix_point, __result.__exponent);
 
   ptrdiff_t __digits = __last - __first;
   if (!__grouping.empty()) {
     if (__digits <= __grouping[0])

libcxx/include/__format/formatter_integral.h

_LIBCPP_HIDE_FROM_ABI auto __format_integer(
   if (__specs.__std_.__alternate_form_ && __prefix)
     while (*__prefix)
       *__first++ = *__prefix++;
 
   char* __last = __formatter::__to_buffer(__first, __end, __value, __base);
 
 #  ifndef _LIBCPP_HAS_NO_LOCALIZATION
   if (__specs.__std_.__locale_specific_form_) {
-    const auto& __np  = use_facet<numpunct<_CharT>>(__ctx.locale());
+    const auto& __np  = std::use_facet<numpunct<_CharT>>(__ctx.locale());
     string __grouping = __np.grouping();
     ptrdiff_t __size  = __last - __first;
     // Writing the grouped form has more overhead than the normal output
     // routines. If there will be no separators written the locale-specific
     // form is identical to the normal routine. Test whether to grouped form
     // is required.
     if (!__grouping.empty() && __size > __grouping[0])
       return __formatter::__write_using_decimal_separators(
__format_integer(_Tp __value, auto& __ctx, __format_spec::__parsed_specifications<_CharT> __specs)
   // might not be outputted together:
   // - alternate form may insert a prefix string.
   // - zero-padding may insert additional '0' characters.
   // Therefore the value is processed as a positive unsigned value.
   // The function @ref __insert_sign will a '-' when the value was negative.
   auto __r        = std::__to_unsigned_like(__value);
   bool __negative = __value < 0;
   if (__negative)
-    __r = __complement(__r);
+    __r = std::__complement(__r);
 
   return __formatter::__format_integer(__r, __ctx, __specs, __negative);
 }
 
 //
 // Formatter arithmetic (bool)
 //
 

 #  endif
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI auto
 __format_bool(bool __value, auto& __ctx, __format_spec::__parsed_specifications<_CharT> __specs)
     -> decltype(__ctx.out()) {
 #  ifndef _LIBCPP_HAS_NO_LOCALIZATION
   if (__specs.__std_.__locale_specific_form_) {
-    const auto& __np           = use_facet<numpunct<_CharT>>(__ctx.locale());
+    const auto& __np           = std::use_facet<numpunct<_CharT>>(__ctx.locale());
     basic_string<_CharT> __str = __value ? __np.truename() : __np.falsename();
     return __formatter::__write_string_no_precision(basic_string_view<_CharT>{__str}, __ctx.out(), __specs);
   }
 #  endif
   basic_string_view<_CharT> __str =
       __value ? __formatter::__bool_strings<_CharT>::__true : __formatter::__bool_strings<_CharT>::__false;
   return __formatter::__write(__str.begin(), __str.end(), __ctx.out(), __specs);
 }

libcxx/include/__format/formatter_output.h

if (__specs.__alignment_ == __format_spec::__alignment::__zero_padding) {
     if (__specs.__width_ > __size) {
       // Write zero padding.
       __padding.__before_ = __specs.__width_ - __size;
       __out_it            = __formatter::__fill(_VSTD::move(__out_it), __specs.__width_ - __size, _CharT('0'));
     }
   } else {
     if (__specs.__width_ > __size) {
       // Determine padding and write padding.
-      __padding = __padding_size(__size, __specs.__width_, __specs.__alignment_);
+      __padding = __formatter::__padding_size(__size, __specs.__width_, __specs.__alignment_);
 
       __out_it = __formatter::__fill(_VSTD::move(__out_it), __padding.__before_, __specs.__fill_);
     }
     // Write [sign][prefix].
     __out_it = __formatter::__copy(__begin, __first, _VSTD::move(__out_it));
   }
 
   auto __r = __grouping.rbegin();
_LIBCPP_HIDE_FROM_ABI auto __write_transformed(const _CharT* __first, const _CharT* __last,
                                                __format_spec::__parsed_specifications<_ParserCharT> __specs,
                                                _UnaryOperation __op) -> decltype(__out_it) {
   _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
 
   ptrdiff_t __size = __last - __first;
   if (__size >= __specs.__width_)
     return __formatter::__transform(__first, __last, _VSTD::move(__out_it), __op);
 
-  __padding_size_result __padding = __padding_size(__size, __specs.__width_, __specs.__alignment_);
+  __padding_size_result __padding = __formatter::__padding_size(__size, __specs.__width_, __specs.__alignment_);
   __out_it                        = __formatter::__fill(_VSTD::move(__out_it), __padding.__before_, __specs.__fill_);
   __out_it                        = __formatter::__transform(__first, __last, _VSTD::move(__out_it), __op);
   return __formatter::__fill(_VSTD::move(__out_it), __padding.__after_, __specs.__fill_);
 }
 
 /// Writes additional zero's for the precision before the exponent.
 /// This is used when the precision requested in the format string is larger
 /// than the maximum precision of the floating-point type. These precision
_LIBCPP_HIDE_FROM_ABI auto __write_using_trailing_zeros(
     __format_spec::__parsed_specifications<_ParserCharT> __specs,
     size_t __size,
     const _CharT* __exponent,
     size_t __num_trailing_zeros) -> decltype(__out_it) {
   _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
   _LIBCPP_ASSERT(__num_trailing_zeros > 0, "The overload not writing trailing zeros should have been used");
 
   __padding_size_result __padding =
-      __padding_size(__size + __num_trailing_zeros, __specs.__width_, __specs.__alignment_);
+      __formatter::__padding_size(__size + __num_trailing_zeros, __specs.__width_, __specs.__alignment_);
   __out_it = __formatter::__fill(_VSTD::move(__out_it), __padding.__before_, __specs.__fill_);
   __out_it = __formatter::__copy(__first, __exponent, _VSTD::move(__out_it));
   __out_it = __formatter::__fill(_VSTD::move(__out_it), __num_trailing_zeros, _CharT('0'));
   __out_it = __formatter::__copy(__exponent, __last, _VSTD::move(__out_it));
   return __formatter::__fill(_VSTD::move(__out_it), __padding.__after_, __specs.__fill_);
 }
 
 /// Writes a string using format's width estimation algorithm.
_LIBCPP_HIDE_FROM_ABI auto __write_string(
     basic_string_view<_CharT> __str,
     output_iterator<const _CharT&> auto __out_it,
     __format_spec::__parsed_specifications<_CharT> __specs) -> decltype(__out_it) {
   if (!__specs.__has_precision())
     return __formatter::__write_string_no_precision(__str, _VSTD::move(__out_it), __specs);
 
   int __size = __formatter::__truncate(__str, __specs.__precision_);
 
-  return __write(__str.begin(), __str.end(), _VSTD::move(__out_it), __specs, __size);
+  return __formatter::__write(__str.begin(), __str.end(), _VSTD::move(__out_it), __specs, __size);
 }
 
 } // namespace __formatter
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMATTER_OUTPUT_H

libcxx/include/__format/parser_std_format_spec.h

__parse_arg_id(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
 
   ++__r.__ptr;
   return __r;
 }
 
 template <class _Context>
 _LIBCPP_HIDE_FROM_ABI constexpr uint32_t
 __substitute_arg_id(basic_format_arg<_Context> __format_arg) {
-  return visit_format_arg(
+  return std::visit_format_arg(
       [](auto __arg) -> uint32_t {
         using _Type = decltype(__arg);
         if constexpr (integral<_Type>) {
           if constexpr (signed_integral<_Type>) {
             if (__arg < 0)
               __throw_format_error("A format-spec arg-id replacement shouldn't "
                                    "have a negative value");
           }
_LIBCPP_HIDE_FROM_ABI constexpr __column_width_result<_CharT> __estimate_column_width(
   // ASCII has one caveat; when an ASCII character is followed by a non-ASCII
   // character they might be part of an extended grapheme cluster. For example:
   //   an ASCII letter and a COMBINING ACUTE ACCENT
   // The truncate should happen after the COMBINING ACUTE ACCENT. Therefore we
   // need to scan one code unit beyond the requested precision. When this code
   // unit is non-ASCII we omit the current code unit and let the Grapheme
   // clustering algorithm do its work.
   const _CharT* __it = __str.begin();
-  if (__is_ascii(*__it)) {
+  if (__format_spec::__is_ascii(*__it)) {
     do {
       --__maximum;
       ++__it;
       if (__it == __str.end())
         return {__str.size(), __str.end()};
 
       if (__maximum == 0) {
-        if (__is_ascii(*__it))
+        if (__format_spec::__is_ascii(*__it))
           return {static_cast<size_t>(__it - __str.begin()), __it};
 
         break;
       }
-    } while (__is_ascii(*__it));
+    } while (__format_spec::__is_ascii(*__it));
     --__it;
     ++__maximum;
   }
 
   ptrdiff_t __ascii_size = __it - __str.begin();
   __column_width_result __result =
       __detail::__estimate_column_width_grapheme_clustering(__it, __str.end(), __maximum, __rounding);
 

libcxx/include/__functional/hash.h

 __murmur2_or_cityhash<_Size, 32>::operator()(const void* __key, _Size __len)
 {
     const _Size __m = 0x5bd1e995;
     const _Size __r = 24;
     _Size __h = __len;
     const unsigned char* __data = static_cast<const unsigned char*>(__key);
     for (; __len >= 4; __data += 4, __len -= 4)
     {
-        _Size __k = __loadword<_Size>(__data);
+        _Size __k = std::__loadword<_Size>(__data);
         __k *= __m;
         __k ^= __k >> __r;
         __k *= __m;
         __h *= __m;
         __h ^= __k;
     }
     switch (__len)
     {
static _Size __hash_len_16(_Size __u, _Size __v)
     __b *= __mul;
     return __b;
   }
 
   static _Size __hash_len_0_to_16(const char* __s, _Size __len)
      _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
   {
     if (__len > 8) {
-      const _Size __a = __loadword<_Size>(__s);
-      const _Size __b = __loadword<_Size>(__s + __len - 8);
+      const _Size __a = std::__loadword<_Size>(__s);
+      const _Size __b = std::__loadword<_Size>(__s + __len - 8);
       return __hash_len_16(__a, __rotate_by_at_least_1(__b + __len, __len)) ^ __b;
     }
     if (__len >= 4) {
-      const uint32_t __a = __loadword<uint32_t>(__s);
-      const uint32_t __b = __loadword<uint32_t>(__s + __len - 4);
+      const uint32_t __a = std::__loadword<uint32_t>(__s);
+      const uint32_t __b = std::__loadword<uint32_t>(__s + __len - 4);
       return __hash_len_16(__len + (__a << 3), __b);
     }
     if (__len > 0) {
       const unsigned char __a = static_cast<unsigned char>(__s[0]);
       const unsigned char __b = static_cast<unsigned char>(__s[__len >> 1]);
       const unsigned char __c = static_cast<unsigned char>(__s[__len - 1]);
       const uint32_t __y = static_cast<uint32_t>(__a) +
                            (static_cast<uint32_t>(__b) << 8);
       const uint32_t __z = __len + (static_cast<uint32_t>(__c) << 2);
       return __shift_mix(__y * __k2 ^ __z * __k3) * __k2;
     }
     return __k2;
   }
 
   static _Size __hash_len_17_to_32(const char *__s, _Size __len)
      _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
   {
-    const _Size __a = __loadword<_Size>(__s) * __k1;
-    const _Size __b = __loadword<_Size>(__s + 8);
-    const _Size __c = __loadword<_Size>(__s + __len - 8) * __k2;
-    const _Size __d = __loadword<_Size>(__s + __len - 16) * __k0;
+    const _Size __a = std::__loadword<_Size>(__s) * __k1;
+    const _Size __b = std::__loadword<_Size>(__s + 8);
+    const _Size __c = std::__loadword<_Size>(__s + __len - 8) * __k2;
+    const _Size __d = std::__loadword<_Size>(__s + __len - 16) * __k0;
     return __hash_len_16(__rotate(__a - __b, 43) + __rotate(__c, 30) + __d,
                          __a + __rotate(__b ^ __k3, 20) - __c + __len);
   }
 
   // Return a 16-byte hash for 48 bytes.  Quick and dirty.
   // Callers do best to use "random-looking" values for a and b.
   static pair<_Size, _Size> __weak_hash_len_32_with_seeds(
       _Size __w, _Size __x, _Size __y, _Size __z, _Size __a, _Size __b)
         _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
   {
     __a += __w;
     __b = __rotate(__b + __a + __z, 21);
     const _Size __c = __a;
     __a += __x;
     __a += __y;
     __b += __rotate(__a, 44);
     return pair<_Size, _Size>(__a + __z, __b + __c);
   }
 
   // Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
   static pair<_Size, _Size> __weak_hash_len_32_with_seeds(
       const char* __s, _Size __a, _Size __b)
     _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
   {
-    return __weak_hash_len_32_with_seeds(__loadword<_Size>(__s),
-                                         __loadword<_Size>(__s + 8),
-                                         __loadword<_Size>(__s + 16),
-                                         __loadword<_Size>(__s + 24),
+    return __weak_hash_len_32_with_seeds(std::__loadword<_Size>(__s),
+                                         std::__loadword<_Size>(__s + 8),
+                                         std::__loadword<_Size>(__s + 16),
+                                         std::__loadword<_Size>(__s + 24),
                                          __a,
                                          __b);
   }
 
   // Return an 8-byte hash for 33 to 64 bytes.
   static _Size __hash_len_33_to_64(const char *__s, size_t __len)
     _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
   {
-    _Size __z = __loadword<_Size>(__s + 24);
-    _Size __a = __loadword<_Size>(__s) +
-                (__len + __loadword<_Size>(__s + __len - 16)) * __k0;
+    _Size __z = std::__loadword<_Size>(__s + 24);
+    _Size __a = std::__loadword<_Size>(__s) +
+                (__len + std::__loadword<_Size>(__s + __len - 16)) * __k0;
     _Size __b = __rotate(__a + __z, 52);
     _Size __c = __rotate(__a, 37);
-    __a += __loadword<_Size>(__s + 8);
+    __a += std::__loadword<_Size>(__s + 8);
     __c += __rotate(__a, 7);
-    __a += __loadword<_Size>(__s + 16);
+    __a += std::__loadword<_Size>(__s + 16);
     _Size __vf = __a + __z;
     _Size __vs = __b + __rotate(__a, 31) + __c;
-    __a = __loadword<_Size>(__s + 16) + __loadword<_Size>(__s + __len - 32);
-    __z += __loadword<_Size>(__s + __len - 8);
+    __a = std::__loadword<_Size>(__s + 16) + std::__loadword<_Size>(__s + __len - 32);
+    __z += std::__loadword<_Size>(__s + __len - 8);
     __b = __rotate(__a + __z, 52);
     __c = __rotate(__a, 37);
-    __a += __loadword<_Size>(__s + __len - 24);
+    __a += std::__loadword<_Size>(__s + __len - 24);
     __c += __rotate(__a, 7);
-    __a += __loadword<_Size>(__s + __len - 16);
+    __a += std::__loadword<_Size>(__s + __len - 16);
     _Size __wf = __a + __z;
     _Size __ws = __b + __rotate(__a, 31) + __c;
     _Size __r = __shift_mix((__vf + __ws) * __k2 + (__wf + __vs) * __k0);
     return __shift_mix(__r * __k0 + __vs) * __k2;
   }
 };
 
 // cityhash64
if (__len <= 16) {
       return __hash_len_17_to_32(__s, __len);
     }
   } else if (__len <= 64) {
     return __hash_len_33_to_64(__s, __len);
   }
 
   // For strings over 64 bytes we hash the end first, and then as we
   // loop we keep 56 bytes of state: v, w, x, y, and z.
-  _Size __x = __loadword<_Size>(__s + __len - 40);
-  _Size __y = __loadword<_Size>(__s + __len - 16) +
-              __loadword<_Size>(__s + __len - 56);
-  _Size __z = __hash_len_16(__loadword<_Size>(__s + __len - 48) + __len,
-                          __loadword<_Size>(__s + __len - 24));
+  _Size __x = std::__loadword<_Size>(__s + __len - 40);
+  _Size __y = std::__loadword<_Size>(__s + __len - 16) +
+              std::__loadword<_Size>(__s + __len - 56);
+  _Size __z = __hash_len_16(std::__loadword<_Size>(__s + __len - 48) + __len,
+                          std::__loadword<_Size>(__s + __len - 24));
   pair<_Size, _Size> __v = __weak_hash_len_32_with_seeds(__s + __len - 64, __len, __z);
   pair<_Size, _Size> __w = __weak_hash_len_32_with_seeds(__s + __len - 32, __y + __k1, __x);
-  __x = __x * __k1 + __loadword<_Size>(__s);
+  __x = __x * __k1 + std::__loadword<_Size>(__s);
 
   // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
   __len = (__len - 1) & ~static_cast<_Size>(63);
   do {
-    __x = __rotate(__x + __y + __v.first + __loadword<_Size>(__s + 8), 37) * __k1;
-    __y = __rotate(__y + __v.second + __loadword<_Size>(__s + 48), 42) * __k1;
+    __x = __rotate(__x + __y + __v.first + std::__loadword<_Size>(__s + 8), 37) * __k1;
+    __y = __rotate(__y + __v.second + std::__loadword<_Size>(__s + 48), 42) * __k1;
     __x ^= __w.second;
-    __y += __v.first + __loadword<_Size>(__s + 40);
+    __y += __v.first + std::__loadword<_Size>(__s + 40);
     __z = __rotate(__z + __w.first, 33) * __k1;
     __v = __weak_hash_len_32_with_seeds(__s, __v.second * __k1, __x + __w.first);
     __w = __weak_hash_len_32_with_seeds(__s + 32, __z + __w.second,
-                                        __y + __loadword<_Size>(__s + 16));
+                                        __y + std::__loadword<_Size>(__s + 16));
     _VSTD::swap(__z, __x);
     __s += 64;
     __len -= 64;
   } while (__len != 0);
   return __hash_len_16(
       __hash_len_16(__v.first, __w.first) + __shift_mix(__y) * __k1 + __z,
       __hash_len_16(__v.second, __w.second) + __x);
 }

libcxx/include/__hash_table

pointer operator->() const {
         return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__value_);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __hash_local_iterator& operator++() {
         _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
                        "Attempted to increment a non-incrementable unordered container local_iterator");
         __node_ = __node_->__next_;
-        if (__node_ != nullptr && __constrain_hash(__node_->__hash(), __bucket_count_) != __bucket_)
+        if (__node_ != nullptr && std::__constrain_hash(__node_->__hash(), __bucket_count_) != __bucket_)
             __node_ = nullptr;
         return *this;
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __hash_local_iterator operator++(int)
     {
         __hash_local_iterator __t(*this);
pointer operator->() const {
         return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__value_);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __hash_const_local_iterator& operator++() {
         _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
                        "Attempted to increment a non-incrementable unordered container const_local_iterator");
         __node_ = __node_->__next_;
-        if (__node_ != nullptr && __constrain_hash(__node_->__hash(), __bucket_count_) != __bucket_)
+        if (__node_ != nullptr && std::__constrain_hash(__node_->__hash(), __bucket_count_) != __bucket_)
             __node_ = nullptr;
         return *this;
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __hash_const_local_iterator operator++(int)
     {
         __hash_const_local_iterator __t(*this);
#if _LIBCPP_STD_VER > 14
     _NodeHandle __node_handle_extract(const_iterator __it);
 #endif
 
     void clear() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY void __rehash_unique(size_type __n) { __rehash<true>(__n); }
     _LIBCPP_INLINE_VISIBILITY void __rehash_multi(size_type __n) { __rehash<false>(__n); }
     _LIBCPP_INLINE_VISIBILITY void __reserve_unique(size_type __n)
     {
-        __rehash_unique(static_cast<size_type>(ceil(__n / max_load_factor())));
+        __rehash_unique(static_cast<size_type>(std::ceil(__n / max_load_factor())));
     }
     _LIBCPP_INLINE_VISIBILITY void __reserve_multi(size_type __n)
     {
-        __rehash_multi(static_cast<size_type>(ceil(__n / max_load_factor())));
+        __rehash_multi(static_cast<size_type>(std::ceil(__n / max_load_factor())));
     }
 
     _LIBCPP_INLINE_VISIBILITY
     size_type bucket_count() const _NOEXCEPT
     {
         return __bucket_list_.get_deleter().size();
     }
 
     _LIBCPP_INLINE_VISIBILITY
     iterator       begin() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     iterator       end() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     const_iterator begin() const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     const_iterator end() const _NOEXCEPT;
 
     template <class _Key>
         _LIBCPP_INLINE_VISIBILITY
         size_type bucket(const _Key& __k) const
         {
             _LIBCPP_ASSERT(bucket_count() > 0,
                 "unordered container::bucket(key) called when bucket_count() == 0");
-            return __constrain_hash(hash_function()(__k), bucket_count());
+            return std::__constrain_hash(hash_function()(__k), bucket_count());
         }
 
     template <class _Key>
         iterator       find(const _Key& __x);
     template <class _Key>
         const_iterator find(const _Key& __x) const;
 
     typedef __hash_node_destructor<__node_allocator> _Dp;
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u)
             is_nothrow_move_constructible<key_equal>::value)
     : __bucket_list_(_VSTD::move(__u.__bucket_list_)),
       __p1_(_VSTD::move(__u.__p1_)),
       __p2_(_VSTD::move(__u.__p2_)),
       __p3_(_VSTD::move(__u.__p3_))
 {
     if (size() > 0)
     {
-        __bucket_list_[__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
+        __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
             __p1_.first().__ptr();
         __u.__p1_.first().__next_ = nullptr;
         __u.size() = 0;
     }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u,
                                                        const allocator_type& __a)
     : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
       __p1_(__default_init_tag(), __node_allocator(__a)),
       __p2_(0, _VSTD::move(__u.hash_function())),
       __p3_(_VSTD::move(__u.__p3_))
 {
     if (__a == allocator_type(__u.__node_alloc()))
     {
         __bucket_list_.reset(__u.__bucket_list_.release());
         __bucket_list_.get_deleter().size() = __u.__bucket_list_.get_deleter().size();
         __u.__bucket_list_.get_deleter().size() = 0;
         if (__u.size() > 0)
         {
             __p1_.first().__next_ = __u.__p1_.first().__next_;
             __u.__p1_.first().__next_ = nullptr;
-            __bucket_list_[__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
+            __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
                 __p1_.first().__ptr();
             size() = __u.size();
             __u.size() = 0;
         }
     }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
     __move_assign_alloc(__u);
     size() = __u.size();
     hash_function() = _VSTD::move(__u.hash_function());
     max_load_factor() = __u.max_load_factor();
     key_eq() = _VSTD::move(__u.key_eq());
     __p1_.first().__next_ = __u.__p1_.first().__next_;
     if (size() > 0)
     {
-        __bucket_list_[__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
+        __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
             __p1_.first().__ptr();
         __u.__p1_.first().__next_ = nullptr;
         __u.size() = 0;
     }
     std::__debug_db_swap(this, std::addressof(__u));
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>

 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__next_pointer
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique_prepare(
     size_t __hash, value_type& __value)
 {
     size_type __bc = bucket_count();
 
     if (__bc != 0)
     {
-        size_t __chash = __constrain_hash(__hash, __bc);
+        size_t __chash = std::__constrain_hash(__hash, __bc);
         __next_pointer __ndptr = __bucket_list_[__chash];
         if (__ndptr != nullptr)
         {
             for (__ndptr = __ndptr->__next_; __ndptr != nullptr &&
-                                             __constrain_hash(__ndptr->__hash(), __bc) == __chash;
+                                             std::__constrain_hash(__ndptr->__hash(), __bc) == __chash;
                                                      __ndptr = __ndptr->__next_)
             {
                 if (key_eq()(__ndptr->__upcast()->__value_, __value))
                     return __ndptr;
             }
         }
     }
     if (size()+1 > __bc * max_load_factor() || __bc == 0)
     {
-        __rehash_unique(_VSTD::max<size_type>(2 * __bc + !__is_hash_power2(__bc),
-                                     size_type(ceil(float(size() + 1) / max_load_factor()))));
+        __rehash_unique(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc),
+                                     size_type(std::ceil(float(size() + 1) / max_load_factor()))));
     }
     return nullptr;
 }
 
 // Insert the node __nd into the container by pushing it into the right bucket,
 // and updating size(). Assumes that __nd->__hash is up-to-date, and that
 // rehashing has already occurred and that no element with the same key exists
 // in the map.
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 _LIBCPP_INLINE_VISIBILITY
 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique_perform(
     __node_pointer __nd) _NOEXCEPT
 {
     size_type __bc = bucket_count();
-    size_t __chash = __constrain_hash(__nd->__hash(), __bc);
+    size_t __chash = std::__constrain_hash(__nd->__hash(), __bc);
     // insert_after __bucket_list_[__chash], or __first_node if bucket is null
     __next_pointer __pn = __bucket_list_[__chash];
     if (__pn == nullptr)
     {
         __pn =__p1_.first().__ptr();
         __nd->__next_ = __pn->__next_;
         __pn->__next_ = __nd->__ptr();
         // fix up __bucket_list_
         __bucket_list_[__chash] = __pn;
         if (__nd->__next_ != nullptr)
-            __bucket_list_[__constrain_hash(__nd->__next_->__hash(), __bc)] = __nd->__ptr();
+            __bucket_list_[std::__constrain_hash(__nd->__next_->__hash(), __bc)] = __nd->__ptr();
     }
     else
     {
         __nd->__next_ = __pn->__next_;
         __pn->__next_ = __nd->__ptr();
     }
     ++size();
 }

 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__next_pointer
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi_prepare(
     size_t __cp_hash, value_type& __cp_val)
 {
     size_type __bc = bucket_count();
     if (size()+1 > __bc * max_load_factor() || __bc == 0)
     {
-        __rehash_multi(_VSTD::max<size_type>(2 * __bc + !__is_hash_power2(__bc),
-                       size_type(ceil(float(size() + 1) / max_load_factor()))));
+        __rehash_multi(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc),
+                       size_type(std::ceil(float(size() + 1) / max_load_factor()))));
         __bc = bucket_count();
     }
-    size_t __chash = __constrain_hash(__cp_hash, __bc);
+    size_t __chash = std::__constrain_hash(__cp_hash, __bc);
     __next_pointer __pn = __bucket_list_[__chash];
     if (__pn != nullptr)
     {
         for (bool __found = false; __pn->__next_ != nullptr &&
-                                   __constrain_hash(__pn->__next_->__hash(), __bc) == __chash;
+                                   std::__constrain_hash(__pn->__next_->__hash(), __bc) == __chash;
                                                            __pn = __pn->__next_)
         {
             //      __found    key_eq()     action
             //      false       false       loop
             //      true        true        loop
             //      false       true        set __found to true
             //      true        false       break
             if (__found != (__pn->__next_->__hash() == __cp_hash &&

 // all we need to do is update the bucket and size(). Assumes that __cp->__hash
 // is up-to-date.
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi_perform(
     __node_pointer __cp, __next_pointer __pn) _NOEXCEPT
 {
     size_type __bc = bucket_count();
-    size_t __chash = __constrain_hash(__cp->__hash_, __bc);
+    size_t __chash = std::__constrain_hash(__cp->__hash_, __bc);
     if (__pn == nullptr)
     {
         __pn =__p1_.first().__ptr();
         __cp->__next_ = __pn->__next_;
         __pn->__next_ = __cp->__ptr();
         // fix up __bucket_list_
         __bucket_list_[__chash] = __pn;
         if (__cp->__next_ != nullptr)
-            __bucket_list_[__constrain_hash(__cp->__next_->__hash(), __bc)]
+            __bucket_list_[std::__constrain_hash(__cp->__next_->__hash(), __bc)]
                 = __cp->__ptr();
     }
     else
     {
         __cp->__next_ = __pn->__next_;
         __pn->__next_ = __cp->__ptr();
         if (__cp->__next_ != nullptr)
         {
-            size_t __nhash = __constrain_hash(__cp->__next_->__hash(), __bc);
+            size_t __nhash = std::__constrain_hash(__cp->__next_->__hash(), __bc);
             if (__nhash != __chash)
                 __bucket_list_[__nhash] = __cp->__ptr();
         }
     }
     ++size();
 }
 
 
_LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
                          " referring to this unordered container");
     if (__p != end() && key_eq()(*__p, __cp->__value_))
     {
         __next_pointer __np = __p.__node_;
         __cp->__hash_ = __np->__hash();
         size_type __bc = bucket_count();
         if (size()+1 > __bc * max_load_factor() || __bc == 0)
         {
-            __rehash_multi(_VSTD::max<size_type>(2 * __bc + !__is_hash_power2(__bc),
-                           size_type(ceil(float(size() + 1) / max_load_factor()))));
+            __rehash_multi(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc),
+                           size_type(std::ceil(float(size() + 1) / max_load_factor()))));
             __bc = bucket_count();
         }
-        size_t __chash = __constrain_hash(__cp->__hash_, __bc);
+        size_t __chash = std::__constrain_hash(__cp->__hash_, __bc);
         __next_pointer __pp = __bucket_list_[__chash];
         while (__pp->__next_ != __np)
             __pp = __pp->__next_;
         __cp->__next_ = __np;
         __pp->__next_ = static_cast<__next_pointer>(__cp);
         ++size();
         return iterator(static_cast<__next_pointer>(__cp), this);
     }
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args)
 
     size_t __hash = hash_function()(__k);
     size_type __bc = bucket_count();
     bool __inserted = false;
     __next_pointer __nd;
     size_t __chash;
     if (__bc != 0)
     {
-        __chash = __constrain_hash(__hash, __bc);
+        __chash = std::__constrain_hash(__hash, __bc);
         __nd = __bucket_list_[__chash];
         if (__nd != nullptr)
         {
             for (__nd = __nd->__next_; __nd != nullptr &&
-                (__nd->__hash() == __hash || __constrain_hash(__nd->__hash(), __bc) == __chash);
+                (__nd->__hash() == __hash || std::__constrain_hash(__nd->__hash(), __bc) == __chash);
                                                            __nd = __nd->__next_)
             {
                 if (key_eq()(__nd->__upcast()->__value_, __k))
                     goto __done;
             }
         }
     }
     {
         __node_holder __h = __construct_node_hash(__hash, _VSTD::forward<_Args>(__args)...);
         if (size()+1 > __bc * max_load_factor() || __bc == 0)
         {
-            __rehash_unique(_VSTD::max<size_type>(2 * __bc + !__is_hash_power2(__bc),
-                           size_type(ceil(float(size() + 1) / max_load_factor()))));
+            __rehash_unique(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc),
+                           size_type(std::ceil(float(size() + 1) / max_load_factor()))));
             __bc = bucket_count();
-            __chash = __constrain_hash(__hash, __bc);
+            __chash = std::__constrain_hash(__hash, __bc);
         }
         // insert_after __bucket_list_[__chash], or __first_node if bucket is null
         __next_pointer __pn = __bucket_list_[__chash];
         if (__pn == nullptr)
         {
             __pn = __p1_.first().__ptr();
             __h->__next_ = __pn->__next_;
             __pn->__next_ = __h.get()->__ptr();
             // fix up __bucket_list_
             __bucket_list_[__chash] = __pn;
             if (__h->__next_ != nullptr)
-                __bucket_list_[__constrain_hash(__h->__next_->__hash(), __bc)]
+                __bucket_list_[std::__constrain_hash(__h->__next_->__hash(), __bc)]
                     = __h.get()->__ptr();
         }
         else
         {
             __h->__next_ = __pn->__next_;
             __pn->__next_ = static_cast<__next_pointer>(__h.get());
         }
         __nd = static_cast<__next_pointer>(__h.release());

 template <bool _UniqueKeys>
 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__rehash(size_type __n)
 _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
 {
     if (__n == 1)
         __n = 2;
     else if (__n & (__n - 1))
-        __n = __next_prime(__n);
+        __n = std::__next_prime(__n);
     size_type __bc = bucket_count();
     if (__n > __bc)
         __do_rehash<_UniqueKeys>(__n);
     else if (__n < __bc)
     {
         __n = _VSTD::max<size_type>
               (
                   __n,
-                  __is_hash_power2(__bc) ? __next_hash_pow2(size_t(ceil(float(size()) / max_load_factor()))) :
-                                           __next_prime(size_t(ceil(float(size()) / max_load_factor())))
+                  std::__is_hash_power2(__bc) ? std::__next_hash_pow2(size_t(std::ceil(float(size()) / max_load_factor()))) :
+                                           std::__next_prime(size_t(std::ceil(float(size()) / max_load_factor())))
               );
         if (__n < __bc)
             __do_rehash<_UniqueKeys>(__n);
     }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <bool _UniqueKeys>
 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__do_rehash(size_type __nbc)
 {
     std::__debug_db_invalidate_all(this);
     __pointer_allocator& __npa = __bucket_list_.get_deleter().__alloc();
     __bucket_list_.reset(__nbc > 0 ?
                       __pointer_alloc_traits::allocate(__npa, __nbc) : nullptr);
     __bucket_list_.get_deleter().size() = __nbc;
     if (__nbc > 0)
     {
         for (size_type __i = 0; __i < __nbc; ++__i)
             __bucket_list_[__i] = nullptr;
         __next_pointer __pp = __p1_.first().__ptr();
         __next_pointer __cp = __pp->__next_;
         if (__cp != nullptr)
         {
-            size_type __chash = __constrain_hash(__cp->__hash(), __nbc);
+            size_type __chash = std::__constrain_hash(__cp->__hash(), __nbc);
             __bucket_list_[__chash] = __pp;
             size_type __phash = __chash;
             for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr;
                                                            __cp = __pp->__next_)
             {
-                __chash = __constrain_hash(__cp->__hash(), __nbc);
+                __chash = std::__constrain_hash(__cp->__hash(), __nbc);
                 if (__chash == __phash)
                     __pp = __cp;
                 else
                 {
                     if (__bucket_list_[__chash] == nullptr)
                     {
                         __bucket_list_[__chash] = __pp;
                         __pp = __cp;

 template <class _Key>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::find(const _Key& __k)
 {
     size_t __hash = hash_function()(__k);
     size_type __bc = bucket_count();
     if (__bc != 0)
     {
-        size_t __chash = __constrain_hash(__hash, __bc);
+        size_t __chash = std::__constrain_hash(__hash, __bc);
         __next_pointer __nd = __bucket_list_[__chash];
         if (__nd != nullptr)
         {
             for (__nd = __nd->__next_; __nd != nullptr &&
                 (__nd->__hash() == __hash
-                  || __constrain_hash(__nd->__hash(), __bc) == __chash);
+                  || std::__constrain_hash(__nd->__hash(), __bc) == __chash);
                                                            __nd = __nd->__next_)
             {
                 if ((__nd->__hash() == __hash)
                     && key_eq()(__nd->__upcast()->__value_, __k))
                     return iterator(__nd, this);
             }
         }
     }
     return end();
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _Key>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::find(const _Key& __k) const
 {
     size_t __hash = hash_function()(__k);
     size_type __bc = bucket_count();
     if (__bc != 0)
     {
-        size_t __chash = __constrain_hash(__hash, __bc);
+        size_t __chash = std::__constrain_hash(__hash, __bc);
         __next_pointer __nd = __bucket_list_[__chash];
         if (__nd != nullptr)
         {
             for (__nd = __nd->__next_; __nd != nullptr &&
                 (__hash == __nd->__hash()
-                    || __constrain_hash(__nd->__hash(), __bc) == __chash);
+                    || std::__constrain_hash(__nd->__hash(), __bc) == __chash);
                                                            __nd = __nd->__next_)
             {
                 if ((__nd->__hash() == __hash)
                     && key_eq()(__nd->__upcast()->__value_, __k))
                     return const_iterator(__nd, this);
             }
         }
 

 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p) _NOEXCEPT
 {
     // current node
     __next_pointer __cn = __p.__node_;
     size_type __bc = bucket_count();
-    size_t __chash = __constrain_hash(__cn->__hash(), __bc);
+    size_t __chash = std::__constrain_hash(__cn->__hash(), __bc);
     // find previous node
     __next_pointer __pn = __bucket_list_[__chash];
     for (; __pn->__next_ != __cn; __pn = __pn->__next_)
         ;
     // Fix up __bucket_list_
         // if __pn is not in same bucket (before begin is not in same bucket) &&
         //    if __cn->__next_ is not in same bucket (nullptr is not in same bucket)
     if (__pn == __p1_.first().__ptr()
-            || __constrain_hash(__pn->__hash(), __bc) != __chash)
+            || std::__constrain_hash(__pn->__hash(), __bc) != __chash)
     {
         if (__cn->__next_ == nullptr
-            || __constrain_hash(__cn->__next_->__hash(), __bc) != __chash)
+            || std::__constrain_hash(__cn->__next_->__hash(), __bc) != __chash)
             __bucket_list_[__chash] = nullptr;
     }
         // if __cn->__next_ is not in same bucket (nullptr is in same bucket)
     if (__cn->__next_ != nullptr)
     {
-        size_t __nhash = __constrain_hash(__cn->__next_->__hash(), __bc);
+        size_t __nhash = std::__constrain_hash(__cn->__next_->__hash(), __bc);
         if (__nhash != __chash)
             __bucket_list_[__nhash] = __pn;
     }
     // remove __cn
     __pn->__next_ = __cn->__next_;
     __cn->__next_ = nullptr;
     --size();
 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
#endif
     _VSTD::swap(__bucket_list_.get_deleter().size(), __u.__bucket_list_.get_deleter().size());
     _VSTD::__swap_allocator(__bucket_list_.get_deleter().__alloc(),
              __u.__bucket_list_.get_deleter().__alloc());
     _VSTD::__swap_allocator(__node_alloc(), __u.__node_alloc());
     _VSTD::swap(__p1_.first().__next_, __u.__p1_.first().__next_);
     __p2_.swap(__u.__p2_);
     __p3_.swap(__u.__p3_);
     if (size() > 0)
-        __bucket_list_[__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
+        __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
             __p1_.first().__ptr();
     if (__u.size() > 0)
-        __u.__bucket_list_[__constrain_hash(__u.__p1_.first().__next_->__hash(), __u.bucket_count())] =
+        __u.__bucket_list_[std::__constrain_hash(__u.__p1_.first().__next_->__hash(), __u.bucket_count())] =
             __u.__p1_.first().__ptr();
     std::__debug_db_swap(this, std::addressof(__u));
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::bucket_size(size_type __n) const
 {
     _LIBCPP_ASSERT(__n < bucket_count(),
         "unordered container::bucket_size(n) called with n >= bucket_count()");
     __next_pointer __np = __bucket_list_[__n];
     size_type __bc = bucket_count();
     size_type __r = 0;
     if (__np != nullptr)
     {
         for (__np = __np->__next_; __np != nullptr &&
-                                   __constrain_hash(__np->__hash(), __bc) == __n;
+                                   std::__constrain_hash(__np->__hash(), __bc) == __n;
                                                          __np = __np->__next_, (void) ++__r)
             ;
     }
     return __r;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 void

libcxx/include/__iterator/common_iterator.h

common_iterator& operator=(const common_iterator<_I2, _S2>& __other) {
     else if (__other_idx == 0)
       __hold_.template emplace<0>(_VSTD::__unchecked_get<0>(__other.__hold_));
 
     return *this;
   }
 
   constexpr decltype(auto) operator*()
   {
-    _LIBCPP_ASSERT(holds_alternative<_Iter>(__hold_), "Attempted to dereference a non-dereferenceable common_iterator");
+    _LIBCPP_ASSERT(std::holds_alternative<_Iter>(__hold_), "Attempted to dereference a non-dereferenceable common_iterator");
     return *_VSTD::__unchecked_get<_Iter>(__hold_);
   }
 
   constexpr decltype(auto) operator*() const
     requires __dereferenceable<const _Iter>
   {
-    _LIBCPP_ASSERT(holds_alternative<_Iter>(__hold_), "Attempted to dereference a non-dereferenceable common_iterator");
+    _LIBCPP_ASSERT(std::holds_alternative<_Iter>(__hold_), "Attempted to dereference a non-dereferenceable common_iterator");
     return *_VSTD::__unchecked_get<_Iter>(__hold_);
   }
 
   template<class _I2 = _Iter>
   decltype(auto) operator->() const
     requires indirectly_readable<const _I2> &&
     (requires(const _I2& __i) { __i.operator->(); } ||
      is_reference_v<iter_reference_t<_I2>> ||
      constructible_from<iter_value_t<_I2>, iter_reference_t<_I2>>)
   {
-    _LIBCPP_ASSERT(holds_alternative<_Iter>(__hold_), "Attempted to dereference a non-dereferenceable common_iterator");
+    _LIBCPP_ASSERT(std::holds_alternative<_Iter>(__hold_), "Attempted to dereference a non-dereferenceable common_iterator");
     if constexpr (is_pointer_v<_Iter> || requires(const _Iter& __i) { __i.operator->(); })    {
       return _VSTD::__unchecked_get<_Iter>(__hold_);
     } else if constexpr (is_reference_v<iter_reference_t<_Iter>>) {
       auto&& __tmp = *_VSTD::__unchecked_get<_Iter>(__hold_);
       return _VSTD::addressof(__tmp);
     } else {
       return __proxy{*_VSTD::__unchecked_get<_Iter>(__hold_)};
     }
   }
 
   common_iterator& operator++() {
-    _LIBCPP_ASSERT(holds_alternative<_Iter>(__hold_), "Attempted to increment a non-dereferenceable common_iterator");
+    _LIBCPP_ASSERT(std::holds_alternative<_Iter>(__hold_), "Attempted to increment a non-dereferenceable common_iterator");
     ++_VSTD::__unchecked_get<_Iter>(__hold_); return *this;
   }
 
   decltype(auto) operator++(int) {
-    _LIBCPP_ASSERT(holds_alternative<_Iter>(__hold_), "Attempted to increment a non-dereferenceable common_iterator");
+    _LIBCPP_ASSERT(std::holds_alternative<_Iter>(__hold_), "Attempted to increment a non-dereferenceable common_iterator");
     if constexpr (forward_iterator<_Iter>) {
       auto __tmp = *this;
       ++*this;
       return __tmp;
     } else if constexpr (requires (_Iter& __i) { { *__i++ } -> __can_reference; } ||
                          !__can_use_postfix_proxy<_Iter>) {
       return _VSTD::__unchecked_get<_Iter>(__hold_)++;
     } else {
friend constexpr iter_difference_t<_I2> operator-(const common_iterator& __x, const common_iterator<_I2, _S2>& __y) {
 
     return _VSTD::__unchecked_get<_Sent>(__x.__hold_) - _VSTD::__unchecked_get<_I2>(__y.__hold_);
   }
 
   _LIBCPP_HIDE_FROM_ABI friend constexpr iter_rvalue_reference_t<_Iter> iter_move(const common_iterator& __i)
     noexcept(noexcept(ranges::iter_move(declval<const _Iter&>())))
       requires input_iterator<_Iter>
   {
-    _LIBCPP_ASSERT(holds_alternative<_Iter>(__i.__hold_), "Attempted to iter_move a non-dereferenceable common_iterator");
+    _LIBCPP_ASSERT(std::holds_alternative<_Iter>(__i.__hold_), "Attempted to iter_move a non-dereferenceable common_iterator");
     return ranges::iter_move( _VSTD::__unchecked_get<_Iter>(__i.__hold_));
   }
 
   template<indirectly_swappable<_Iter> _I2, class _S2>
   _LIBCPP_HIDE_FROM_ABI friend constexpr void iter_swap(const common_iterator& __x, const common_iterator<_I2, _S2>& __y)
       noexcept(noexcept(ranges::iter_swap(declval<const _Iter&>(), declval<const _I2&>())))
   {
-    _LIBCPP_ASSERT(holds_alternative<_Iter>(__x.__hold_), "Attempted to iter_swap a non-dereferenceable common_iterator");
-    _LIBCPP_ASSERT(holds_alternative<_I2>(__y.__hold_), "Attempted to iter_swap a non-dereferenceable common_iterator");
+    _LIBCPP_ASSERT(std::holds_alternative<_Iter>(__x.__hold_), "Attempted to iter_swap a non-dereferenceable common_iterator");
+    _LIBCPP_ASSERT(std::holds_alternative<_I2>(__y.__hold_), "Attempted to iter_swap a non-dereferenceable common_iterator");
     return ranges::iter_swap(_VSTD::__unchecked_get<_Iter>(__x.__hold_), _VSTD::__unchecked_get<_I2>(__y.__hold_));
   }
 };
 
 template<class _Iter, class _Sent>
 struct incrementable_traits<common_iterator<_Iter, _Sent>> {
   using difference_type = iter_difference_t<_Iter>;
 };

libcxx/include/__iterator/iter_move.h

 namespace __iter_move {
 
 void iter_move();
 
 template <class _Tp>
 concept __unqualified_iter_move =
   __class_or_enum<remove_cvref_t<_Tp>> &&
   requires (_Tp&& __t) {
+    // NOLINTNEXTLINE(libcpp-robust-against-adl) iter_swap ADL calls should only be made through ranges::iter_swap
     iter_move(std::forward<_Tp>(__t));
   };
 
 template<class _Tp>
 concept __move_deref =
   !__unqualified_iter_move<_Tp> &&
   requires (_Tp&& __t) {
     *__t;
     requires is_lvalue_reference_v<decltype(*__t)>;
   };
 
 template<class _Tp>
 concept __just_deref =
   !__unqualified_iter_move<_Tp> &&
   !__move_deref<_Tp> &&
   requires (_Tp&& __t) {
     *__t;
     requires (!is_lvalue_reference_v<decltype(*__t)>);
   };
 
 // [iterator.cust.move]
 
 struct __fn {
+  // NOLINTBEGIN(libcpp-robust-against-adl) iter_move ADL calls should only be made through ranges::iter_move
   template<class _Ip>
     requires __unqualified_iter_move<_Ip>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator()(_Ip&& __i) const
     noexcept(noexcept(iter_move(std::forward<_Ip>(__i))))
   {
     return iter_move(std::forward<_Ip>(__i));
   }
+  // NOLINTEND(libcpp-robust-against-adl)
 
   template<class _Ip>
     requires __move_deref<_Ip>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ip&& __i) const
     noexcept(noexcept(std::move(*std::forward<_Ip>(__i))))
     -> decltype(      std::move(*std::forward<_Ip>(__i)))
     { return          std::move(*std::forward<_Ip>(__i)); }
 

libcxx/include/__iterator/iter_swap.h

 namespace __iter_swap {
   template<class _I1, class _I2>
   void iter_swap(_I1, _I2) = delete;
 
   template<class _T1, class _T2>
   concept __unqualified_iter_swap =
     (__class_or_enum<remove_cvref_t<_T1>> || __class_or_enum<remove_cvref_t<_T2>>) &&
     requires (_T1&& __x, _T2&& __y) {
+      // NOLINTNEXTLINE(libcpp-robust-against-adl) iter_swap ADL calls should only be made through ranges::iter_swap
       iter_swap(_VSTD::forward<_T1>(__x), _VSTD::forward<_T2>(__y));
     };
 
   template<class _T1, class _T2>
   concept __readable_swappable =
     indirectly_readable<_T1> && indirectly_readable<_T2> &&
     swappable_with<iter_reference_t<_T1>, iter_reference_t<_T2>>;
 
+
   struct __fn {
+    // NOLINTBEGIN(libcpp-robust-against-adl) iter_swap ADL calls should only be made through ranges::iter_swap
     template <class _T1, class _T2>
       requires __unqualified_iter_swap<_T1, _T2>
     _LIBCPP_HIDE_FROM_ABI
     constexpr void operator()(_T1&& __x, _T2&& __y) const
       noexcept(noexcept(iter_swap(_VSTD::forward<_T1>(__x), _VSTD::forward<_T2>(__y))))
     {
       (void)iter_swap(_VSTD::forward<_T1>(__x), _VSTD::forward<_T2>(__y));
     }
+    // NOLINTEND(libcpp-robust-against-adl)
 
     template <class _T1, class _T2>
       requires (!__unqualified_iter_swap<_T1, _T2>) &&
                __readable_swappable<_T1, _T2>
     _LIBCPP_HIDE_FROM_ABI
     constexpr void operator()(_T1&& __x, _T2&& __y) const
       noexcept(noexcept(ranges::swap(*_VSTD::forward<_T1>(__x), *_VSTD::forward<_T2>(__y))))
     {

libcxx/include/__locale

 };
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 template <class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 isspace(_CharT __c, const locale& __loc)
 {
-    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c);
+    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c);
 }
 
 template <class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 isprint(_CharT __c, const locale& __loc)
 {
-    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c);
+    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c);
 }
 
 template <class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 iscntrl(_CharT __c, const locale& __loc)
 {
-    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c);
+    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c);
 }
 
 template <class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 isupper(_CharT __c, const locale& __loc)
 {
-    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c);
+    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c);
 }
 
 template <class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 islower(_CharT __c, const locale& __loc)
 {
-    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c);
+    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c);
 }
 
 template <class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 isalpha(_CharT __c, const locale& __loc)
 {
-    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c);
+    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c);
 }
 
 template <class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 isdigit(_CharT __c, const locale& __loc)
 {
-    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c);
+    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c);
 }
 
 template <class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 ispunct(_CharT __c, const locale& __loc)
 {
-    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c);
+    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c);
 }
 
 template <class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 isxdigit(_CharT __c, const locale& __loc)
 {
-    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c);
+    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c);
 }
 
 template <class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 isalnum(_CharT __c, const locale& __loc)
 {
-    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c);
+    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c);
 }
 
 template <class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 isgraph(_CharT __c, const locale& __loc)
 {
-    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c);
+    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c);
 }
 
 template <class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 _CharT
 toupper(_CharT __c, const locale& __loc)
 {
-    return use_facet<ctype<_CharT> >(__loc).toupper(__c);
+    return std::use_facet<ctype<_CharT> >(__loc).toupper(__c);
 }
 
 template <class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 _CharT
 tolower(_CharT __c, const locale& __loc)
 {
-    return use_facet<ctype<_CharT> >(__loc).tolower(__c);
+    return std::use_facet<ctype<_CharT> >(__loc).tolower(__c);
 }
 
 // codecvt_base
 
 class _LIBCPP_TYPE_VIS codecvt_base
 {
 public:
     _LIBCPP_INLINE_VISIBILITY codecvt_base() {}

libcxx/include/__memory/shared_ptr.h

 template <class _Dp, class _Pt,
     class = decltype(declval<_Dp>()(declval<_Pt>()))>
 static true_type __well_formed_deleter_test(int);
 
 template <class, class>
 static false_type __well_formed_deleter_test(...);
 
 template <class _Dp, class _Pt>
-struct __well_formed_deleter : decltype(__well_formed_deleter_test<_Dp, _Pt>(0)) {};
+struct __well_formed_deleter : decltype(std::__well_formed_deleter_test<_Dp, _Pt>(0)) {};
 
 template<class _Dp, class _Tp, class _Yp>
 struct __shared_ptr_deleter_ctor_reqs
 {
     static const bool value = __compatible_with<_Tp, _Yp>::value &&
                               is_move_constructible<_Dp>::value &&
                               __well_formed_deleter<_Dp, _Tp*>::value;
 };
atomic_is_lock_free(const shared_ptr<_Tp>*)
     return false;
 }
 
 template <class _Tp>
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>
 atomic_load(const shared_ptr<_Tp>* __p)
 {
-    __sp_mut& __m = __get_sp_mut(__p);
+    __sp_mut& __m = std::__get_sp_mut(__p);
     __m.lock();
     shared_ptr<_Tp> __q = *__p;
     __m.unlock();
     return __q;
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 shared_ptr<_Tp>
 atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
 {
-    return atomic_load(__p);
+    return std::atomic_load(__p);
 }
 
 template <class _Tp>
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 _LIBCPP_HIDE_FROM_ABI void
 atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
 {
-    __sp_mut& __m = __get_sp_mut(__p);
+    __sp_mut& __m = std::__get_sp_mut(__p);
     __m.lock();
     __p->swap(__r);
     __m.unlock();
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 void
 atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order)
 {
-    atomic_store(__p, __r);
+    std::atomic_store(__p, __r);
 }
 
 template <class _Tp>
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>
 atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
 {
-    __sp_mut& __m = __get_sp_mut(__p);
+    __sp_mut& __m = std::__get_sp_mut(__p);
     __m.lock();
     __p->swap(__r);
     __m.unlock();
     return __r;
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 shared_ptr<_Tp>
 atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order)
 {
-    return atomic_exchange(__p, __r);
+    return std::atomic_exchange(__p, __r);
 }
 
 template <class _Tp>
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 _LIBCPP_HIDE_FROM_ABI bool
 atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w)
 {
     shared_ptr<_Tp> __temp;
-    __sp_mut& __m = __get_sp_mut(__p);
+    __sp_mut& __m = std::__get_sp_mut(__p);
     __m.lock();
     if (__p->__owner_equivalent(*__v))
     {
         _VSTD::swap(__temp, *__p);
         *__p = __w;
         __m.unlock();
         return true;
     }
     _VSTD::swap(__temp, *__v);
     *__v = *__p;
     __m.unlock();
     return false;
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 bool
 atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w)
 {
-    return atomic_compare_exchange_strong(__p, __v, __w);
+    return std::atomic_compare_exchange_strong(__p, __v, __w);
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 bool
 atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
                                         shared_ptr<_Tp> __w, memory_order, memory_order)
 {
-    return atomic_compare_exchange_strong(__p, __v, __w);
+    return std::atomic_compare_exchange_strong(__p, __v, __w);
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 bool
 atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
                                       shared_ptr<_Tp> __w, memory_order, memory_order)
 {
-    return atomic_compare_exchange_weak(__p, __v, __w);
+    return std::atomic_compare_exchange_weak(__p, __v, __w);
 }
 
 #endif // !defined(_LIBCPP_HAS_NO_THREADS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_SHARED_PTR_H

libcxx/include/__memory/uninitialized_algorithms.h

#endif
 
     return __idx;
 }
 
 template <class _ForwardIterator, class _Size>
 inline _LIBCPP_HIDE_FROM_ABI
 _ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
     using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
-    return __uninitialized_value_construct_n<_ValueType>(_VSTD::move(__first), __n);
+    return std::__uninitialized_value_construct_n<_ValueType>(_VSTD::move(__first), __n);
 }
 
 // uninitialized_move
 
 template <class _ValueType, class _InputIterator, class _Sentinel1, class _ForwardIterator, class _Sentinel2,
           class _IterMove>
 inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
 __uninitialized_move(_InputIterator __ifirst, _Sentinel1 __ilast,

libcxx/include/__numeric/midpoint.h

 
 template <class _Fp>
 _LIBCPP_INLINE_VISIBILITY constexpr
 enable_if_t<is_floating_point_v<_Fp>, _Fp>
 midpoint(_Fp __a, _Fp __b) noexcept
 {
     constexpr _Fp __lo = numeric_limits<_Fp>::min()*2;
     constexpr _Fp __hi = numeric_limits<_Fp>::max()/2;
-    return __fp_abs(__a) <= __hi && __fp_abs(__b) <= __hi ?  // typical case: overflow is impossible
+    return std::__fp_abs(__a) <= __hi && std::__fp_abs(__b) <= __hi ?  // typical case: overflow is impossible
       (__a + __b)/2 :                                        // always correctly rounded
-      __fp_abs(__a) < __lo ? __a + __b/2 :                   // not safe to halve a
-      __fp_abs(__b) < __lo ? __a/2 + __b :                   // not safe to halve b
+      std::__fp_abs(__a) < __lo ? __a + __b/2 :                   // not safe to halve a
+      std::__fp_abs(__b) < __lo ? __a/2 + __b :                   // not safe to halve b
       __a/2 + __b/2;                                         // otherwise correctly rounded
 }
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___NUMERIC_MIDPOINT_H

libcxx/include/__random/binomial_distribution.h

 
 template<class _IntType>
 binomial_distribution<_IntType>::param_type::param_type(result_type __t, double __p)
     : __t_(__t), __p_(__p)
 {
     if (0 < __p_ && __p_ < 1)
     {
         __r0_ = static_cast<result_type>((__t_ + 1) * __p_);
-        __pr_ = _VSTD::exp(__libcpp_lgamma(__t_ + 1.) -
-                           __libcpp_lgamma(__r0_ + 1.) -
-                           __libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) +
+        __pr_ = _VSTD::exp(std::__libcpp_lgamma(__t_ + 1.) -
+                           std::__libcpp_lgamma(__r0_ + 1.) -
+                           std::__libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) +
                            (__t_ - __r0_) * _VSTD::log(1 - __p_));
         __odds_ratio_ = __p_ / (1 - __p_);
     }
 }
 
 // Reference: Kemp, C.D. (1986). `A modal method for generating binomial
 //           variables', Commun. Statist. - Theor. Meth. 15(3), 805-813.
 template<class _IntType>

libcxx/include/__random/uniform_int_distribution.h

typedef typename conditional<sizeof(result_type) <= sizeof(uint32_t), uint32_t,
                                  __make_unsigned_t<result_type> >::type _UIntType;
     const _UIntType _Rp = _UIntType(__p.b()) - _UIntType(__p.a()) + _UIntType(1);
     if (_Rp == 1)
         return __p.a();
     const size_t _Dt = numeric_limits<_UIntType>::digits;
     typedef __independent_bits_engine<_URNG, _UIntType> _Eng;
     if (_Rp == 0)
         return static_cast<result_type>(_Eng(__g, _Dt)());
-    size_t __w = _Dt - __countl_zero(_Rp) - 1;
+    size_t __w = _Dt - std::__countl_zero(_Rp) - 1;
     if ((_Rp & (numeric_limits<_UIntType>::max() >> (_Dt - __w))) != 0)
         ++__w;
     _Eng __e(__g, __w);
     _UIntType __u;
     do
     {
         __u = __e();
     } while (__u >= _Rp);

libcxx/include/__split_buffer

if (__begin_ == __first_)
         {
             difference_type __d = __end_cap() - __end_;
             __d = (__d + 1) / 2;
             __begin_ = _VSTD::move_backward(__begin_, __end_, __end_ + __d);
             __end_ += __d;
         }
         else
         {
-            size_type __c = max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
+            size_type __c = std::max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
             __split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
             __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                    move_iterator<pointer>(__end_));
             _VSTD::swap(__first_, __t.__first_);
             _VSTD::swap(__begin_, __t.__begin_);
             _VSTD::swap(__end_, __t.__end_);
             _VSTD::swap(__end_cap(), __t.__end_cap());
         }
if (__begin_ == __first_)
         {
             difference_type __d = __end_cap() - __end_;
             __d = (__d + 1) / 2;
             __begin_ = _VSTD::move_backward(__begin_, __end_, __end_ + __d);
             __end_ += __d;
         }
         else
         {
-            size_type __c = max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
+            size_type __c = std::max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
             __split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
             __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                    move_iterator<pointer>(__end_));
             _VSTD::swap(__first_, __t.__first_);
             _VSTD::swap(__begin_, __t.__begin_);
             _VSTD::swap(__end_, __t.__end_);
             _VSTD::swap(__end_cap(), __t.__end_cap());
         }
if (__end_ == __end_cap())
         {
             difference_type __d = __begin_ - __first_;
             __d = (__d + 1) / 2;
             __end_ = _VSTD::move(__begin_, __end_, __begin_ - __d);
             __begin_ -= __d;
         }
         else
         {
-            size_type __c = max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
+            size_type __c = std::max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
             __split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
             __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                    move_iterator<pointer>(__end_));
             _VSTD::swap(__first_, __t.__first_);
             _VSTD::swap(__begin_, __t.__begin_);
             _VSTD::swap(__end_, __t.__end_);
             _VSTD::swap(__end_cap(), __t.__end_cap());
         }
if (__end_ == __end_cap())
         {
             difference_type __d = __begin_ - __first_;
             __d = (__d + 1) / 2;
             __end_ = _VSTD::move(__begin_, __end_, __begin_ - __d);
             __begin_ -= __d;
         }
         else
         {
-            size_type __c = max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
+            size_type __c = std::max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
             __split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
             __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                    move_iterator<pointer>(__end_));
             _VSTD::swap(__first_, __t.__first_);
             _VSTD::swap(__begin_, __t.__begin_);
             _VSTD::swap(__end_, __t.__end_);
             _VSTD::swap(__end_cap(), __t.__end_cap());
         }
if (__end_ == __end_cap())
         {
             difference_type __d = __begin_ - __first_;
             __d = (__d + 1) / 2;
             __end_ = _VSTD::move(__begin_, __end_, __begin_ - __d);
             __begin_ -= __d;
         }
         else
         {
-            size_type __c = max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
+            size_type __c = std::max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
             __split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
             __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                    move_iterator<pointer>(__end_));
             _VSTD::swap(__first_, __t.__first_);
             _VSTD::swap(__begin_, __t.__begin_);
             _VSTD::swap(__end_, __t.__end_);
             _VSTD::swap(__end_cap(), __t.__end_cap());
         }

libcxx/include/__string/char_traits.h

__str_find(const _CharT *__p, _SizeT __sz,
        const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
 {
     if (__pos > __sz)
         return __npos;
 
     if (__n == 0) // There is nothing to search, just return __pos.
         return __pos;
 
-    const _CharT *__r = __search_substring<_CharT, _Traits>(
+    const _CharT *__r = std::__search_substring<_CharT, _Traits>(
         __p + __pos, __p + __sz, __s, __s + __n);
 
     if (__r == __p + __sz)
         return __npos;
     return static_cast<_SizeT>(__r - __p);
 }
 
 

libcxx/include/__type_traits/conjunction.h

 
 template <class... _Pred>
 __expand_to_true<__enable_if_t<_Pred::value>...> __and_helper(int);
 
 template <class...>
 false_type __and_helper(...);
 
 template <class... _Pred>
-using _And _LIBCPP_NODEBUG = decltype(__and_helper<_Pred...>(0));
+using _And _LIBCPP_NODEBUG = decltype(std::__and_helper<_Pred...>(0));
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_CONJUNCTION_H

libcxx/include/__type_traits/is_callable.h

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _Func, class... _Args, class = decltype(std::declval<_Func>()(std::declval<_Args>()...))>
 true_type __is_callable_helper(int);
 template<class...>
 false_type __is_callable_helper(...);
 
 template<class _Func, class... _Args>
-struct __is_callable : decltype(__is_callable_helper<_Func, _Args...>(0)) {};
+struct __is_callable : decltype(std::__is_callable_helper<_Func, _Args...>(0)) {};
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_CALLABLE_H

libcxx/include/__type_traits/is_implicitly_default_constructible.h

 void __test_implicit_default_constructible(_Tp);
 
 template <class _Tp, class = void, class = typename is_default_constructible<_Tp>::type>
 struct __is_implicitly_default_constructible
     : false_type
 { };
 
 template <class _Tp>
-struct __is_implicitly_default_constructible<_Tp, decltype(__test_implicit_default_constructible<_Tp const&>({})), true_type>
+struct __is_implicitly_default_constructible<_Tp, decltype(std::__test_implicit_default_constructible<_Tp const&>({})), true_type>
     : true_type
 { };
 
 template <class _Tp>
-struct __is_implicitly_default_constructible<_Tp, decltype(__test_implicit_default_constructible<_Tp const&>({})), false_type>
+struct __is_implicitly_default_constructible<_Tp, decltype(std::__test_implicit_default_constructible<_Tp const&>({})), false_type>
     : false_type
 { };
 #endif // !C++03
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_IMPLICITLY_DEFAULT_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_valid_expansion.h

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <template <class...> class _Templ, class ..._Args, class = _Templ<_Args...> >
 true_type __sfinae_test_impl(int);
 template <template <class...> class, class ...>
 false_type __sfinae_test_impl(...);
 
 template <template <class ...> class _Templ, class ..._Args>
-using _IsValidExpansion _LIBCPP_NODEBUG = decltype(__sfinae_test_impl<_Templ, _Args...>(0));
+using _IsValidExpansion _LIBCPP_NODEBUG = decltype(std::__sfinae_test_impl<_Templ, _Args...>(0));
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_VALID_EXPANSION_H

libcxx/include/__utility/declval.h

 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Tp>
 _Tp&& __declval(int);
 template <class _Tp>
 _Tp __declval(long);
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 template <class _Tp>
-decltype(__declval<_Tp>(0)) declval() _NOEXCEPT;
+decltype(std::__declval<_Tp>(0)) declval() _NOEXCEPT;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___UTILITY_DECLVAL_H

libcxx/include/atomic

 struct __libcpp_atomic_wait_backoff_impl {
     _Atp* __a;
     _Fn __test_fn;
     _LIBCPP_AVAILABILITY_SYNC
     _LIBCPP_INLINE_VISIBILITY bool operator()(chrono::nanoseconds __elapsed) const
     {
         if(__elapsed > chrono::microseconds(64))
         {
-            auto const __monitor = __libcpp_atomic_monitor(__a);
+            auto const __monitor = std::__libcpp_atomic_monitor(__a);
             if(__test_fn())
                 return true;
-            __libcpp_atomic_wait(__a, __monitor);
+            std::__libcpp_atomic_wait(__a, __monitor);
         }
         else if(__elapsed > chrono::microseconds(4))
             __libcpp_thread_yield();
         else
             {} // poll
         return false;
     }
 };
 
 template <class _Atp, class _Fn>
 _LIBCPP_AVAILABILITY_SYNC
 _LIBCPP_INLINE_VISIBILITY bool __cxx_atomic_wait(_Atp* __a, _Fn && __test_fn)
 {
     __libcpp_atomic_wait_backoff_impl<_Atp, typename decay<_Fn>::type> __backoff_fn = {__a, __test_fn};
-    return __libcpp_thread_poll_with_backoff(__test_fn, __backoff_fn);
+    return std::__libcpp_thread_poll_with_backoff(__test_fn, __backoff_fn);
 }
 
 #else // _LIBCPP_HAS_NO_THREADS
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY void __cxx_atomic_notify_all(__cxx_atomic_impl<_Tp> const volatile*) { }
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY void __cxx_atomic_notify_one(__cxx_atomic_impl<_Tp> const volatile*) { }
 template <class _Atp, class _Fn>
 _LIBCPP_INLINE_VISIBILITY bool __cxx_atomic_wait(_Atp*, _Fn && __test_fn)
 {
     return __libcpp_thread_poll_with_backoff(__test_fn, __spinning_backoff_policy());
 }
 
 #endif // _LIBCPP_HAS_NO_THREADS
 
 template <class _Atp, class _Tp>
 struct __cxx_atomic_wait_test_fn_impl {
     _Atp* __a;
     _Tp __val;
     memory_order __order;
     _LIBCPP_INLINE_VISIBILITY bool operator()() const
     {
-        return !__cxx_nonatomic_compare_equal(__cxx_atomic_load(__a, __order), __val);
+        return !std::__cxx_nonatomic_compare_equal(std::__cxx_atomic_load(__a, __order), __val);
     }
 };
 
 template <class _Atp, class _Tp>
 _LIBCPP_AVAILABILITY_SYNC
 _LIBCPP_INLINE_VISIBILITY bool __cxx_atomic_wait(_Atp* __a, _Tp const __val, memory_order __order)
 {
     __cxx_atomic_wait_test_fn_impl<_Atp, _Tp> __test_fn = {__a, __val, __order};
-    return __cxx_atomic_wait(__a, __test_fn);
+    return std::__cxx_atomic_wait(__a, __test_fn);
 }
 
 // general atomic<T>
 
 template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::value>
 struct __atomic_base  // false
 {
     mutable __cxx_atomic_impl<_Tp> __a_;
 
 #if defined(__cpp_lib_atomic_is_always_lock_free)
   static _LIBCPP_CONSTEXPR bool is_always_lock_free = __atomic_always_lock_free(sizeof(__a_), 0);
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     bool is_lock_free() const volatile _NOEXCEPT
         {return __cxx_atomic_is_lock_free(sizeof(_Tp));}
     _LIBCPP_INLINE_VISIBILITY
     bool is_lock_free() const _NOEXCEPT
         {return static_cast<__atomic_base const volatile*>(this)->is_lock_free();}
     _LIBCPP_INLINE_VISIBILITY
     void store(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
       _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m)
-        {__cxx_atomic_store(&__a_, __d, __m);}
+        {std::__cxx_atomic_store(&__a_, __d, __m);}
     _LIBCPP_INLINE_VISIBILITY
     void store(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT
       _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m)
-        {__cxx_atomic_store(&__a_, __d, __m);}
+        {std::__cxx_atomic_store(&__a_, __d, __m);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp load(memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT
       _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
-        {return __cxx_atomic_load(&__a_, __m);}
+        {return std::__cxx_atomic_load(&__a_, __m);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp load(memory_order __m = memory_order_seq_cst) const _NOEXCEPT
       _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
-        {return __cxx_atomic_load(&__a_, __m);}
+        {return std::__cxx_atomic_load(&__a_, __m);}
     _LIBCPP_INLINE_VISIBILITY
     operator _Tp() const volatile _NOEXCEPT {return load();}
     _LIBCPP_INLINE_VISIBILITY
     operator _Tp() const _NOEXCEPT          {return load();}
     _LIBCPP_INLINE_VISIBILITY
     _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
-        {return __cxx_atomic_exchange(&__a_, __d, __m);}
+        {return std::__cxx_atomic_exchange(&__a_, __d, __m);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT
-        {return __cxx_atomic_exchange(&__a_, __d, __m);}
+        {return std::__cxx_atomic_exchange(&__a_, __d, __m);}
     _LIBCPP_INLINE_VISIBILITY
     bool compare_exchange_weak(_Tp& __e, _Tp __d,
                                memory_order __s, memory_order __f) volatile _NOEXCEPT
       _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
-        {return __cxx_atomic_compare_exchange_weak(&__a_, &__e, __d, __s, __f);}
+        {return std::__cxx_atomic_compare_exchange_weak(&__a_, &__e, __d, __s, __f);}
     _LIBCPP_INLINE_VISIBILITY
     bool compare_exchange_weak(_Tp& __e, _Tp __d,
                                memory_order __s, memory_order __f) _NOEXCEPT
       _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
-        {return __cxx_atomic_compare_exchange_weak(&__a_, &__e, __d, __s, __f);}
+        {return std::__cxx_atomic_compare_exchange_weak(&__a_, &__e, __d, __s, __f);}
     _LIBCPP_INLINE_VISIBILITY
     bool compare_exchange_strong(_Tp& __e, _Tp __d,
                                  memory_order __s, memory_order __f) volatile _NOEXCEPT
       _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
-        {return __cxx_atomic_compare_exchange_strong(&__a_, &__e, __d, __s, __f);}
+        {return std::__cxx_atomic_compare_exchange_strong(&__a_, &__e, __d, __s, __f);}
     _LIBCPP_INLINE_VISIBILITY
     bool compare_exchange_strong(_Tp& __e, _Tp __d,
                                  memory_order __s, memory_order __f) _NOEXCEPT
       _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
-        {return __cxx_atomic_compare_exchange_strong(&__a_, &__e, __d, __s, __f);}
+        {return std::__cxx_atomic_compare_exchange_strong(&__a_, &__e, __d, __s, __f);}
     _LIBCPP_INLINE_VISIBILITY
     bool compare_exchange_weak(_Tp& __e, _Tp __d,
                               memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
-        {return __cxx_atomic_compare_exchange_weak(&__a_, &__e, __d, __m, __m);}
+        {return std::__cxx_atomic_compare_exchange_weak(&__a_, &__e, __d, __m, __m);}
     _LIBCPP_INLINE_VISIBILITY
     bool compare_exchange_weak(_Tp& __e, _Tp __d,
                                memory_order __m = memory_order_seq_cst) _NOEXCEPT
-        {return __cxx_atomic_compare_exchange_weak(&__a_, &__e, __d, __m, __m);}
+        {return std::__cxx_atomic_compare_exchange_weak(&__a_, &__e, __d, __m, __m);}
     _LIBCPP_INLINE_VISIBILITY
     bool compare_exchange_strong(_Tp& __e, _Tp __d,
                               memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
-        {return __cxx_atomic_compare_exchange_strong(&__a_, &__e, __d, __m, __m);}
+        {return std::__cxx_atomic_compare_exchange_strong(&__a_, &__e, __d, __m, __m);}
     _LIBCPP_INLINE_VISIBILITY
     bool compare_exchange_strong(_Tp& __e, _Tp __d,
                                  memory_order __m = memory_order_seq_cst) _NOEXCEPT
-        {return __cxx_atomic_compare_exchange_strong(&__a_, &__e, __d, __m, __m);}
+        {return std::__cxx_atomic_compare_exchange_strong(&__a_, &__e, __d, __m, __m);}
 
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void wait(_Tp __v, memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT
-        {__cxx_atomic_wait(&__a_, __v, __m);}
+        {std::__cxx_atomic_wait(&__a_, __v, __m);}
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void wait(_Tp __v, memory_order __m = memory_order_seq_cst) const _NOEXCEPT
-        {__cxx_atomic_wait(&__a_, __v, __m);}
+        {std::__cxx_atomic_wait(&__a_, __v, __m);}
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_one() volatile _NOEXCEPT
-        {__cxx_atomic_notify_one(&__a_);}
+        {std::__cxx_atomic_notify_one(&__a_);}
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_one() _NOEXCEPT
-        {__cxx_atomic_notify_one(&__a_);}
+        {std::__cxx_atomic_notify_one(&__a_);}
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_all() volatile _NOEXCEPT
-        {__cxx_atomic_notify_all(&__a_);}
+        {std::__cxx_atomic_notify_all(&__a_);}
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_all() _NOEXCEPT
-        {__cxx_atomic_notify_all(&__a_);}
+        {std::__cxx_atomic_notify_all(&__a_);}
 
 #if _LIBCPP_STD_VER > 17
     _LIBCPP_INLINE_VISIBILITY constexpr
     __atomic_base() noexcept(is_nothrow_default_constructible_v<_Tp>) : __a_(_Tp()) {}
 #else
     _LIBCPP_INLINE_VISIBILITY
     __atomic_base() _NOEXCEPT = default;
 #endif
struct __atomic_base<_Tp, true>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
     __atomic_base() _NOEXCEPT = default;
 
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __base(__d) {}
 
     _LIBCPP_INLINE_VISIBILITY
     _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
-        {return __cxx_atomic_fetch_add(&this->__a_, __op, __m);}
+        {return std::__cxx_atomic_fetch_add(&this->__a_, __op, __m);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
-        {return __cxx_atomic_fetch_add(&this->__a_, __op, __m);}
+        {return std::__cxx_atomic_fetch_add(&this->__a_, __op, __m);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
-        {return __cxx_atomic_fetch_sub(&this->__a_, __op, __m);}
+        {return std::__cxx_atomic_fetch_sub(&this->__a_, __op, __m);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
-        {return __cxx_atomic_fetch_sub(&this->__a_, __op, __m);}
+        {return std::__cxx_atomic_fetch_sub(&this->__a_, __op, __m);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
-        {return __cxx_atomic_fetch_and(&this->__a_, __op, __m);}
+        {return std::__cxx_atomic_fetch_and(&this->__a_, __op, __m);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
-        {return __cxx_atomic_fetch_and(&this->__a_, __op, __m);}
+        {return std::__cxx_atomic_fetch_and(&this->__a_, __op, __m);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
-        {return __cxx_atomic_fetch_or(&this->__a_, __op, __m);}
+        {return std::__cxx_atomic_fetch_or(&this->__a_, __op, __m);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
-        {return __cxx_atomic_fetch_or(&this->__a_, __op, __m);}
+        {return std::__cxx_atomic_fetch_or(&this->__a_, __op, __m);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
-        {return __cxx_atomic_fetch_xor(&this->__a_, __op, __m);}
+        {return std::__cxx_atomic_fetch_xor(&this->__a_, __op, __m);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
-        {return __cxx_atomic_fetch_xor(&this->__a_, __op, __m);}
+        {return std::__cxx_atomic_fetch_xor(&this->__a_, __op, __m);}
 
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator++(int) volatile _NOEXCEPT      {return fetch_add(_Tp(1));}
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator++(int) _NOEXCEPT               {return fetch_add(_Tp(1));}
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator--(int) volatile _NOEXCEPT      {return fetch_sub(_Tp(1));}
     _LIBCPP_INLINE_VISIBILITY
struct atomic<_Tp*>
     _LIBCPP_INLINE_VISIBILITY
     _Tp* operator=(_Tp* __d) _NOEXCEPT
         {__base::store(__d); return __d;}
 
     _LIBCPP_INLINE_VISIBILITY
     _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
         // __atomic_fetch_add accepts function pointers, guard against them.
         static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
-        return __cxx_atomic_fetch_add(&this->__a_, __op, __m);
+        return std::__cxx_atomic_fetch_add(&this->__a_, __op, __m);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
         // __atomic_fetch_add accepts function pointers, guard against them.
         static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
-        return __cxx_atomic_fetch_add(&this->__a_, __op, __m);
+        return std::__cxx_atomic_fetch_add(&this->__a_, __op, __m);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
         // __atomic_fetch_add accepts function pointers, guard against them.
         static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
-        return __cxx_atomic_fetch_sub(&this->__a_, __op, __m);
+        return std::__cxx_atomic_fetch_sub(&this->__a_, __op, __m);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
         // __atomic_fetch_add accepts function pointers, guard against them.
         static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
-        return __cxx_atomic_fetch_sub(&this->__a_, __op, __m);
+        return std::__cxx_atomic_fetch_sub(&this->__a_, __op, __m);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     _Tp* operator++(int) volatile _NOEXCEPT            {return fetch_add(1);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp* operator++(int) _NOEXCEPT                     {return fetch_add(1);}
     _LIBCPP_INLINE_VISIBILITY
     _Tp* operator--(int) volatile _NOEXCEPT            {return fetch_sub(1);}

 
 // atomic_init
 
 template <class _Tp>
 _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_INLINE_VISIBILITY
 void
 atomic_init(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT
 {
-    __cxx_atomic_init(&__o->__a_, __d);
+    std::__cxx_atomic_init(&__o->__a_, __d);
 }
 
 template <class _Tp>
 _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_INLINE_VISIBILITY
 void
 atomic_init(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT
 {
-    __cxx_atomic_init(&__o->__a_, __d);
+    std::__cxx_atomic_init(&__o->__a_, __d);
 }
 
 // atomic_store
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 void
 atomic_store(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT

libcxx/include/barrier

public:
     using arrival_token = __barrier_phase_t;
 
     static constexpr ptrdiff_t max() noexcept {
         return numeric_limits<ptrdiff_t>::max();
     }
 
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     __barrier_base(ptrdiff_t __expected, _CompletionF __completion = _CompletionF())
-            : __expected_(__expected), __base_(__construct_barrier_algorithm_base(this->__expected_),
+            : __expected_(__expected), __base_(std::__construct_barrier_algorithm_base(this->__expected_),
                                                &__destroy_barrier_algorithm_base),
               __expected_adjustment_(0), __completion_(std::move(__completion)), __phase_(0)
     {
     }
     [[nodiscard]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     arrival_token arrive(ptrdiff_t __update)
     {
         auto const __old_phase = __phase_.load(memory_order_relaxed);
         for(; __update; --__update)
             if(__arrive_barrier_algorithm_base(__base_.get(), __old_phase)) {
                 __completion_();
                 __expected_ += __expected_adjustment_.load(memory_order_relaxed);
                 __expected_adjustment_.store(0, memory_order_relaxed);
                 __phase_.store(__old_phase + 2, memory_order_release);
                 __phase_.notify_all();
             }
         return __old_phase;
     }
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void wait(arrival_token&& __old_phase) const
     {
         auto const __test_fn = [this, __old_phase]() -> bool {
             return __phase_.load(memory_order_acquire) != __old_phase;
         };
-        __libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy());
+        std::__libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy());
     }
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void arrive_and_drop()
     {
         __expected_adjustment_.fetch_sub(1, memory_order_relaxed);
         (void)arrive(1);
     }
 };

libcxx/include/charconv

#else
     return __did;
 #endif
 }
 
 template <typename _Tp, typename _Up>
 inline _LIBCPP_HIDE_FROM_ABI bool
 __mul_overflowed(_Tp __a, _Up __b, _Tp& __r)
 {
-    return __mul_overflowed(__a, static_cast<_Tp>(__b), __r);
+    return __itoa::__mul_overflowed(__a, static_cast<_Tp>(__b), __r);
 }
 
 template <typename _Tp>
 struct _LIBCPP_HIDDEN __traits : __traits_base<_Tp>
 {
     static constexpr int digits = numeric_limits<_Tp>::digits10 + 1;
     using __traits_base<_Tp>::__pow;
     using typename __traits_base<_Tp>::type;
__read(char const* __p, char const* __ep, type& __a, type& __b)
         {
             if (!('0' <= *__p && *__p <= '9'))
                 break;
             __cprod[--__i] = *__p++ - '0';
         } while (__p != __ep && __i != 0);
 
         __a = __inner_product(__cprod + __i + 1, __cprod + __j, __pow() + 1,
                               __cprod[__i]);
-        if (__mul_overflowed(__cprod[__j], __pow()[__j - __i], __b))
+        if (__itoa::__mul_overflowed(__cprod[__j], __pow()[__j - __i], __b))
             --__p;
         return __p;
     }
 
     template <typename _It1, typename _It2, class _Up>
     static _LIBCPP_HIDE_FROM_ABI _Up
     __inner_product(_It1 __first1, _It1 __last1, _It2 __first2, _Up __init)
     {

 __complement(_Tp __x)
 {
     static_assert(is_unsigned<_Tp>::value, "cast to unsigned first");
     return _Tp(~__x + 1);
 }
 
 template <typename _Tp>
 inline _LIBCPP_HIDE_FROM_ABI to_chars_result
-__to_chars_itoa(char* __first, char* __last, _Tp __value, true_type)
-{
-    auto __x = __to_unsigned_like(__value);
-    if (__value < 0 && __first != __last)
-    {
-        *__first++ = '-';
-        __x = __complement(__x);
-    }
-
-    return __to_chars_itoa(__first, __last, __x, false_type());
-}
-
-template <typename _Tp>
-inline _LIBCPP_HIDE_FROM_ABI to_chars_result
 __to_chars_itoa(char* __first, char* __last, _Tp __value, false_type)
 {
     using __tx = __itoa::__traits<_Tp>;
     auto __diff = __last - __first;
 
     if (__tx::digits <= __diff || __tx::__width(__value) <= __diff)
         return {__tx::__convert(__first, __value), errc(0)};
     else
         return {__last, errc::value_too_large};
 }
 
+template <typename _Tp>
+inline _LIBCPP_HIDE_FROM_ABI to_chars_result
+__to_chars_itoa(char* __first, char* __last, _Tp __value, true_type)
+{
+    auto __x = std::__to_unsigned_like(__value);
+    if (__value < 0 && __first != __last)
+    {
+        *__first++ = '-';
+        __x = std::__complement(__x);
+    }
+
+    return std::__to_chars_itoa(__first, __last, __x, false_type());
+}
+
 #  ifndef _LIBCPP_HAS_NO_INT128
 template <>
 inline _LIBCPP_HIDE_FROM_ABI to_chars_result
 __to_chars_itoa(char* __first, char* __last, __uint128_t __value, false_type)
 {
     // When the value fits in 64-bits use the 64-bit code path. This reduces
     // the number of expensive calculations on 128-bit values.
     //

 }
 #endif
 
 template <typename _Tp>
 inline _LIBCPP_HIDE_FROM_ABI to_chars_result
 __to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
                     true_type)
 {
-    auto __x = __to_unsigned_like(__value);
+    auto __x = std::__to_unsigned_like(__value);
     if (__value < 0 && __first != __last)
     {
         *__first++ = '-';
-        __x = __complement(__x);
+        __x = std::__complement(__x);
     }
 
-    return __to_chars_integral(__first, __last, __x, __base, false_type());
+    return std::__to_chars_integral(__first, __last, __x, __base, false_type());
 }
 
 namespace __itoa {
 
 template <unsigned _Base>
 struct _LIBCPP_HIDDEN __integral;
 
 template <>

 }
 
 template <typename _Tp>
 inline _LIBCPP_HIDE_FROM_ABI to_chars_result
 __to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
                     false_type)
 {
   if (__base == 10) [[likely]]
-    return __to_chars_itoa(__first, __last, __value, false_type());
+    return std::__to_chars_itoa(__first, __last, __value, false_type());
 
   switch (__base) {
   case 2:
-    return __to_chars_integral<2>(__first, __last, __value);
+    return std::__to_chars_integral<2>(__first, __last, __value);
   case 8:
-    return __to_chars_integral<8>(__first, __last, __value);
+    return std::__to_chars_integral<8>(__first, __last, __value);
   case 16:
-    return __to_chars_integral<16>(__first, __last, __value);
+    return std::__to_chars_integral<16>(__first, __last, __value);
   }
 
   ptrdiff_t __cap = __last - __first;
-  int __n = __to_chars_integral_width(__value, __base);
+  int __n = std::__to_chars_integral_width(__value, __base);
   if (__n > __cap)
     return {__last, errc::value_too_large};
 
   __last = __first + __n;
   char* __p = __last;
   do {
     unsigned __c = __value % __base;
     __value /= __base;
to_chars(char* __first, char* __last, _Tp __value, int __base)
   return std::__to_chars_integral(__first, __last, static_cast<_Type>(__value), __base, is_signed<_Tp>());
 }
 
 template <typename _It, typename _Tp, typename _Fn, typename... _Ts>
 inline _LIBCPP_HIDE_FROM_ABI from_chars_result
 __sign_combinator(_It __first, _It __last, _Tp& __value, _Fn __f, _Ts... __args)
 {
     using __tl = numeric_limits<_Tp>;
-    decltype(__to_unsigned_like(__value)) __x;
+    decltype(std::__to_unsigned_like(__value)) __x;
 
     bool __neg = (__first != __last && *__first == '-');
     auto __r = __f(__neg ? __first + 1 : __first, __last, __x, __args...);
     switch (__r.ec)
     {
     case errc::invalid_argument:
         return {__first, __r.ec};
     case errc::result_out_of_range:
         return __r;
     default:
         break;
     }
 
     if (__neg)
     {
-        if (__x <= __complement(__to_unsigned_like(__tl::min())))
+        if (__x <= std::__complement(std::__to_unsigned_like(__tl::min())))
         {
-            __x = __complement(__x);
+            __x = std::__complement(__x);
             std::memcpy(&__value, &__x, sizeof(__x));
             return __r;
         }
     }
     else
     {
-        if (__x <= __to_unsigned_like(__tl::max()))
+        if (__x <= std::__to_unsigned_like(__tl::max()))
         {
             __value = __x;
             return __r;
         }
     }
 
     return {__r.ptr, errc::result_out_of_range};
 }

 };
 
 template <typename _Tp>
 inline _LIBCPP_HIDE_FROM_ABI __in_pattern_result
 __in_pattern(_Tp __c, int __base)
 {
     if (__base <= 10)
         return {'0' <= __c && __c < '0' + __base, __c - '0'};
-    else if (__in_pattern(__c))
+    else if (std::__in_pattern(__c))
         return {true, __c - '0'};
     else if ('a' <= __c && __c < 'a' + __base - 10)
         return {true, __c - 'a' + 10};
     else
         return {'A' <= __c && __c < 'A' + __base - 10, __c - 'A' + 10};
 }
 
 template <typename _It, typename _Tp, typename _Fn, typename... _Ts>
 inline _LIBCPP_HIDE_FROM_ABI from_chars_result
 __subject_seq_combinator(_It __first, _It __last, _Tp& __value, _Fn __f,
                          _Ts... __args)
 {
     auto __find_non_zero = [](_It __firstit, _It __lastit) {
         for (; __firstit != __lastit; ++__firstit)
             if (*__firstit != '0')
                 break;
         return __firstit;
     };
 
     auto __p = __find_non_zero(__first, __last);
-    if (__p == __last || !__in_pattern(*__p, __args...))
+    if (__p == __last || !std::__in_pattern(*__p, __args...))
     {
         if (__p == __first)
             return {__first, errc::invalid_argument};
         else
         {
             __value = 0;
             return {__p, {}};
         }
     }
 
     auto __r = __f(__p, __last, __value, __args...);
     if (__r.ec == errc::result_out_of_range)
     {
         for (; __r.ptr != __last; ++__r.ptr)
         {
-            if (!__in_pattern(*__r.ptr, __args...))
+            if (!std::__in_pattern(*__r.ptr, __args...))
                 break;
         }
     }
 
     return __r;
 }
 
 template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>
 inline _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
 {
     using __tx = __itoa::__traits<_Tp>;
     using __output_type = typename __tx::type;
 
-    return __subject_seq_combinator(
+    return std::__subject_seq_combinator(
         __first, __last, __value,
         [](const char* __f, const char* __l,
            _Tp& __val) -> from_chars_result {
             __output_type __a, __b;
             auto __p = __tx::__read(__f, __l, __a, __b);
-            if (__p == __l || !__in_pattern(*__p))
+            if (__p == __l || !std::__in_pattern(*__p))
             {
                 __output_type __m = numeric_limits<_Tp>::max();
                 if (__m >= __a && __m - __a >= __b)
                 {
                     __val = __a + __b;
                     return {__p, {}};
                 }
             }
             return {__p, errc::result_out_of_range};
         });
 }
 
 template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>
 inline _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
 {
-    using __t = decltype(__to_unsigned_like(__value));
-    return __sign_combinator(__first, __last, __value, __from_chars_atoi<__t>);
+    using __t = decltype(std::__to_unsigned_like(__value));
+    return std::__sign_combinator(__first, __last, __value, __from_chars_atoi<__t>);
 }
 
 template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>
 inline _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_integral(const char* __first, const char* __last, _Tp& __value,
                       int __base)
 {
     if (__base == 10)
-        return __from_chars_atoi(__first, __last, __value);
+        return std::__from_chars_atoi(__first, __last, __value);
 
-    return __subject_seq_combinator(
+    return std::__subject_seq_combinator(
         __first, __last, __value,
         [](const char* __p, const char* __lastp, _Tp& __val,
            int __b) -> from_chars_result {
             using __tl = numeric_limits<_Tp>;
             auto __digits = __tl::digits / log2f(float(__b));
             _Tp __x = __in_pattern(*__p++, __b).__val, __y = 0;
 
             for (int __i = 1; __p != __lastp; ++__i, ++__p)
return std::__subject_seq_combinator(
         __base);
 }
 
 template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>
 inline _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_integral(const char* __first, const char* __last, _Tp& __value,
                       int __base)
 {
-    using __t = decltype(__to_unsigned_like(__value));
-    return __sign_combinator(__first, __last, __value,
+    using __t = decltype(std::__to_unsigned_like(__value));
+    return std::__sign_combinator(__first, __last, __value,
                                   __from_chars_integral<__t>, __base);
 }
 
 template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
 inline _LIBCPP_HIDE_FROM_ABI from_chars_result
 from_chars(const char* __first, const char* __last, _Tp& __value)
 {
-    return __from_chars_atoi(__first, __last, __value);
+    return std::__from_chars_atoi(__first, __last, __value);
 }
 
 template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
 inline _LIBCPP_HIDE_FROM_ABI from_chars_result
 from_chars(const char* __first, const char* __last, _Tp& __value, int __base)
 {
     _LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]");
-    return __from_chars_integral(__first, __last, __value, __base);
+    return std::__from_chars_integral(__first, __last, __value, __base);
 }
 
 // Floating-point implementation starts here.
 // Unlike the other parts of charconv this is only available in C++17 and newer.
 #if _LIBCPP_STD_VER > 14
 
 _LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS
 to_chars_result to_chars(char* __first, char* __last, float __value);

libcxx/include/cmath

<
     __promote<_A1, _A2, _A3>
 >::type
 hypot(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT
 {
     typedef typename __promote<_A1, _A2, _A3>::type __result_type;
     static_assert((!(is_same<_A1, __result_type>::value &&
                      is_same<_A2, __result_type>::value &&
                      is_same<_A3, __result_type>::value)), "");
-    return hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
+    return std::hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
 }
 #endif
 
 template <class _A1>
 _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
 __libcpp_isnan_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_isnan)
     return __builtin_isnan(__lcpp_x);
 #else
     return isnan(__lcpp_x);
 #endif
 }
 
 template <class _A1>
 _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
 __libcpp_isnan_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 {
-    return isnan(__lcpp_x);
+    return std::isnan(__lcpp_x);
 }
 
 template <class _A1>
 _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
 __libcpp_isinf_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_isinf)
     return __builtin_isinf(__lcpp_x);
 #else
     return isinf(__lcpp_x);
 #endif
 }
 
 template <class _A1>
 _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
 __libcpp_isinf_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 {
-    return isinf(__lcpp_x);
+    return std::isinf(__lcpp_x);
 }
 
 template <class _A1>
 _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
 __libcpp_isfinite_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_isfinite)
     return __builtin_isfinite(__lcpp_x);
 #else
     return isfinite(__lcpp_x);
 #endif
 }
 
 template <class _A1>
 _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
 __libcpp_isfinite_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 {
-    return isfinite(__lcpp_x);
+    return std::isfinite(__lcpp_x);
 }
 
 #if _LIBCPP_STD_VER > 17
 template <typename _Fp>
 _LIBCPP_HIDE_FROM_ABI constexpr
 _Fp __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept {
     if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
         return __t * __b + (1 - __t) * __a;
<
     __promote<_A1, _A2, _A3>
 >::type
 lerp(_A1 __a, _A2 __b, _A3 __t) noexcept
 {
     typedef typename __promote<_A1, _A2, _A3>::type __result_type;
     static_assert(!(_IsSame<_A1, __result_type>::value &&
                     _IsSame<_A2, __result_type>::value &&
                     _IsSame<_A3, __result_type>::value));
-    return __lerp((__result_type)__a, (__result_type)__b, (__result_type)__t);
+    return std::__lerp((__result_type)__a, (__result_type)__b, (__result_type)__t);
 }
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_CMATH

libcxx/include/complex

operator*(const complex<_Tp>& __z, const complex<_Tp>& __w)
     _Tp __c = __w.real();
     _Tp __d = __w.imag();
     _Tp __ac = __a * __c;
     _Tp __bd = __b * __d;
     _Tp __ad = __a * __d;
     _Tp __bc = __b * __c;
     _Tp __x = __ac - __bd;
     _Tp __y = __ad + __bc;
-    if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
+    if (std::__libcpp_isnan_or_builtin(__x) && std::__libcpp_isnan_or_builtin(__y))
     {
         bool __recalc = false;
-        if (__libcpp_isinf_or_builtin(__a) || __libcpp_isinf_or_builtin(__b))
+        if (std::__libcpp_isinf_or_builtin(__a) || std::__libcpp_isinf_or_builtin(__b))
         {
-            __a = copysign(__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
-            __b = copysign(__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
-            if (__libcpp_isnan_or_builtin(__c))
-                __c = copysign(_Tp(0), __c);
-            if (__libcpp_isnan_or_builtin(__d))
-                __d = copysign(_Tp(0), __d);
+            __a = std::copysign(std::__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
+            __b = std::copysign(std::__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
+            if (std::__libcpp_isnan_or_builtin(__c))
+                __c = std::copysign(_Tp(0), __c);
+            if (std::__libcpp_isnan_or_builtin(__d))
+                __d = std::copysign(_Tp(0), __d);
             __recalc = true;
         }
-        if (__libcpp_isinf_or_builtin(__c) || __libcpp_isinf_or_builtin(__d))
+        if (std::__libcpp_isinf_or_builtin(__c) || std::__libcpp_isinf_or_builtin(__d))
         {
-            __c = copysign(__libcpp_isinf_or_builtin(__c) ? _Tp(1) : _Tp(0), __c);
-            __d = copysign(__libcpp_isinf_or_builtin(__d) ? _Tp(1) : _Tp(0), __d);
-            if (__libcpp_isnan_or_builtin(__a))
-                __a = copysign(_Tp(0), __a);
-            if (__libcpp_isnan_or_builtin(__b))
-                __b = copysign(_Tp(0), __b);
+            __c = std::copysign(std::__libcpp_isinf_or_builtin(__c) ? _Tp(1) : _Tp(0), __c);
+            __d = std::copysign(std::__libcpp_isinf_or_builtin(__d) ? _Tp(1) : _Tp(0), __d);
+            if (std::__libcpp_isnan_or_builtin(__a))
+                __a = std::copysign(_Tp(0), __a);
+            if (std::__libcpp_isnan_or_builtin(__b))
+                __b = std::copysign(_Tp(0), __b);
             __recalc = true;
         }
-        if (!__recalc && (__libcpp_isinf_or_builtin(__ac) || __libcpp_isinf_or_builtin(__bd) ||
-                          __libcpp_isinf_or_builtin(__ad) || __libcpp_isinf_or_builtin(__bc)))
+        if (!__recalc && (std::__libcpp_isinf_or_builtin(__ac) || std::__libcpp_isinf_or_builtin(__bd) ||
+                          std::__libcpp_isinf_or_builtin(__ad) || std::__libcpp_isinf_or_builtin(__bc)))
         {
-            if (__libcpp_isnan_or_builtin(__a))
-                __a = copysign(_Tp(0), __a);
-            if (__libcpp_isnan_or_builtin(__b))
-                __b = copysign(_Tp(0), __b);
-            if (__libcpp_isnan_or_builtin(__c))
-                __c = copysign(_Tp(0), __c);
-            if (__libcpp_isnan_or_builtin(__d))
-                __d = copysign(_Tp(0), __d);
+            if (std::__libcpp_isnan_or_builtin(__a))
+                __a = std::copysign(_Tp(0), __a);
+            if (std::__libcpp_isnan_or_builtin(__b))
+                __b = std::copysign(_Tp(0), __b);
+            if (std::__libcpp_isnan_or_builtin(__c))
+                __c = std::copysign(_Tp(0), __c);
+            if (std::__libcpp_isnan_or_builtin(__d))
+                __d = std::copysign(_Tp(0), __d);
             __recalc = true;
         }
         if (__recalc)
         {
             __x = _Tp(INFINITY) * (__a * __c - __b * __d);
             __y = _Tp(INFINITY) * (__a * __d + __b * __c);
         }
     }

 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 operator/(const complex<_Tp>& __z, const complex<_Tp>& __w)
 {
     int __ilogbw = 0;
     _Tp __a = __z.real();
     _Tp __b = __z.imag();
     _Tp __c = __w.real();
     _Tp __d = __w.imag();
-    _Tp __logbw = logb(fmax(fabs(__c), fabs(__d)));
-    if (__libcpp_isfinite_or_builtin(__logbw))
+    _Tp __logbw = std::logb(std::fmax(std::fabs(__c), std::fabs(__d)));
+    if (std::__libcpp_isfinite_or_builtin(__logbw))
     {
         __ilogbw = static_cast<int>(__logbw);
-        __c = scalbn(__c, -__ilogbw);
-        __d = scalbn(__d, -__ilogbw);
+        __c = std::scalbn(__c, -__ilogbw);
+        __d = std::scalbn(__d, -__ilogbw);
     }
     _Tp __denom = __c * __c + __d * __d;
-    _Tp __x = scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
-    _Tp __y = scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
-    if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
+    _Tp __x = std::scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
+    _Tp __y = std::scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
+    if (std::__libcpp_isnan_or_builtin(__x) && std::__libcpp_isnan_or_builtin(__y))
     {
-        if ((__denom == _Tp(0)) && (!__libcpp_isnan_or_builtin(__a) || !__libcpp_isnan_or_builtin(__b)))
+        if ((__denom == _Tp(0)) && (!std::__libcpp_isnan_or_builtin(__a) || !std::__libcpp_isnan_or_builtin(__b)))
         {
-            __x = copysign(_Tp(INFINITY), __c) * __a;
-            __y = copysign(_Tp(INFINITY), __c) * __b;
+            __x = std::copysign(_Tp(INFINITY), __c) * __a;
+            __y = std::copysign(_Tp(INFINITY), __c) * __b;
         }
-        else if ((__libcpp_isinf_or_builtin(__a) || __libcpp_isinf_or_builtin(__b)) && __libcpp_isfinite_or_builtin(__c) && __libcpp_isfinite_or_builtin(__d))
+        else if ((std::__libcpp_isinf_or_builtin(__a) || std::__libcpp_isinf_or_builtin(__b)) && std::__libcpp_isfinite_or_builtin(__c) && std::__libcpp_isfinite_or_builtin(__d))
         {
-            __a = copysign(__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
-            __b = copysign(__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
+            __a = std::copysign(std::__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
+            __b = std::copysign(std::__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
             __x = _Tp(INFINITY) * (__a * __c + __b * __d);
             __y = _Tp(INFINITY) * (__b * __c - __a * __d);
         }
-        else if (__libcpp_isinf_or_builtin(__logbw) && __logbw > _Tp(0) && __libcpp_isfinite_or_builtin(__a) && __libcpp_isfinite_or_builtin(__b))
+        else if (std::__libcpp_isinf_or_builtin(__logbw) && __logbw > _Tp(0) && std::__libcpp_isfinite_or_builtin(__a) && std::__libcpp_isfinite_or_builtin(__b))
         {
-            __c = copysign(__libcpp_isinf_or_builtin(__c) ? _Tp(1) : _Tp(0), __c);
-            __d = copysign(__libcpp_isinf_or_builtin(__d) ? _Tp(1) : _Tp(0), __d);
+            __c = std::copysign(std::__libcpp_isinf_or_builtin(__c) ? _Tp(1) : _Tp(0), __c);
+            __d = std::copysign(std::__libcpp_isinf_or_builtin(__d) ? _Tp(1) : _Tp(0), __d);
             __x = _Tp(0) * (__a * __c + __b * __d);
             __y = _Tp(0) * (__b * __c - __a * __d);
         }
     }
     return complex<_Tp>(__x, __y);
 }
 
 template<class _Tp>

 
 // abs
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 abs(const complex<_Tp>& __c)
 {
-    return hypot(__c.real(), __c.imag());
+    return std::hypot(__c.real(), __c.imag());
 }
 
 // arg
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 arg(const complex<_Tp>& __c)
 {
-    return atan2(__c.imag(), __c.real());
+    return std::atan2(__c.imag(), __c.real());
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if<
     is_same<_Tp, long double>::value,
     long double
 >::type
 arg(_Tp __re)
 {
-    return atan2l(0.L, __re);
+    return std::atan2l(0.L, __re);
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value || is_same<_Tp, double>::value,
     double
 >::type
 arg(_Tp __re)
 {
-    return atan2(0., __re);
+    return std::atan2(0., __re);
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if<
     is_same<_Tp, float>::value,
     float
 >::type
 arg(_Tp __re)
 {
-    return atan2f(0.F, __re);
+    return std::atan2f(0.F, __re);
 }
 
 // norm
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 norm(const complex<_Tp>& __c)
 {
-    if (__libcpp_isinf_or_builtin(__c.real()))
-        return abs(__c.real());
-    if (__libcpp_isinf_or_builtin(__c.imag()))
-        return abs(__c.imag());
+    if (std::__libcpp_isinf_or_builtin(__c.real()))
+        return std::abs(__c.real());
+    if (std::__libcpp_isinf_or_builtin(__c.imag()))
+        return std::abs(__c.imag());
     return __c.real() * __c.real() + __c.imag() * __c.imag();
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename __libcpp_complex_overload_traits<_Tp>::_ValueType
 norm(_Tp __re)
 {

 // proj
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 complex<_Tp>
 proj(const complex<_Tp>& __c)
 {
     complex<_Tp> __r = __c;
-    if (__libcpp_isinf_or_builtin(__c.real()) || __libcpp_isinf_or_builtin(__c.imag()))
-        __r = complex<_Tp>(INFINITY, copysign(_Tp(0), __c.imag()));
+    if (std::__libcpp_isinf_or_builtin(__c.real()) || std::__libcpp_isinf_or_builtin(__c.imag()))
+        __r = complex<_Tp>(INFINITY, std::copysign(_Tp(0), __c.imag()));
     return __r;
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_floating_point<_Tp>::value,
     typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
 >::type
 proj(_Tp __re)
 {
-    if (__libcpp_isinf_or_builtin(__re))
-        __re = abs(__re);
+    if (std::__libcpp_isinf_or_builtin(__re))
+        __re = std::abs(__re);
     return complex<_Tp>(__re);
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value,
     typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
 >::type
 proj(_Tp __re)
 {
     typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
     return _ComplexType(__re);
 }
 
 // polar
 
 template<class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 polar(const _Tp& __rho, const _Tp& __theta = _Tp())
 {
-    if (__libcpp_isnan_or_builtin(__rho) || signbit(__rho))
+    if (std::__libcpp_isnan_or_builtin(__rho) || std::signbit(__rho))
         return complex<_Tp>(_Tp(NAN), _Tp(NAN));
-    if (__libcpp_isnan_or_builtin(__theta))
+    if (std::__libcpp_isnan_or_builtin(__theta))
     {
-        if (__libcpp_isinf_or_builtin(__rho))
+        if (std::__libcpp_isinf_or_builtin(__rho))
             return complex<_Tp>(__rho, __theta);
         return complex<_Tp>(__theta, __theta);
     }
-    if (__libcpp_isinf_or_builtin(__theta))
+    if (std::__libcpp_isinf_or_builtin(__theta))
     {
-        if (__libcpp_isinf_or_builtin(__rho))
+        if (std::__libcpp_isinf_or_builtin(__rho))
             return complex<_Tp>(__rho, _Tp(NAN));
         return complex<_Tp>(_Tp(NAN), _Tp(NAN));
     }
-    _Tp __x = __rho * cos(__theta);
-    if (__libcpp_isnan_or_builtin(__x))
+    _Tp __x = __rho * std::cos(__theta);
+    if (std::__libcpp_isnan_or_builtin(__x))
         __x = 0;
-    _Tp __y = __rho * sin(__theta);
-    if (__libcpp_isnan_or_builtin(__y))
+    _Tp __y = __rho * std::sin(__theta);
+    if (std::__libcpp_isnan_or_builtin(__y))
         __y = 0;
     return complex<_Tp>(__x, __y);
 }
 
 // log
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 complex<_Tp>
 log(const complex<_Tp>& __x)
 {
-    return complex<_Tp>(log(abs(__x)), arg(__x));
+    return complex<_Tp>(std::log(std::abs(__x)), std::arg(__x));
 }
 
 // log10
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 complex<_Tp>
 log10(const complex<_Tp>& __x)
 {
-    return log(__x) / log(_Tp(10));
+    return std::log(__x) / std::log(_Tp(10));
 }
 
 // sqrt
 
 template<class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 sqrt(const complex<_Tp>& __x)
 {
-    if (__libcpp_isinf_or_builtin(__x.imag()))
+    if (std::__libcpp_isinf_or_builtin(__x.imag()))
         return complex<_Tp>(_Tp(INFINITY), __x.imag());
-    if (__libcpp_isinf_or_builtin(__x.real()))
+    if (std::__libcpp_isinf_or_builtin(__x.real()))
     {
         if (__x.real() > _Tp(0))
-            return complex<_Tp>(__x.real(), __libcpp_isnan_or_builtin(__x.imag()) ? __x.imag() : copysign(_Tp(0), __x.imag()));
-        return complex<_Tp>(__libcpp_isnan_or_builtin(__x.imag()) ? __x.imag() : _Tp(0), copysign(__x.real(), __x.imag()));
+            return complex<_Tp>(__x.real(), std::__libcpp_isnan_or_builtin(__x.imag()) ? __x.imag() : std::copysign(_Tp(0), __x.imag()));
+        return complex<_Tp>(std::__libcpp_isnan_or_builtin(__x.imag()) ? __x.imag() : _Tp(0), std::copysign(__x.real(), __x.imag()));
     }
-    return polar(sqrt(abs(__x)), arg(__x) / _Tp(2));
+    return std::polar(std::sqrt(std::abs(__x)), std::arg(__x) / _Tp(2));
 }
 
 // exp
 
 template<class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 exp(const complex<_Tp>& __x)
 {
     _Tp __i = __x.imag();
     if (__i == 0) {
-        return complex<_Tp>(exp(__x.real()), copysign(_Tp(0), __x.imag()));
+        return complex<_Tp>(std::exp(__x.real()), std::copysign(_Tp(0), __x.imag()));
     }
-    if (__libcpp_isinf_or_builtin(__x.real()))
+    if (std::__libcpp_isinf_or_builtin(__x.real()))
     {
         if (__x.real() < _Tp(0))
         {
-            if (!__libcpp_isfinite_or_builtin(__i))
+            if (!std::__libcpp_isfinite_or_builtin(__i))
                 __i = _Tp(1);
         }
-        else if (__i == 0 || !__libcpp_isfinite_or_builtin(__i))
+        else if (__i == 0 || !std::__libcpp_isfinite_or_builtin(__i))
         {
-            if (__libcpp_isinf_or_builtin(__i))
+            if (std::__libcpp_isinf_or_builtin(__i))
                 __i = _Tp(NAN);
             return complex<_Tp>(__x.real(), __i);
         }
     }
-    _Tp __e = exp(__x.real());
-    return complex<_Tp>(__e * cos(__i), __e * sin(__i));
+    _Tp __e = std::exp(__x.real());
+    return complex<_Tp>(__e * std::cos(__i), __e * std::sin(__i));
 }
 
 // pow
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 complex<_Tp>
 pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
 {
-    return exp(__y * log(__x));
+    return std::exp(__y * std::log(__x));
 }
 
 template<class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 complex<typename __promote<_Tp, _Up>::type>
 pow(const complex<_Tp>& __x, const complex<_Up>& __y)
 {
     typedef complex<typename __promote<_Tp, _Up>::type> result_type;

 
 // asinh
 
 template<class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 asinh(const complex<_Tp>& __x)
 {
     const _Tp __pi(atan2(+0., -0.));
-    if (__libcpp_isinf_or_builtin(__x.real()))
+    if (std::__libcpp_isinf_or_builtin(__x.real()))
     {
-        if (__libcpp_isnan_or_builtin(__x.imag()))
+        if (std::__libcpp_isnan_or_builtin(__x.imag()))
             return __x;
-        if (__libcpp_isinf_or_builtin(__x.imag()))
-            return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
-        return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
+        if (std::__libcpp_isinf_or_builtin(__x.imag()))
+            return complex<_Tp>(__x.real(), std::copysign(__pi * _Tp(0.25), __x.imag()));
+        return complex<_Tp>(__x.real(), std::copysign(_Tp(0), __x.imag()));
     }
-    if (__libcpp_isnan_or_builtin(__x.real()))
+    if (std::__libcpp_isnan_or_builtin(__x.real()))
     {
-        if (__libcpp_isinf_or_builtin(__x.imag()))
+        if (std::__libcpp_isinf_or_builtin(__x.imag()))
             return complex<_Tp>(__x.imag(), __x.real());
         if (__x.imag() == 0)
             return __x;
         return complex<_Tp>(__x.real(), __x.real());
     }
-    if (__libcpp_isinf_or_builtin(__x.imag()))
-        return complex<_Tp>(copysign(__x.imag(), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
-    complex<_Tp> __z = log(__x + sqrt(__sqr(__x) + _Tp(1)));
-    return complex<_Tp>(copysign(__z.real(), __x.real()), copysign(__z.imag(), __x.imag()));
+    if (std::__libcpp_isinf_or_builtin(__x.imag()))
+        return complex<_Tp>(std::copysign(__x.imag(), __x.real()), std::copysign(__pi/_Tp(2), __x.imag()));
+    complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) + _Tp(1)));
+    return complex<_Tp>(std::copysign(__z.real(), __x.real()), std::copysign(__z.imag(), __x.imag()));
 }
 
 // acosh
 
 template<class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 acosh(const complex<_Tp>& __x)
 {
-    const _Tp __pi(atan2(+0., -0.));
-    if (__libcpp_isinf_or_builtin(__x.real()))
+    const _Tp __pi(std::atan2(+0., -0.));
+    if (std::__libcpp_isinf_or_builtin(__x.real()))
     {
-        if (__libcpp_isnan_or_builtin(__x.imag()))
-            return complex<_Tp>(abs(__x.real()), __x.imag());
-        if (__libcpp_isinf_or_builtin(__x.imag()))
+        if (std::__libcpp_isnan_or_builtin(__x.imag()))
+            return complex<_Tp>(std::abs(__x.real()), __x.imag());
+        if (std::__libcpp_isinf_or_builtin(__x.imag()))
         {
             if (__x.real() > 0)
-                return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
+                return complex<_Tp>(__x.real(), std::copysign(__pi * _Tp(0.25), __x.imag()));
             else
-                return complex<_Tp>(-__x.real(), copysign(__pi * _Tp(0.75), __x.imag()));
+                return complex<_Tp>(-__x.real(), std::copysign(__pi * _Tp(0.75), __x.imag()));
         }
         if (__x.real() < 0)
-            return complex<_Tp>(-__x.real(), copysign(__pi, __x.imag()));
-        return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
+            return complex<_Tp>(-__x.real(), std::copysign(__pi, __x.imag()));
+        return complex<_Tp>(__x.real(), std::copysign(_Tp(0), __x.imag()));
     }
-    if (__libcpp_isnan_or_builtin(__x.real()))
+    if (std::__libcpp_isnan_or_builtin(__x.real()))
     {
-        if (__libcpp_isinf_or_builtin(__x.imag()))
-            return complex<_Tp>(abs(__x.imag()), __x.real());
+        if (std::__libcpp_isinf_or_builtin(__x.imag()))
+            return complex<_Tp>(std::abs(__x.imag()), __x.real());
         return complex<_Tp>(__x.real(), __x.real());
     }
-    if (__libcpp_isinf_or_builtin(__x.imag()))
-        return complex<_Tp>(abs(__x.imag()), copysign(__pi/_Tp(2), __x.imag()));
-    complex<_Tp> __z = log(__x + sqrt(__sqr(__x) - _Tp(1)));
-    return complex<_Tp>(copysign(__z.real(), _Tp(0)), copysign(__z.imag(), __x.imag()));
+    if (std::__libcpp_isinf_or_builtin(__x.imag()))
+        return complex<_Tp>(std::abs(__x.imag()), std::copysign(__pi/_Tp(2), __x.imag()));
+    complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) - _Tp(1)));
+    return complex<_Tp>(std::copysign(__z.real(), _Tp(0)), std::copysign(__z.imag(), __x.imag()));
 }
 
 // atanh
 
 template<class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 atanh(const complex<_Tp>& __x)
 {
     const _Tp __pi(atan2(+0., -0.));
-    if (__libcpp_isinf_or_builtin(__x.imag()))
+    if (std::__libcpp_isinf_or_builtin(__x.imag()))
     {
-        return complex<_Tp>(copysign(_Tp(0), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
+        return complex<_Tp>(std::copysign(_Tp(0), __x.real()), std::copysign(__pi/_Tp(2), __x.imag()));
     }
-    if (__libcpp_isnan_or_builtin(__x.imag()))
+    if (std::__libcpp_isnan_or_builtin(__x.imag()))
     {
-        if (__libcpp_isinf_or_builtin(__x.real()) || __x.real() == 0)
-            return complex<_Tp>(copysign(_Tp(0), __x.real()), __x.imag());
+        if (std::__libcpp_isinf_or_builtin(__x.real()) || __x.real() == 0)
+            return complex<_Tp>(std::copysign(_Tp(0), __x.real()), __x.imag());
         return complex<_Tp>(__x.imag(), __x.imag());
     }
-    if (__libcpp_isnan_or_builtin(__x.real()))
+    if (std::__libcpp_isnan_or_builtin(__x.real()))
     {
         return complex<_Tp>(__x.real(), __x.real());
     }
-    if (__libcpp_isinf_or_builtin(__x.real()))
+    if (std::__libcpp_isinf_or_builtin(__x.real()))
     {
-        return complex<_Tp>(copysign(_Tp(0), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
+        return complex<_Tp>(std::copysign(_Tp(0), __x.real()), std::copysign(__pi/_Tp(2), __x.imag()));
     }
-    if (abs(__x.real()) == _Tp(1) && __x.imag() == _Tp(0))
+    if (std::abs(__x.real()) == _Tp(1) && __x.imag() == _Tp(0))
     {
-        return complex<_Tp>(copysign(_Tp(INFINITY), __x.real()), copysign(_Tp(0), __x.imag()));
+        return complex<_Tp>(std::copysign(_Tp(INFINITY), __x.real()), std::copysign(_Tp(0), __x.imag()));
     }
-    complex<_Tp> __z = log((_Tp(1) + __x) / (_Tp(1) - __x)) / _Tp(2);
-    return complex<_Tp>(copysign(__z.real(), __x.real()), copysign(__z.imag(), __x.imag()));
+    complex<_Tp> __z = std::log((_Tp(1) + __x) / (_Tp(1) - __x)) / _Tp(2);
+    return complex<_Tp>(std::copysign(__z.real(), __x.real()), std::copysign(__z.imag(), __x.imag()));
 }
 
 // sinh
 
 template<class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 sinh(const complex<_Tp>& __x)
 {
-    if (__libcpp_isinf_or_builtin(__x.real()) && !__libcpp_isfinite_or_builtin(__x.imag()))
+    if (std::__libcpp_isinf_or_builtin(__x.real()) && !std::__libcpp_isfinite_or_builtin(__x.imag()))
         return complex<_Tp>(__x.real(), _Tp(NAN));
-    if (__x.real() == 0 && !__libcpp_isfinite_or_builtin(__x.imag()))
+    if (__x.real() == 0 && !std::__libcpp_isfinite_or_builtin(__x.imag()))
         return complex<_Tp>(__x.real(), _Tp(NAN));
-    if (__x.imag() == 0 && !__libcpp_isfinite_or_builtin(__x.real()))
+    if (__x.imag() == 0 && !std::__libcpp_isfinite_or_builtin(__x.real()))
         return __x;
-    return complex<_Tp>(sinh(__x.real()) * cos(__x.imag()), cosh(__x.real()) * sin(__x.imag()));
+    return complex<_Tp>(std::sinh(__x.real()) * std::cos(__x.imag()), std::cosh(__x.real()) * std::sin(__x.imag()));
 }
 
 // cosh
 
 template<class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 cosh(const complex<_Tp>& __x)
 {
-    if (__libcpp_isinf_or_builtin(__x.real()) && !__libcpp_isfinite_or_builtin(__x.imag()))
-        return complex<_Tp>(abs(__x.real()), _Tp(NAN));
-    if (__x.real() == 0 && !__libcpp_isfinite_or_builtin(__x.imag()))
+    if (std::__libcpp_isinf_or_builtin(__x.real()) && !std::__libcpp_isfinite_or_builtin(__x.imag()))
+        return complex<_Tp>(std::abs(__x.real()), _Tp(NAN));
+    if (__x.real() == 0 && !std::__libcpp_isfinite_or_builtin(__x.imag()))
         return complex<_Tp>(_Tp(NAN), __x.real());
     if (__x.real() == 0 && __x.imag() == 0)
         return complex<_Tp>(_Tp(1), __x.imag());
-    if (__x.imag() == 0 && !__libcpp_isfinite_or_builtin(__x.real()))
-        return complex<_Tp>(abs(__x.real()), __x.imag());
-    return complex<_Tp>(cosh(__x.real()) * cos(__x.imag()), sinh(__x.real()) * sin(__x.imag()));
+    if (__x.imag() == 0 && !std::__libcpp_isfinite_or_builtin(__x.real()))
+        return complex<_Tp>(std::abs(__x.real()), __x.imag());
+    return complex<_Tp>(std::cosh(__x.real()) * std::cos(__x.imag()), std::sinh(__x.real()) * std::sin(__x.imag()));
 }
 
 // tanh
 
 template<class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 tanh(const complex<_Tp>& __x)
 {
-    if (__libcpp_isinf_or_builtin(__x.real()))
+    if (std::__libcpp_isinf_or_builtin(__x.real()))
     {
-        if (!__libcpp_isfinite_or_builtin(__x.imag()))
-            return complex<_Tp>(copysign(_Tp(1), __x.real()), _Tp(0));
-        return complex<_Tp>(copysign(_Tp(1), __x.real()), copysign(_Tp(0), sin(_Tp(2) * __x.imag())));
+        if (!std::__libcpp_isfinite_or_builtin(__x.imag()))
+            return complex<_Tp>(std::copysign(_Tp(1), __x.real()), _Tp(0));
+        return complex<_Tp>(std::copysign(_Tp(1), __x.real()), std::copysign(_Tp(0), std::sin(_Tp(2) * __x.imag())));
     }
-    if (__libcpp_isnan_or_builtin(__x.real()) && __x.imag() == 0)
+    if (std::__libcpp_isnan_or_builtin(__x.real()) && __x.imag() == 0)
         return __x;
     _Tp __2r(_Tp(2) * __x.real());
     _Tp __2i(_Tp(2) * __x.imag());
-    _Tp __d(cosh(__2r) + cos(__2i));
-    _Tp __2rsh(sinh(__2r));
-    if (__libcpp_isinf_or_builtin(__2rsh) && __libcpp_isinf_or_builtin(__d))
+    _Tp __d(std::cosh(__2r) + std::cos(__2i));
+    _Tp __2rsh(std::sinh(__2r));
+    if (std::__libcpp_isinf_or_builtin(__2rsh) && std::__libcpp_isinf_or_builtin(__d))
         return complex<_Tp>(__2rsh > _Tp(0) ? _Tp(1) : _Tp(-1),
                             __2i > _Tp(0) ? _Tp(0) : _Tp(-0.));
-    return  complex<_Tp>(__2rsh/__d, sin(__2i)/__d);
+    return  complex<_Tp>(__2rsh/__d, std::sin(__2i)/__d);
 }
 
 // asin
 
 template<class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 asin(const complex<_Tp>& __x)
 {
-    complex<_Tp> __z = asinh(complex<_Tp>(-__x.imag(), __x.real()));
+    complex<_Tp> __z = std::asinh(complex<_Tp>(-__x.imag(), __x.real()));
     return complex<_Tp>(__z.imag(), -__z.real());
 }
 
 // acos
 
 template<class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 acos(const complex<_Tp>& __x)
 {
     const _Tp __pi(atan2(+0., -0.));
-    if (__libcpp_isinf_or_builtin(__x.real()))
+    if (std::__libcpp_isinf_or_builtin(__x.real()))
     {
-        if (__libcpp_isnan_or_builtin(__x.imag()))
+        if (std::__libcpp_isnan_or_builtin(__x.imag()))
             return complex<_Tp>(__x.imag(), __x.real());
-        if (__libcpp_isinf_or_builtin(__x.imag()))
+        if (std::__libcpp_isinf_or_builtin(__x.imag()))
         {
             if (__x.real() < _Tp(0))
                 return complex<_Tp>(_Tp(0.75) * __pi, -__x.imag());
             return complex<_Tp>(_Tp(0.25) * __pi, -__x.imag());
         }
         if (__x.real() < _Tp(0))
-            return complex<_Tp>(__pi, signbit(__x.imag()) ? -__x.real() : __x.real());
-        return complex<_Tp>(_Tp(0), signbit(__x.imag()) ? __x.real() : -__x.real());
+            return complex<_Tp>(__pi, std::signbit(__x.imag()) ? -__x.real() : __x.real());
+        return complex<_Tp>(_Tp(0), std::signbit(__x.imag()) ? __x.real() : -__x.real());
     }
-    if (__libcpp_isnan_or_builtin(__x.real()))
+    if (std::__libcpp_isnan_or_builtin(__x.real()))
     {
-        if (__libcpp_isinf_or_builtin(__x.imag()))
+        if (std::__libcpp_isinf_or_builtin(__x.imag()))
             return complex<_Tp>(__x.real(), -__x.imag());
         return complex<_Tp>(__x.real(), __x.real());
     }
-    if (__libcpp_isinf_or_builtin(__x.imag()))
+    if (std::__libcpp_isinf_or_builtin(__x.imag()))
         return complex<_Tp>(__pi/_Tp(2), -__x.imag());
-    if (__x.real() == 0 && (__x.imag() == 0 || isnan(__x.imag())))
+    if (__x.real() == 0 && (__x.imag() == 0 || std::isnan(__x.imag())))
         return complex<_Tp>(__pi/_Tp(2), -__x.imag());
-    complex<_Tp> __z = log(__x + sqrt(__sqr(__x) - _Tp(1)));
-    if (signbit(__x.imag()))
-        return complex<_Tp>(abs(__z.imag()), abs(__z.real()));
-    return complex<_Tp>(abs(__z.imag()), -abs(__z.real()));
+    complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) - _Tp(1)));
+    if (std::signbit(__x.imag()))
+        return complex<_Tp>(std::abs(__z.imag()), std::abs(__z.real()));
+    return complex<_Tp>(std::abs(__z.imag()), -std::abs(__z.real()));
 }
 
 // atan
 
 template<class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 atan(const complex<_Tp>& __x)
 {
-    complex<_Tp> __z = atanh(complex<_Tp>(-__x.imag(), __x.real()));
+    complex<_Tp> __z = std::atanh(complex<_Tp>(-__x.imag(), __x.real()));
     return complex<_Tp>(__z.imag(), -__z.real());
 }
 
 // sin
 
 template<class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 sin(const complex<_Tp>& __x)
 {
-    complex<_Tp> __z = sinh(complex<_Tp>(-__x.imag(), __x.real()));
+    complex<_Tp> __z = std::sinh(complex<_Tp>(-__x.imag(), __x.real()));
     return complex<_Tp>(__z.imag(), -__z.real());
 }
 
 // cos
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 complex<_Tp>
 cos(const complex<_Tp>& __x)
 {
-    return cosh(complex<_Tp>(-__x.imag(), __x.real()));
+    return std::cosh(complex<_Tp>(-__x.imag(), __x.real()));
 }
 
 // tan
 
 template<class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 tan(const complex<_Tp>& __x)
 {
-    complex<_Tp> __z = tanh(complex<_Tp>(-__x.imag(), __x.real()));
+    complex<_Tp> __z = std::tanh(complex<_Tp>(-__x.imag(), __x.real()));
     return complex<_Tp>(__z.imag(), -__z.real());
 }
 
 template<class _Tp, class _CharT, class _Traits>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
 {
     if (__is.good())
     {
-        ws(__is);
+        std::ws(__is);
         if (__is.peek() == _CharT('('))
         {
             __is.get();
             _Tp __r;
             __is >> __r;
             if (!__is.fail())
             {
-                ws(__is);
+                std::ws(__is);
                 _CharT __c = __is.peek();
                 if (__c == _CharT(','))
                 {
                     __is.get();
                     _Tp __i;
                     __is >> __i;
                     if (!__is.fail())
                     {
-                        ws(__is);
+                        std::ws(__is);
                         __c = __is.peek();
                         if (__c == _CharT(')'))
                         {
                             __is.get();
                             __x = complex<_Tp>(__r, __i);
                         }
                         else
                             __is.setstate(__is.failbit);

libcxx/include/deque

else if (__map_.size() < __map_.capacity())
         __start_ = __map_.size() == 1 ?
                                __block_size / 2 :
                                __start_ + __block_size;
     }
     // Else need to allocate 1 buffer, *and* we need to reallocate __map_.
     else
     {
         __split_buffer<pointer, __pointer_allocator&>
-            __buf(max<size_type>(2 * __map_.capacity(), 1),
+            __buf(std::max<size_type>(2 * __map_.capacity(), 1),
                   0, __map_.__alloc());
 
         typedef __allocator_destructor<_Allocator> _Dp;
         unique_ptr<pointer, _Dp> __hold(
             __alloc_traits::allocate(__a, __block_size),
                 _Dp(__a, __block_size));
         __buf.push_back(__hold.get());
         __hold.release();
else if (__nb <= __map_.capacity() - __map_.size())
             __map_.push_front(__pt);
         }
     }
     // Else need to allocate __nb buffers, *and* we need to reallocate __map_.
     else
     {
         size_type __ds = (__nb + __back_capacity) * __block_size - __map_.empty();
         __split_buffer<pointer, __pointer_allocator&>
-            __buf(max<size_type>(2* __map_.capacity(),
+            __buf(std::max<size_type>(2* __map_.capacity(),
                                       __nb + __map_.size()),
                   0, __map_.__alloc());
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_NO_EXCEPTIONS
             for (; __nb > 0; --__nb)
                 __buf.push_back(__alloc_traits::allocate(__a, __block_size));
 #ifndef _LIBCPP_NO_EXCEPTIONS
else if (__map_.size() < __map_.capacity())
             __map_.pop_front();
             __map_.push_back(__pt);
         }
     }
     // Else need to allocate 1 buffer, *and* we need to reallocate __map_.
     else
     {
         __split_buffer<pointer, __pointer_allocator&>
-            __buf(max<size_type>(2* __map_.capacity(), 1),
+            __buf(std::max<size_type>(2* __map_.capacity(), 1),
                   __map_.size(),
                   __map_.__alloc());
 
         typedef __allocator_destructor<_Allocator> _Dp;
         unique_ptr<pointer, _Dp> __hold(
             __alloc_traits::allocate(__a, __block_size),
                 _Dp(__a, __block_size));
         __buf.push_back(__hold.get());
else if (__nb <= __map_.capacity() - __map_.size())
             __map_.push_back(__pt);
         }
     }
     // Else need to allocate __nb buffers, *and* we need to reallocate __map_.
     else
     {
         size_type __ds = __front_capacity * __block_size;
         __split_buffer<pointer, __pointer_allocator&>
-            __buf(max<size_type>(2* __map_.capacity(),
+            __buf(std::max<size_type>(2* __map_.capacity(),
                                       __nb + __map_.size()),
                   __map_.size() - __front_capacity,
                   __map_.__alloc());
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_NO_EXCEPTIONS
             for (; __nb > 0; --__nb)
                 __buf.push_back(__alloc_traits::allocate(__a, __block_size));

libcxx/include/experimental/functional

typedef _BMSkipTable<value_type, difference_type, _Hash, _BinaryPredicate,
                     is_same<_BinaryPredicate, equal_to<>>::value
             > skip_table_type;
 
 public:
     boyer_moore_searcher(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l,
                 _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate())
             : __first_(__f), __last_(__l), __pred_(__pred),
               __pattern_length_(_VSTD::distance(__first_, __last_)),
-              __skip_{make_shared<skip_table_type>(__pattern_length_, -1, __hf, __pred_)},
-              __suffix_{make_shared<vector<difference_type>>(__pattern_length_ + 1)}
+              __skip_{std::make_shared<skip_table_type>(__pattern_length_, -1, __hf, __pred_)},
+              __suffix_{std::make_shared<vector<difference_type>>(__pattern_length_ + 1)}
         {
     //  build the skip table
         for ( difference_type __i = 0; __f != __l; ++__f, (void) ++__i )
             __skip_->insert(*__f, __i);
 
         this->__build_suffix_table ( __first_, __last_, __pred_ );
         }
 
     template <typename _RandomAccessIterator2>
     pair<_RandomAccessIterator2, _RandomAccessIterator2>
     operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const
     {
         static_assert(__is_same_uncvref<typename iterator_traits<_RandomAccessIterator1>::value_type,
                                         typename iterator_traits<_RandomAccessIterator2>::value_type>::value,
                       "Corpus and Pattern iterators must point to the same type");
 
-        if (__f      == __l )    return make_pair(__l, __l); // empty corpus
-        if (__first_ == __last_) return make_pair(__f, __f); // empty pattern
+        if (__f      == __l )    return std::make_pair(__l, __l); // empty corpus
+        if (__first_ == __last_) return std::make_pair(__f, __f); // empty pattern
 
     //  If the pattern is larger than the corpus, we can't find it!
         if ( __pattern_length_ > _VSTD::distance(__f, __l))
-            return make_pair(__l, __l);
+            return std::make_pair(__l, __l);
 
     //  Do the search
         return this->__search(__f, __l);
     }
 
 private:
     _RandomAccessIterator1               __first_;
     _RandomAccessIterator1               __last_;
__search(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const
         {
 
         //  Do we match right where we are?
             difference_type __j = __pattern_length_;
             while (__pred_(__first_ [__j-1], __cur [__j-1])) {
                 __j--;
             //  We matched - we're done!
                 if ( __j == 0 )
-                    return make_pair(__cur, __cur + __pattern_length_);
+                    return std::make_pair(__cur, __cur + __pattern_length_);
                 }
 
         //  Since we didn't match, figure out how far to skip forward
             difference_type __k = __skip[__cur [ __j - 1 ]];
             difference_type __m = __j - __k - 1;
             if (__k < __j && __m > __suffix[ __j ])
                 __cur += __m;
             else
                 __cur += __suffix[ __j ];
         }
 
-        return make_pair(__l, __l);     // We didn't find anything
+        return std::make_pair(__l, __l);     // We didn't find anything
     }
 
 
     template<typename _Iterator, typename _Container>
     void __compute_bm_prefix ( _Iterator __f, _Iterator __l, _BinaryPredicate __pred, _Container &__prefix )
     {
         const size_t __count = _VSTD::distance(__f, __l);
 
public:
     template <typename _RandomAccessIterator2>
     pair<_RandomAccessIterator2, _RandomAccessIterator2>
     operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const
     {
         static_assert(__is_same_uncvref<typename std::iterator_traits<_RandomAccessIterator1>::value_type,
                                         typename std::iterator_traits<_RandomAccessIterator2>::value_type>::value,
                       "Corpus and Pattern iterators must point to the same type");
 
-        if (__f      == __l )    return make_pair(__l, __l); // empty corpus
-        if (__first_ == __last_) return make_pair(__f, __f); // empty pattern
+        if (__f      == __l )    return std::make_pair(__l, __l); // empty corpus
+        if (__first_ == __last_) return std::make_pair(__f, __f); // empty pattern
 
     //  If the pattern is larger than the corpus, we can't find it!
         if ( __pattern_length_ > _VSTD::distance(__f, __l))
-            return make_pair(__l, __l);
+            return std::make_pair(__l, __l);
 
     //  Do the search
         return this->__search(__f, __l);
     }
 
 private:
     _RandomAccessIterator1      __first_;
     _RandomAccessIterator1      __last_;
__search ( _RandomAccessIterator2 __f, _RandomAccessIterator2 __l ) const {
         {
         //  Do we match right where we are?
             difference_type __j = __pattern_length_;
             while (__pred_(__first_[__j-1], __cur[__j-1]))
             {
                 __j--;
             //  We matched - we're done!
                 if ( __j == 0 )
-                    return make_pair(__cur, __cur + __pattern_length_);
+                    return std::make_pair(__cur, __cur + __pattern_length_);
             }
             __cur += __skip[__cur[__pattern_length_-1]];
         }
 
-        return make_pair(__l, __l);
+        return std::make_pair(__l, __l);
     }
 };
 
 template<class _RandomAccessIterator,
          class _Hash = hash<typename iterator_traits<_RandomAccessIterator>::value_type>,
          class _BinaryPredicate = equal_to<>>
 _LIBCPP_DEPRECATED_BOYER_MOORE_HORSPOOL_SEARCHER _LIBCPP_INLINE_VISIBILITY
 boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>

libcxx/include/experimental/simd

 }
 
 template <class _From, class _To>
 _LIBCPP_HIDE_FROM_ABI
 constexpr typename std::enable_if<std::is_arithmetic<_To>::value &&
                                       std::is_arithmetic<_From>::value,
                                   bool>::type
 __is_non_narrowing_arithmetic_convertible() {
-  return __is_non_narrowing_convertible_impl<_To>(_From{});
+  return experimental::__is_non_narrowing_convertible_impl<_To>(_From{});
 }
 
 template <class _From, class _To>
 _LIBCPP_HIDE_FROM_ABI
 constexpr typename std::enable_if<!(std::is_arithmetic<_To>::value &&
                                     std::is_arithmetic<_From>::value),
                                   bool>::type
 __is_non_narrowing_arithmetic_convertible() {
   return false;
 }
 
 template <class _Tp>
 _LIBCPP_HIDE_FROM_ABI constexpr _Tp __variadic_sum() {
   return _Tp{};
 }
 
 template <class _Tp, class _Up, class... _Args>
 _LIBCPP_HIDE_FROM_ABI constexpr _Tp __variadic_sum(_Up __first, _Args... __rest) {
-  return static_cast<_Tp>(__first) + __variadic_sum<_Tp>(__rest...);
+  return static_cast<_Tp>(__first) + experimental::__variadic_sum<_Tp>(__rest...);
 }
 
 template <class _Tp>
 struct __nodeduce {
   using type = _Tp;
 };
 
 template <class _Tp>

 split(const simd<typename _SimdType::value_type, _Abi>&);
 
 template <class _SimdType, class _Abi>
 array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /
                      _SimdType::size()>
 split(const simd_mask<typename _SimdType::value_type, _Abi>&);
 
 template <class _Tp, class... _Abis>
-simd<_Tp, abi_for_size_t<_Tp, __variadic_sum(simd_size<_Tp, _Abis>::value...)>>
+simd<_Tp, abi_for_size_t<_Tp, experimental::__variadic_sum(simd_size<_Tp, _Abis>::value...)>>
 concat(const simd<_Tp, _Abis>&...);
 
 template <class _Tp, class... _Abis>
 simd_mask<_Tp,
-          abi_for_size_t<_Tp, __variadic_sum(simd_size<_Tp, _Abis>::value...)>>
+          abi_for_size_t<_Tp, experimental::__variadic_sum(simd_size<_Tp, _Abis>::value...)>>
 concat(const simd_mask<_Tp, _Abis>&...);
 
 // reductions [simd.mask.reductions]
 template <class _Tp, class _Abi>
 bool all_of(const simd_mask<_Tp, _Abi>&) noexcept;
 template <class _Tp, class _Abi>
 bool any_of(const simd_mask<_Tp, _Abi>&) noexcept;
 template <class _Tp, class _Abi>
private:
   }
 
   template <class _Generator, size_t... __indicies>
   static constexpr decltype(
       std::forward_as_tuple(std::declval<_Generator>()(
           std::integral_constant<size_t, __indicies>())...),
       bool())
   __can_generate(std::index_sequence<__indicies...>) {
-    return !__variadic_sum<bool>(
+    return !experimental::__variadic_sum<bool>(
         !__can_broadcast<decltype(std::declval<_Generator>()(
             std::integral_constant<size_t, __indicies>()))>()...);
   }
 
   template <class _Generator>
   static bool __can_generate(...) {
     return false;
   }

libcxx/include/format

while (__begin != __end) {
     case _CharT('{'):
       ++__begin;
       if (__begin == __end)
         __throw_format_error("The format string terminates at a '{'");
 
       if (*__begin != _CharT('{')) [[likely]] {
         __ctx.advance_to(_VSTD::move(__out_it));
         __begin =
-            __handle_replacement_field(__begin, __end, __parse_ctx, __ctx);
+            __format::__handle_replacement_field(__begin, __end, __parse_ctx, __ctx);
         __out_it = __ctx.out();
 
         // The output is written and __begin points to the next character. So
         // start the next iteration.
         continue;
       }
       // The string is an escape character.
       break;

libcxx/include/fstream

: __extbuf_(nullptr),
       __st_(),
       __st_last_(),
       __om_(0),
       __cm_(0),
       __owns_eb_(false),
       __owns_ib_(false),
       __always_noconv_(false)
 {
-    if (has_facet<codecvt<char_type, char, state_type> >(this->getloc()))
+    if (std::has_facet<codecvt<char_type, char, state_type> >(this->getloc()))
     {
-        __cv_ = &use_facet<codecvt<char_type, char, state_type> >(this->getloc());
+        __cv_ = &std::use_facet<codecvt<char_type, char, state_type> >(this->getloc());
         __always_noconv_ = __cv_->always_noconv();
     }
     setbuf(nullptr, 4096);
 }
 
 template <class _CharT, class _Traits>
 basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs)
     : basic_streambuf<_CharT, _Traits>(__rhs)

 basic_filebuf<_CharT, _Traits>::underflow()
 {
     if (__file_ == nullptr)
         return traits_type::eof();
     bool __initial = __read_mode();
     char_type __1buf;
     if (this->gptr() == nullptr)
         this->setg(&__1buf, &__1buf+1, &__1buf+1);
-    const size_t __unget_sz = __initial ? 0 : min<size_t>((this->egptr() - this->eback()) / 2, 4);
+    const size_t __unget_sz = __initial ? 0 : std::min<size_t>((this->egptr() - this->eback()) / 2, 4);
     int_type __c = traits_type::eof();
     if (this->gptr() == this->egptr())
     {
         _VSTD::memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type));
         if (__always_noconv_)
         {
             size_t __nmemb = static_cast<size_t>(this->egptr() - this->eback() - __unget_sz);
-            __nmemb = fread(this->eback() + __unget_sz, 1, __nmemb, __file_);
+            __nmemb = ::fread(this->eback() + __unget_sz, 1, __nmemb, __file_);
             if (__nmemb != 0)
             {
                 this->setg(this->eback(),
                            this->eback() + __unget_sz,
                            this->eback() + __unget_sz + __nmemb);
                 __c = traits_type::to_int_type(*this->gptr());
             }
         }
if (!traits_type::eq_int_type(__c, traits_type::eof()))
         *this->pptr() = traits_type::to_char_type(__c);
         this->pbump(1);
     }
     if (this->pptr() != this->pbase())
     {
         if (__always_noconv_)
         {
             size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
-            if (fwrite(this->pbase(), sizeof(char_type), __nmemb, __file_) != __nmemb)
+            if (std::fwrite(this->pbase(), sizeof(char_type), __nmemb, __file_) != __nmemb)
                 return traits_type::eof();
         }
         else
         {
             char* __extbe = __extbuf_;
             codecvt_base::result __r;
             do
             {
                 if (!__cv_)
                     __throw_bad_cast();
 
                 const char_type* __e;
                 __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e,
                                         __extbuf_, __extbuf_ + __ebs_, __extbe);
                 if (__e == this->pbase())
                     return traits_type::eof();
                 if (__r == codecvt_base::noconv)
                 {
                     size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
-                    if (fwrite(this->pbase(), 1, __nmemb, __file_) != __nmemb)
+                    if (std::fwrite(this->pbase(), 1, __nmemb, __file_) != __nmemb)
                         return traits_type::eof();
                 }
                 else if (__r == codecvt_base::ok || __r == codecvt_base::partial)
                 {
                     size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_);
                     if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb)
                         return traits_type::eof();
                     if (__r == codecvt_base::partial)
basic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way,
     default:
         return pos_type(off_type(-1));
     }
 #if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
     if (fseek(__file_, __width > 0 ? __width * __off : 0, __whence))
         return pos_type(off_type(-1));
     pos_type __r = ftell(__file_);
 #else
-    if (fseeko(__file_, __width > 0 ? __width * __off : 0, __whence))
+    if (::fseeko(__file_, __width > 0 ? __width * __off : 0, __whence))
         return pos_type(off_type(-1));
     pos_type __r = ftello(__file_);
 #endif
     __r.state(__st_);
     return __r;
 }
 
 template <class _CharT, class _Traits>
 typename basic_filebuf<_CharT, _Traits>::pos_type
 basic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode)
 {
     if (__file_ == nullptr || sync())
         return pos_type(off_type(-1));
 #if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
     if (fseek(__file_, __sp, SEEK_SET))
         return pos_type(off_type(-1));
 #else
-    if (fseeko(__file_, __sp, SEEK_SET))
+    if (::fseeko(__file_, __sp, SEEK_SET))
         return pos_type(off_type(-1));
 #endif
     __st_ = __sp.state();
     return __sp;
 }
 
 template <class _CharT, class _Traits>
 int
else if (__cm_ & ios_base::in)
                     __update_st = true;
                 }
             }
         }
 #if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
         if (fseek(__file_, -__c, SEEK_CUR))
             return -1;
 #else
-        if (fseeko(__file_, -__c, SEEK_CUR))
+        if (::fseeko(__file_, -__c, SEEK_CUR))
             return -1;
 #endif
         if (__update_st)
             __st_ = __state;
         __extbufnext_ = __extbufend_ = __extbuf_;
         this->setg(nullptr, nullptr, nullptr);
         __cm_ = 0;
     }
     return 0;
 }
 
 template <class _CharT, class _Traits>
 void
 basic_filebuf<_CharT, _Traits>::imbue(const locale& __loc)
 {
     sync();
-    __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
+    __cv_ = &std::use_facet<codecvt<char_type, char, state_type> >(__loc);
     bool __old_anc = __always_noconv_;
     __always_noconv_ = __cv_->always_noconv();
     if (__old_anc != __always_noconv_)
     {
         this->setg(nullptr, nullptr, nullptr);
         this->setp(nullptr, nullptr);
         // invariant, char_type is char, else we couldn't get here
         if (__always_noconv_)  // need to dump __intbuf_

libcxx/include/future

 
 template <class _Rp>
 _Rp
 __assoc_state<_Rp>::move()
 {
     unique_lock<mutex> __lk(this->__mut_);
     this->__sub_wait(__lk);
     if (this->__exception_ != nullptr)
-        rethrow_exception(this->__exception_);
+        std::rethrow_exception(this->__exception_);
     return _VSTD::move(*reinterpret_cast<_Rp*>(&__value_));
 }
 
 template <class _Rp>
 __add_lvalue_reference_t<_Rp>
 __assoc_state<_Rp>::copy()
 {
     unique_lock<mutex> __lk(this->__mut_);
     this->__sub_wait(__lk);
     if (this->__exception_ != nullptr)
-        rethrow_exception(this->__exception_);
+        std::rethrow_exception(this->__exception_);
     return *reinterpret_cast<_Rp*>(&__value_);
 }
 
 template <class _Rp>
 class _LIBCPP_AVAILABILITY_FUTURE __assoc_state<_Rp&>
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;

 
 template <class _Rp>
 _Rp&
 __assoc_state<_Rp&>::copy()
 {
     unique_lock<mutex> __lk(this->__mut_);
     this->__sub_wait(__lk);
     if (this->__exception_ != nullptr)
-        rethrow_exception(this->__exception_);
+        std::rethrow_exception(this->__exception_);
     return *__value_;
 }
 
 template <class _Rp, class _Alloc>
 class _LIBCPP_AVAILABILITY_FUTURE __assoc_state_alloc
     : public __assoc_state<_Rp>
 {
     typedef __assoc_state<_Rp> base;

libcxx/include/iomanip

#ifndef _LIBCPP_NO_EXCEPTIONS
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         typename basic_istream<_CharT, _Traits>::sentry __s(__is);
         if (__s)
         {
             typedef istreambuf_iterator<_CharT, _Traits> _Ip;
             typedef money_get<_CharT, _Ip> _Fp;
             ios_base::iostate __err = ios_base::goodbit;
-            const _Fp& __mf = use_facet<_Fp>(__is.getloc());
+            const _Fp& __mf = std::use_facet<_Fp>(__is.getloc());
             __mf.get(_Ip(__is), _Ip(), __x.__intl_, __is, __err, __x.__mon_);
             __is.setstate(__err);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __is.__set_badbit_and_consider_rethrow();
#ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
         if (__s)
         {
             typedef ostreambuf_iterator<_CharT, _Traits> _Op;
             typedef money_put<_CharT, _Op> _Fp;
-            const _Fp& __mf = use_facet<_Fp>(__os.getloc());
+            const _Fp& __mf = std::use_facet<_Fp>(__os.getloc());
             if (__mf.put(_Op(__os), __x.__intl_, __os, __os.fill(), __x.__mon_).failed())
                 __os.setstate(ios_base::badbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __os.__set_badbit_and_consider_rethrow();
#ifndef _LIBCPP_NO_EXCEPTIONS
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         typename basic_istream<_CharT, _Traits>::sentry __s(__is);
         if (__s)
         {
             typedef istreambuf_iterator<_CharT, _Traits> _Ip;
             typedef time_get<_CharT, _Ip> _Fp;
             ios_base::iostate __err = ios_base::goodbit;
-            const _Fp& __tf = use_facet<_Fp>(__is.getloc());
+            const _Fp& __tf = std::use_facet<_Fp>(__is.getloc());
             __tf.get(_Ip(__is), _Ip(), __is, __err, __x.__tm_,
                      __x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_));
             __is.setstate(__err);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
#ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
         if (__s)
         {
             typedef ostreambuf_iterator<_CharT, _Traits> _Op;
             typedef time_put<_CharT, _Op> _Fp;
-            const _Fp& __tf = use_facet<_Fp>(__os.getloc());
+            const _Fp& __tf = std::use_facet<_Fp>(__os.getloc());
             if (__tf.put(_Op(__os), __os, __os.fill(), __x.__tm_,
                          __x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_)).failed())
                 __os.setstate(ios_base::badbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {

libcxx/include/ios

basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
     return __r;
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 char
 basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const
 {
-    return use_facet<ctype<char_type> >(getloc()).narrow(__c, __dfault);
+    return std::use_facet<ctype<char_type> >(getloc()).narrow(__c, __dfault);
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 _CharT
 basic_ios<_CharT, _Traits>::widen(char __c) const
 {
-    return use_facet<ctype<char_type> >(getloc()).widen(__c);
+    return std::use_facet<ctype<char_type> >(getloc()).widen(__c);
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 _CharT
 basic_ios<_CharT, _Traits>::fill() const
 {
     if (traits_type::eq_int_type(traits_type::eof(), __fill_))

libcxx/include/istream

 {
     if (__is.good())
     {
         if (__is.tie())
             __is.tie()->flush();
         if (!__noskipws && (__is.flags() & ios_base::skipws))
         {
             typedef istreambuf_iterator<_CharT, _Traits> _Ip;
-            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
+            const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
             _Ip __i(__is);
             _Ip __eof;
             for (; __i != __eof; ++__i)
                 if (!__ct.is(__ct.space, *__i))
                     break;
             if (__i == __eof)
                 __is.setstate(ios_base::failbit | ios_base::eofbit);
         }
__input_arithmetic(basic_istream<_CharT, _Traits>& __is, _Tp& __n) {
     if (__s)
     {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_NO_EXCEPTIONS
             typedef istreambuf_iterator<_CharT, _Traits> _Ip;
             typedef num_get<_CharT, _Ip> _Fp;
-            use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __n);
+            std::use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __n);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
             __state |= ios_base::badbit;
             __is.__setstate_nothrow(__state);
             if (__is.exceptions() & ios_base::badbit)
             {
__input_arithmetic_with_numeric_limits(basic_istream<_CharT, _Traits>& __is, _Tp& __n) {
     {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_NO_EXCEPTIONS
             typedef istreambuf_iterator<_CharT, _Traits> _Ip;
             typedef num_get<_CharT, _Ip> _Fp;
             long __temp;
-            use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __temp);
+            std::use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __temp);
             if (__temp < numeric_limits<_Tp>::min())
             {
                 __state |= ios_base::failbit;
                 __n = numeric_limits<_Tp>::min();
             }
             else if (__temp > numeric_limits<_Tp>::max())
             {
                 __state |= ios_base::failbit;
__input_c_string(basic_istream<_CharT, _Traits>& __is, _CharT* __p, size_t __n)
     typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
     if (__sen)
     {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif
             _CharT* __s = __p;
-            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
+            const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
             while (__s != __p + (__n-1))
             {
                 typename _Traits::int_type __i = __is.rdbuf()->sgetc();
                 if (_Traits::eq_int_type(__i, _Traits::eof()))
                 {
                    __state |= ios_base::eofbit;
                    break;
                 }
ws(basic_istream<_CharT, _Traits>& __is)
     ios_base::iostate __state = ios_base::goodbit;
     typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
     if (__sen)
     {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_NO_EXCEPTIONS
-            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
+            const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
             while (true)
             {
                 typename _Traits::int_type __i = __is.rdbuf()->sgetc();
                 if (_Traits::eq_int_type(__i, _Traits::eof()))
                 {
                    __state |= ios_base::eofbit;
                    break;
                 }

 #endif
             __str.clear();
             streamsize __n = __is.width();
             if (__n <= 0)
                 __n = __str.max_size();
             if (__n <= 0)
                 __n = numeric_limits<streamsize>::max();
             streamsize __c = 0;
-            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
+            const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
             while (__c < __n)
             {
                 typename _Traits::int_type __i = __is.rdbuf()->sgetc();
                 if (_Traits::eq_int_type(__i, _Traits::eof()))
                 {
                    __state |= ios_base::eofbit;
                    break;
                 }

 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_istream<_CharT, _Traits>&
 getline(basic_istream<_CharT, _Traits>& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str)
 {
-    return getline(__is, __str, __is.widen('\n'));
+    return std::getline(__is, __str, __is.widen('\n'));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_istream<_CharT, _Traits>&
 getline(basic_istream<_CharT, _Traits>&& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm)
 {
-    return getline(__is, __str, __dlm);
+    return std::getline(__is, __str, __dlm);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_istream<_CharT, _Traits>&
 getline(basic_istream<_CharT, _Traits>&& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str)
 {
-    return getline(__is, __str, __is.widen('\n'));
+    return std::getline(__is, __str, __is.widen('\n'));
 }
 
 template <class _CharT, class _Traits, size_t _Size>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
 {
     ios_base::iostate __state = ios_base::goodbit;
     typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
     if (__sen)
     {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif
             basic_string<_CharT, _Traits> __str;
-            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
+            const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
             size_t __c = 0;
             _CharT __zero = __ct.widen('0');
             _CharT __one = __ct.widen('1');
             while (__c != _Size)
             {
                 typename _Traits::int_type __i = __is.rdbuf()->sgetc();
                 if (_Traits::eq_int_type(__i, _Traits::eof()))
                 {

libcxx/include/locale

 };
 
 #ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
 template <class _CharT>
 string
 __num_get<_CharT>::__stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep)
 {
     locale __loc = __iob.getloc();
-    use_facet<ctype<_CharT> >(__loc).widen(__src, __src + 26, __atoms);
-    const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
+    std::use_facet<ctype<_CharT> >(__loc).widen(__src, __src + 26, __atoms);
+    const numpunct<_CharT>& __np = std::use_facet<numpunct<_CharT> >(__loc);
     __thousands_sep = __np.thousands_sep();
     return __np.grouping();
 }
 #endif
 
 template <class _CharT>
 string
 __num_get<_CharT>::__stage2_float_prep(ios_base& __iob, _CharT* __atoms, _CharT& __decimal_point,
                     _CharT& __thousands_sep)
 {
     locale __loc = __iob.getloc();
-    use_facet<ctype<_CharT> >(__loc).widen(__src, __src + 32, __atoms);
-    const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
+    std::use_facet<ctype<_CharT> >(__loc).widen(__src, __src + 32, __atoms);
+    const numpunct<_CharT>& __np = std::use_facet<numpunct<_CharT> >(__loc);
     __decimal_point = __np.decimal_point();
     __thousands_sep = __np.thousands_sep();
     return __np.grouping();
 }
 
 template <class _CharT>
 int
 #ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
#endif
     {
         if (__g_end-__g < __num_get_buf_sz)
         {
             *__g_end++ = __dc;
             __dc = 0;
         }
         return 0;
     }
-    ptrdiff_t __f = find(__atoms, __atoms + 26, __ct) - __atoms;
+    ptrdiff_t __f = std::find(__atoms, __atoms + 26, __ct) - __atoms;
     if (__f >= 24)
         return -1;
     switch (__base)
     {
     case 8:
     case 10:
         if (__f >= __base)
             return -1;
if (__ct == __thousands_sep && __grouping.size() != 0)
             return -1;
         if (__g_end-__g < __num_get_buf_sz)
         {
             *__g_end++ = __dc;
             __dc = 0;
         }
         return 0;
     }
-    ptrdiff_t __f = find(__atoms, __atoms + 32, __ct) - __atoms;
+    ptrdiff_t __f = std::find(__atoms, __atoms + 32, __ct) - __atoms;
     if (__f >= 32)
         return -1;
     char __x = __src[__f];
     if (__x == '-' || __x == '+')
     {
         if (__a_end == __a || (__a_end[-1] & 0x5F) == (__exp & 0x7F))
         {
             *__a_end++ = __x;

 _Tp
 __num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err)
 {
     if (__a != __a_end)
     {
         __libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
         errno = 0;
         char *__p2;
-        _Tp __ld = __do_strtod<_Tp>(__a, &__p2);
+        _Tp __ld = std::__do_strtod<_Tp>(__a, &__p2);
         __libcpp_remove_reference_t<decltype(errno)> __current_errno = errno;
         if (__current_errno == 0)
             errno = __save_errno;
         if (__p2 != __a_end)
         {
             __err = ios_base::failbit;
             return 0;
         }
if ((__iob.flags() & ios_base::boolalpha) == 0)
             break;
         default:
             __v = true;
             __err = ios_base::failbit;
             break;
         }
         return __b;
     }
-    const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__iob.getloc());
-    const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__iob.getloc());
+    const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__iob.getloc());
+    const numpunct<_CharT>& __np = std::use_facet<numpunct<_CharT> >(__iob.getloc());
     typedef typename numpunct<_CharT>::string_type string_type;
     const string_type __names[2] = {__np.truename(), __np.falsename()};
     const string_type* __i = _VSTD::__scan_keyword(__b, __e, __names, __names+2,
                                                    __ct, __err);
     __v = __i == __names;
     return __b;
 }
 
for (; __b != __e; ++__b)
         if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
                                     __thousands_sep, __grouping, __g, __g_end,
                                     __atoms))
             break;
     }
     if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz)
         *__g_end++ = __dc;
     // Stage 3
-    __v = __num_get_signed_integral<_Signed>(__a, __a_end, __err, __base);
+    __v = std::__num_get_signed_integral<_Signed>(__a, __a_end, __err, __base);
     // Digit grouping checked
     __check_grouping(__grouping, __g, __g_end, __err);
     // EOF checked
     if (__b == __e)
         __err |= ios_base::eofbit;
     return __b;
 }
 
for (; __b != __e; ++__b)
         if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
                                     __thousands_sep, __grouping, __g, __g_end,
                                     __atoms))
             break;
     }
     if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz)
         *__g_end++ = __dc;
     // Stage 3
-    __v = __num_get_unsigned_integral<_Unsigned>(__a, __a_end, __err, __base);
+    __v = std::__num_get_unsigned_integral<_Unsigned>(__a, __a_end, __err, __base);
     // Digit grouping checked
     __check_grouping(__grouping, __g, __g_end, __err);
     // EOF checked
     if (__b == __e)
         __err |= ios_base::eofbit;
     return __b;
 }
 
for (; __b != __e; ++__b)
                                       __decimal_point, __thousands_sep,
                                       __grouping, __g, __g_end,
                                       __dc, __atoms))
             break;
     }
     if (__grouping.size() != 0 && __in_units && __g_end-__g < __num_get_base::__num_get_buf_sz)
         *__g_end++ = __dc;
     // Stage 3
-    __v = __num_get_float<_Fp>(__a, __a_end, __err);
+    __v = std::__num_get_float<_Fp>(__a, __a_end, __err);
     // Digit grouping checked
     __check_grouping(__grouping, __g, __g_end, __err);
     // EOF checked
     if (__b == __e)
         __err |= ios_base::eofbit;
     return __b;
 }
 
 template <class _CharT, class _InputIterator>
 _InputIterator
 num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
                                         ios_base& __iob,
                                         ios_base::iostate& __err,
                                         void*& __v) const
 {
     // Stage 1
     int __base = 16;
     // Stage 2
     char_type __atoms[26];
     char_type __thousands_sep = 0;
     string __grouping;
-    use_facet<ctype<_CharT> >(__iob.getloc()).widen(__num_get_base::__src,
+    std::use_facet<ctype<_CharT> >(__iob.getloc()).widen(__num_get_base::__src,
                                                          __num_get_base::__src + 26, __atoms);
     string __buf;
     __buf.resize(__buf.capacity());
     char* __a = &__buf[0];
     char* __a_end = __a;
     unsigned __g[__num_get_base::__num_get_buf_sz];
     unsigned* __g_end = __g;
     unsigned __dc = 0;
     for (; __b != __e; ++__b)

 };
 
 template <class _CharT>
 void
 __num_put<_CharT>::__widen_and_group_int(char* __nb, char* __np, char* __ne,
                                          _CharT* __ob, _CharT*& __op, _CharT*& __oe,
                                          const locale& __loc)
 {
-    const ctype<_CharT>&    __ct = use_facet<ctype<_CharT> >   (__loc);
-    const numpunct<_CharT>& __npt = use_facet<numpunct<_CharT> >(__loc);
+    const ctype<_CharT>&    __ct = std::use_facet<ctype<_CharT> >   (__loc);
+    const numpunct<_CharT>& __npt = std::use_facet<numpunct<_CharT> >(__loc);
     string __grouping = __npt.grouping();
     if (__grouping.empty())
     {
         __ct.widen(__nb, __ne, __ob);
         __oe = __ob + (__ne - __nb);
     }
     else
     {
         __oe = __ob;
         char* __nf = __nb;
         if (*__nf == '-' || *__nf == '+')
             *__oe++ = __ct.widen(*__nf++);
         if (__ne - __nf >= 2 && __nf[0] == '0' && (__nf[1] == 'x' ||
                                                    __nf[1] == 'X'))
         {
             *__oe++ = __ct.widen(*__nf++);
             *__oe++ = __ct.widen(*__nf++);
         }
-        reverse(__nf, __ne);
+        std::reverse(__nf, __ne);
         _CharT __thousands_sep = __npt.thousands_sep();
         unsigned __dc = 0;
         unsigned __dg = 0;
         for (char* __p = __nf; __p < __ne; ++__p)
         {
             if (static_cast<unsigned>(__grouping[__dg]) > 0 &&
                 __dc == static_cast<unsigned>(__grouping[__dg]))
             {
                 *__oe++ = __thousands_sep;
                 __dc = 0;
                 if (__dg < __grouping.size()-1)
                     ++__dg;
             }
             *__oe++ = __ct.widen(*__p);
             ++__dc;
         }
-        reverse(__ob + (__nf - __nb), __oe);
+        std::reverse(__ob + (__nf - __nb), __oe);
     }
     if (__np == __ne)
         __op = __oe;
     else
         __op = __ob + (__np - __nb);
 }
 
 template <class _CharT>
 void
 __num_put<_CharT>::__widen_and_group_float(char* __nb, char* __np, char* __ne,
                                            _CharT* __ob, _CharT*& __op, _CharT*& __oe,
                                            const locale& __loc)
 {
-    const ctype<_CharT>&    __ct = use_facet<ctype<_CharT> >   (__loc);
-    const numpunct<_CharT>& __npt = use_facet<numpunct<_CharT> >(__loc);
+    const ctype<_CharT>&    __ct = std::use_facet<ctype<_CharT> >   (__loc);
+    const numpunct<_CharT>& __npt = std::use_facet<numpunct<_CharT> >(__loc);
     string __grouping = __npt.grouping();
     __oe = __ob;
     char* __nf = __nb;
     if (*__nf == '-' || *__nf == '+')
         *__oe++ = __ct.widen(*__nf++);
     char* __ns;
     if (__ne - __nf >= 2 && __nf[0] == '0' && (__nf[1] == 'x' ||
                                                __nf[1] == 'X'))
__num_put<_CharT>::__widen_and_group_float(char* __nb, char* __np, char* __ne,
     }
     if (__grouping.empty())
     {
         __ct.widen(__nf, __ns, __oe);
         __oe += __ns - __nf;
     }
     else
     {
-        reverse(__nf, __ns);
+        std::reverse(__nf, __ns);
         _CharT __thousands_sep = __npt.thousands_sep();
         unsigned __dc = 0;
         unsigned __dg = 0;
         for (char* __p = __nf; __p < __ns; ++__p)
         {
             if (__grouping[__dg] > 0 && __dc == static_cast<unsigned>(__grouping[__dg]))
             {
                 *__oe++ = __thousands_sep;
                 __dc = 0;
                 if (__dg < __grouping.size()-1)
                     ++__dg;
             }
             *__oe++ = __ct.widen(*__p);
             ++__dc;
         }
-        reverse(__ob + (__nf - __nb), __oe);
+        std::reverse(__ob + (__nf - __nb), __oe);
     }
     for (__nf = __ns; __nf < __ne; ++__nf)
     {
         if (*__nf == '.')
         {
             *__oe++ = __npt.decimal_point();
             ++__nf;
             break;

 
 template <class _CharT, class _OutputIterator>
 _OutputIterator
 num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
                                          char_type __fl, bool __v) const
 {
     if ((__iob.flags() & ios_base::boolalpha) == 0)
         return do_put(__s, __iob, __fl, (unsigned long)__v);
-    const numpunct<char_type>& __np = use_facet<numpunct<char_type> >(__iob.getloc());
+    const numpunct<char_type>& __np = std::use_facet<numpunct<char_type> >(__iob.getloc());
     typedef typename numpunct<char_type>::string_type string_type;
 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
     string_type __tmp(__v ? __np.truename() : __np.falsename());
     string_type __nm = _VSTD::move(__tmp);
 #else
     string_type __nm = __v ? __np.truename() : __np.falsename();
 #endif
     for (typename string_type::iterator __i = __nm.begin(); __i != __nm.end(); ++__i, ++__s)
num_put<_CharT, _OutputIterator>::__do_put_integral(iter_type __s, ios_base& __iob,
     _LIBCPP_CONSTEXPR const unsigned __nbuf
         = (numeric_limits<_Unsigned>::digits / 3)        // 1 char per 3 bits
         + ((numeric_limits<_Unsigned>::digits % 3) != 0) // round up
         + 2; // base prefix + terminating null character
     char __nar[__nbuf];
     _LIBCPP_DIAGNOSTIC_PUSH
     _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
     _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
-    int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
+    int __nc = std::__libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
     _LIBCPP_DIAGNOSTIC_POP
     char* __ne = __nar + __nc;
     char* __np = this->__identify_padding(__nar, __ne, __iob);
     // Stage 2 - Widen __nar while adding thousands separators
     char_type __o[2*(__nbuf-1) - 1];
     char_type* __op;  // pad here
     char_type* __oe;  // end of output
     this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc());
     // [__o, __oe) contains thousands_sep'd wide number
     // Stage 3 & 4
-    return __pad_and_output(__s, __o, __op, __oe, __iob, __fl);
+    return std::__pad_and_output(__s, __o, __op, __oe, __iob, __fl);
 }
 
 template <class _CharT, class _OutputIterator>
 _OutputIterator
 num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
                                          char_type __fl, long __v) const
 {
     return this->__do_put_integral(__s, __iob, __fl, __v, "l");
num_put<_CharT, _OutputIterator>::__do_put_floating_point(iter_type __s, ios_base& __iob,
     const unsigned __nbuf = 30;
     char __nar[__nbuf];
     char* __nb = __nar;
     int __nc;
     _LIBCPP_DIAGNOSTIC_PUSH
     _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
     _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
     if (__specify_precision)
-        __nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
+        __nc = std::__libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
                                    (int)__iob.precision(), __v);
     else
-        __nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
+        __nc = std::__libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
     unique_ptr<char, void(*)(void*)> __nbh(nullptr, free);
     if (__nc > static_cast<int>(__nbuf-1))
     {
         if (__specify_precision)
-            __nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
+            __nc = std::__libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
         else
-            __nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
+            __nc = std::__libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
         if (__nc == -1)
             __throw_bad_alloc();
         __nbh.reset(__nb);
     }
     _LIBCPP_DIAGNOSTIC_POP
     char* __ne = __nb + __nc;
     char* __np = this->__identify_padding(__nb, __ne, __iob);
     // Stage 2 - Widen __nar while adding thousands separators
     char_type __o[2*(__nbuf-1) - 1];
     char_type* __ob = __o;
     unique_ptr<char_type, void(*)(void*)> __obh(0, free);
     if (__nb != __nar)
     {
         __ob = (char_type*)malloc(2*static_cast<size_t>(__nc)*sizeof(char_type));
         if (__ob == 0)
             __throw_bad_alloc();
         __obh.reset(__ob);
     }
     char_type* __op;  // pad here
     char_type* __oe;  // end of output
     this->__widen_and_group_float(__nb, __np, __ne, __ob, __op, __oe, __iob.getloc());
     // [__o, __oe) contains thousands_sep'd wide number
     // Stage 3 & 4
-    __s = __pad_and_output(__s, __ob, __op, __oe, __iob, __fl);
+    __s = std::__pad_and_output(__s, __ob, __op, __oe, __iob, __fl);
     return __s;
 }
 
 template <class _CharT, class _OutputIterator>
 _OutputIterator
 num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
                                          char_type __fl, double __v) const
 {
num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
     char __nar[__nbuf];
     int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, "%p", __v);
     char* __ne = __nar + __nc;
     char* __np = this->__identify_padding(__nar, __ne, __iob);
     // Stage 2 - Widen __nar
     char_type __o[2*(__nbuf-1) - 1];
     char_type* __op;  // pad here
     char_type* __oe;  // end of output
-    const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
+    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
     __ct.widen(__nar, __ne, __o);
     __oe = __o + (__ne - __nar);
     if (__np == __ne)
         __op = __oe;
     else
         __op = __o + (__np - __nar);
     // [__o, __oe) contains wide number
     // Stage 3 & 4
-    return __pad_and_output(__s, __o, __op, __oe, __iob, __fl);
+    return std::__pad_and_output(__s, __o, __op, __oe, __iob, __fl);
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<char>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<wchar_t>;
 #endif
 
 template <class _CharT, class _InputIterator>

 
 template <class _CharT, class _InputIterator>
 void
 time_get<_CharT, _InputIterator>::__get_month(int& __m,
                                               iter_type& __b, iter_type __e,
                                               ios_base::iostate& __err,
                                               const ctype<char_type>& __ct) const
 {
-    int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2) - 1;
+    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2) - 1;
     if (!(__err & ios_base::failbit) && 0 <= __t && __t <= 11)
         __m = __t;
     else
         __err |= ios_base::failbit;
 }
 
 template <class _CharT, class _InputIterator>
 void
 time_get<_CharT, _InputIterator>::__get_year(int& __y,
                                              iter_type& __b, iter_type __e,
                                              ios_base::iostate& __err,
                                              const ctype<char_type>& __ct) const
 {
-    int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 4);
+    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 4);
     if (!(__err & ios_base::failbit))
     {
         if (__t < 69)
             __t += 2000;
         else if (69 <= __t && __t <= 99)
             __t += 1900;
         __y = __t - 1900;
     }
 }
 
 template <class _CharT, class _InputIterator>
 void
 time_get<_CharT, _InputIterator>::__get_year4(int& __y,
                                               iter_type& __b, iter_type __e,
                                               ios_base::iostate& __err,
                                               const ctype<char_type>& __ct) const
 {
-    int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 4);
+    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 4);
     if (!(__err & ios_base::failbit))
         __y = __t - 1900;
 }
 
 template <class _CharT, class _InputIterator>
 void
 time_get<_CharT, _InputIterator>::__get_hour(int& __h,
                                              iter_type& __b, iter_type __e,
                                              ios_base::iostate& __err,
                                              const ctype<char_type>& __ct) const
 {
-    int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2);
+    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
     if (!(__err & ios_base::failbit) && __t <= 23)
         __h = __t;
     else
         __err |= ios_base::failbit;
 }
 
 template <class _CharT, class _InputIterator>
 void
 time_get<_CharT, _InputIterator>::__get_12_hour(int& __h,
                                                 iter_type& __b, iter_type __e,
                                                 ios_base::iostate& __err,
                                                 const ctype<char_type>& __ct) const
 {
-    int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2);
+    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
     if (!(__err & ios_base::failbit) && 1 <= __t && __t <= 12)
         __h = __t;
     else
         __err |= ios_base::failbit;
 }
 
 template <class _CharT, class _InputIterator>
 void
 time_get<_CharT, _InputIterator>::__get_minute(int& __m,
                                                iter_type& __b, iter_type __e,
                                                ios_base::iostate& __err,
                                                const ctype<char_type>& __ct) const
 {
-    int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2);
+    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
     if (!(__err & ios_base::failbit) && __t <= 59)
         __m = __t;
     else
         __err |= ios_base::failbit;
 }
 
 template <class _CharT, class _InputIterator>
 void
 time_get<_CharT, _InputIterator>::__get_second(int& __s,
                                                iter_type& __b, iter_type __e,
                                                ios_base::iostate& __err,
                                                const ctype<char_type>& __ct) const
 {
-    int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2);
+    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
     if (!(__err & ios_base::failbit) && __t <= 60)
         __s = __t;
     else
         __err |= ios_base::failbit;
 }
 
 template <class _CharT, class _InputIterator>
 void
 time_get<_CharT, _InputIterator>::__get_weekday(int& __w,
                                                 iter_type& __b, iter_type __e,
                                                 ios_base::iostate& __err,
                                                 const ctype<char_type>& __ct) const
 {
-    int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 1);
+    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 1);
     if (!(__err & ios_base::failbit) && __t <= 6)
         __w = __t;
     else
         __err |= ios_base::failbit;
 }
 
 template <class _CharT, class _InputIterator>
 void
 time_get<_CharT, _InputIterator>::__get_day_year_num(int& __d,
                                                      iter_type& __b, iter_type __e,
                                                      ios_base::iostate& __err,
                                                      const ctype<char_type>& __ct) const
 {
-    int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 3);
+    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 3);
     if (!(__err & ios_base::failbit) && __t <= 365)
         __d = __t;
     else
         __err |= ios_base::failbit;
 }
 
 template <class _CharT, class _InputIterator>
 void

 
 template <class _CharT, class _InputIterator>
 _InputIterator
 time_get<_CharT, _InputIterator>::get(iter_type __b, iter_type __e,
                                       ios_base& __iob,
                                       ios_base::iostate& __err, tm* __tm,
                                       const char_type* __fmtb, const char_type* __fmte) const
 {
-    const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
+    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
     __err = ios_base::goodbit;
     while (__fmtb != __fmte && __err == ios_base::goodbit)
     {
         if (__b == __e)
         {
             __err = ios_base::failbit;
             break;
         }

 
 template <class _CharT, class _InputIterator>
 _InputIterator
 time_get<_CharT, _InputIterator>::do_get_weekday(iter_type __b, iter_type __e,
                                                  ios_base& __iob,
                                                  ios_base::iostate& __err,
                                                  tm* __tm) const
 {
-    const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
+    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
     __get_weekdayname(__tm->tm_wday, __b, __e, __err, __ct);
     return __b;
 }
 
 template <class _CharT, class _InputIterator>
 _InputIterator
 time_get<_CharT, _InputIterator>::do_get_monthname(iter_type __b, iter_type __e,
                                                    ios_base& __iob,
                                                    ios_base::iostate& __err,
                                                    tm* __tm) const
 {
-    const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
+    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
     __get_monthname(__tm->tm_mon, __b, __e, __err, __ct);
     return __b;
 }
 
 template <class _CharT, class _InputIterator>
 _InputIterator
 time_get<_CharT, _InputIterator>::do_get_year(iter_type __b, iter_type __e,
                                               ios_base& __iob,
                                               ios_base::iostate& __err,
                                               tm* __tm) const
 {
-    const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
+    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
     __get_year(__tm->tm_year, __b, __e, __err, __ct);
     return __b;
 }
 
 template <class _CharT, class _InputIterator>
 _InputIterator
 time_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
                                          ios_base& __iob,
                                          ios_base::iostate& __err, tm* __tm,
                                          char __fmt, char) const
 {
     __err = ios_base::goodbit;
-    const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
+    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
     switch (__fmt)
     {
     case 'a':
     case 'A':
         __get_weekdayname(__tm->tm_wday, __b, __e, __err, __ct);
         break;
     case 'b':
     case 'B':

 
 template <class _CharT, class _OutputIterator>
 _OutputIterator
 time_put<_CharT, _OutputIterator>::put(iter_type __s, ios_base& __iob,
                                        char_type __fl, const tm* __tm,
                                        const char_type* __pb,
                                        const char_type* __pe) const
 {
-    const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
+    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
     for (; __pb != __pe; ++__pb)
     {
         if (__ct.narrow(*__pb, 0) == '%')
         {
             if (++__pb == __pe)
             {
                 *__s++ = __pb[-1];
                 break;
__money_get<_CharT>::__gather_info(bool __intl, const locale& __loc,
                                    money_base::pattern& __pat, char_type& __dp,
                                    char_type& __ts, string& __grp,
                                    string_type& __sym, string_type& __psn,
                                    string_type& __nsn, int& __fd)
 {
     if (__intl)
     {
         const moneypunct<char_type, true>& __mp =
-            use_facet<moneypunct<char_type, true> >(__loc);
+            std::use_facet<moneypunct<char_type, true> >(__loc);
         __pat = __mp.neg_format();
         __nsn = __mp.negative_sign();
         __psn = __mp.positive_sign();
         __dp = __mp.decimal_point();
         __ts = __mp.thousands_sep();
         __grp = __mp.grouping();
         __sym = __mp.curr_symbol();
         __fd = __mp.frac_digits();
     }
     else
     {
         const moneypunct<char_type, false>& __mp =
-            use_facet<moneypunct<char_type, false> >(__loc);
+            std::use_facet<moneypunct<char_type, false> >(__loc);
         __pat = __mp.neg_format();
         __nsn = __mp.negative_sign();
         __psn = __mp.positive_sign();
         __dp = __mp.decimal_point();
         __ts = __mp.thousands_sep();
         __grp = __mp.grouping();
         __sym = __mp.curr_symbol();
         __fd = __mp.frac_digits();

 {
     bool __owns = __b.get_deleter() != __do_nothing;
     size_t __cur_cap = static_cast<size_t>(__e-__b.get()) * sizeof(_Tp);
     size_t __new_cap = __cur_cap < numeric_limits<size_t>::max() / 2 ?
                        2 * __cur_cap : numeric_limits<size_t>::max();
     if (__new_cap == 0)
         __new_cap = sizeof(_Tp);
     size_t __n_off = static_cast<size_t>(__n - __b.get());
-    _Tp* __t = (_Tp*)realloc(__owns ? __b.get() : 0, __new_cap);
+    _Tp* __t = (_Tp*)std::realloc(__owns ? __b.get() : 0, __new_cap);
     if (__t == 0)
         __throw_bad_alloc();
     if (__owns)
         __b.release();
     __b = unique_ptr<_Tp, void(*)(void*)>(__t, free);
     __new_cap /= sizeof(_Tp);
     __n = __b.get() + __n_off;
     __e = __b.get() + __new_cap;
for (unsigned __p = 0; __p < 4 && __b != __e; ++__p)
                                 __pat.field[__p - 1] == money_base::space)) {
                     // Match spaces we've already read against spaces at
                     // the beginning of __sym.
                     while (__sym_space_end != __sym.end() &&
                            __ct.is(ctype_base::space, *__sym_space_end))
                         ++__sym_space_end;
                     const size_t __num_spaces = __sym_space_end - __sym.begin();
                     if (__num_spaces > __spaces.size() ||
-                        !equal(__spaces.end() - __num_spaces, __spaces.end(),
+                        !std::equal(__spaces.end() - __num_spaces, __spaces.end(),
                                __sym.begin())) {
                         // No match. Put __sym_space_end back at the
                         // beginning of __sym, which will prevent a
                         // match in the next loop.
                         __sym_space_end = __sym.begin();
                     }
                 }
                 typename string_type::const_iterator __sym_curr_char = __sym_space_end;
for (unsigned __p = 0; __p < 4 && __b != __e; ++__p)
             {
             unsigned __ng = 0;
             for (; __b != __e; ++__b)
             {
                 char_type __c = *__b;
                 if (__ct.is(ctype_base::digit, __c))
                 {
                     if (__wn == __we)
-                        __double_or_nothing(__wb, __wn, __we);
+                        std::__double_or_nothing(__wb, __wn, __we);
                     *__wn++ = __c;
                     ++__ng;
                 }
                 else if (__grp.size() > 0 && __ng > 0 && __c == __ts)
                 {
                     if (__gn == __ge)
-                        __double_or_nothing(__gb, __gn, __ge);
+                        std::__double_or_nothing(__gb, __gn, __ge);
                     *__gn++ = __ng;
                     __ng = 0;
                 }
                 else
                     break;
             }
             if (__gb.get() != __gn && __ng > 0)
             {
                 if (__gn == __ge)
-                    __double_or_nothing(__gb, __gn, __ge);
+                    std::__double_or_nothing(__gb, __gn, __ge);
                 *__gn++ = __ng;
             }
             if (__fd > 0)
             {
                 if (__b == __e || *__b != __dp)
                 {
                     __err |= ios_base::failbit;
                     return false;
                 }
                 for (++__b; __fd > 0; --__fd, ++__b)
                 {
                     if (__b == __e || !__ct.is(ctype_base::digit, *__b))
                     {
                         __err |= ios_base::failbit;
                         return false;
                     }
                     if (__wn == __we)
-                        __double_or_nothing(__wb, __wn, __we);
+                        std::__double_or_nothing(__wb, __wn, __we);
                     *__wn++ = *__b;
                 }
             }
             if (__wn == __wb.get())
             {
                 __err |= ios_base::failbit;
                 return false;
             }
money_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
                                           long double& __v) const
 {
     const int __bz = 100;
     char_type __wbuf[__bz];
     unique_ptr<char_type, void(*)(void*)> __wb(__wbuf, __do_nothing);
     char_type* __wn;
     char_type* __we = __wbuf + __bz;
     locale __loc = __iob.getloc();
-    const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc);
+    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
     bool __neg = false;
     if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct,
                  __wb, __wn, __we))
     {
         const char __src[] = "0123456789";
         char_type __atoms[sizeof(__src)-1];
         __ct.widen(__src, __src + (sizeof(__src)-1), __atoms);
         char __nbuf[__bz];
         char* __nc = __nbuf;
         unique_ptr<char, void(*)(void*)> __h(nullptr, free);
         if (__wn - __wb.get() > __bz-2)
         {
             __h.reset((char*)malloc(static_cast<size_t>(__wn - __wb.get() + 2)));
             if (__h.get() == nullptr)
                 __throw_bad_alloc();
             __nc = __h.get();
         }
         if (__neg)
             *__nc++ = '-';
         for (const char_type* __w = __wb.get(); __w < __wn; ++__w, ++__nc)
-            *__nc = __src[find(__atoms, _VSTD::end(__atoms), *__w) - __atoms];
+            *__nc = __src[std::find(__atoms, _VSTD::end(__atoms), *__w) - __atoms];
         *__nc = char();
         if (sscanf(__nbuf, "%Lf", &__v) != 1)
             __throw_runtime_error("money_get error");
     }
     if (__b == __e)
         __err |= ios_base::eofbit;
     return __b;
 }
 
 template <class _CharT, class _InputIterator>
 _InputIterator
 money_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
                                           bool __intl, ios_base& __iob,
                                           ios_base::iostate& __err,
                                           string_type& __v) const
 {
     const int __bz = 100;
     char_type __wbuf[__bz];
     unique_ptr<char_type, void(*)(void*)> __wb(__wbuf, __do_nothing);
     char_type* __wn;
     char_type* __we = __wbuf + __bz;
     locale __loc = __iob.getloc();
-    const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc);
+    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
     bool __neg = false;
     if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct,
                  __wb, __wn, __we))
     {
         __v.clear();
         if (__neg)
             __v.push_back(__ct.widen('-'));
         char_type __z = __ct.widen('0');
__money_put<_CharT>::__gather_info(bool __intl, bool __neg, const locale& __loc,
                                    money_base::pattern& __pat, char_type& __dp,
                                    char_type& __ts, string& __grp,
                                    string_type& __sym, string_type& __sn,
                                    int& __fd)
 {
     if (__intl)
     {
         const moneypunct<char_type, true>& __mp =
-            use_facet<moneypunct<char_type, true> >(__loc);
+            std::use_facet<moneypunct<char_type, true> >(__loc);
         if (__neg)
         {
             __pat = __mp.neg_format();
             __sn = __mp.negative_sign();
         }
         else
         {
             __pat = __mp.pos_format();
             __sn = __mp.positive_sign();
         }
         __dp = __mp.decimal_point();
         __ts = __mp.thousands_sep();
         __grp = __mp.grouping();
         __sym = __mp.curr_symbol();
         __fd = __mp.frac_digits();
     }
     else
     {
         const moneypunct<char_type, false>& __mp =
-            use_facet<moneypunct<char_type, false> >(__loc);
+            std::use_facet<moneypunct<char_type, false> >(__loc);
         if (__neg)
         {
             __pat = __mp.neg_format();
             __sn = __mp.negative_sign();
         }
         else
         {
             __pat = __mp.pos_format();
for (char __p : __pat.field)
                                         numeric_limits<unsigned>::max() :
                                         static_cast<unsigned>(__grp[__ig]);
                     }
                     *__me++ = *--__d;
                     ++__ng;
                 }
             }
             // reverse it
-            reverse(__t, __me);
+            std::reverse(__t, __me);
             }
             break;
         }
     }
     // print rest of sign, if any
     if (__sn.size() > 1)
         __me = _VSTD::copy(__sn.begin()+1, __sn.end(), __me);
     // set alignment
if (static_cast<size_t>(__n) > __bs-1)
         __hn.reset(__bb);
         __hd.reset((char_type*)malloc(static_cast<size_t>(__n) * sizeof(char_type)));
         if (__hd == nullptr)
             __throw_bad_alloc();
         __db = __hd.get();
     }
     // gather info
     locale __loc = __iob.getloc();
-    const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc);
+    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
     __ct.widen(__bb, __bb + __n, __db);
     bool __neg = __n > 0 && __bb[0] == '-';
     money_base::pattern __pat;
     char_type __dp;
     char_type __ts;
     string __grp;
     string_type __sym;
     string_type __sn;
if (__exn > __bs)
             __throw_bad_alloc();
     }
     // format
     char_type* __mi;
     char_type* __me;
     this->__format(__mb, __mi, __me, __iob.flags(),
                    __db, __db + __n, __ct,
                    __neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
-    return __pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
+    return std::__pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
 }
 
 template <class _CharT, class _OutputIterator>
 _OutputIterator
 money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
                                            ios_base& __iob, char_type __fl,
                                            const string_type& __digits) const
 {
     // gather info
     locale __loc = __iob.getloc();
-    const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc);
+    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
     bool __neg = __digits.size() > 0 && __digits[0] == __ct.widen('-');
     money_base::pattern __pat;
     char_type __dp;
     char_type __ts;
     string __grp;
     string_type __sym;
     string_type __sn;
     int __fd;
if (__exn > 100)
             __throw_bad_alloc();
     }
     // format
     char_type* __mi;
     char_type* __me;
     this->__format(__mb, __mi, __me, __iob.flags(),
                    __digits.data(), __digits.data() + __digits.size(), __ct,
                    __neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
-    return __pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
+    return std::__pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<char>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<wchar_t>;
 #endif
 
 // messages

 
 template <class _CharT>
 typename messages<_CharT>::string_type
 messages<_CharT>::do_get(catalog __c, int __set, int __msgid,
                          const string_type& __dflt) const
 {
 #ifdef _LIBCPP_HAS_CATOPEN
     string __ndflt;
-    __narrow_to_utf8<sizeof(char_type)*__CHAR_BIT__>()(back_inserter(__ndflt),
+    __narrow_to_utf8<sizeof(char_type)*__CHAR_BIT__>()(std::back_inserter(__ndflt),
                                                        __dflt.c_str(),
                                                        __dflt.c_str() + __dflt.size());
     if (__c != -1)
         __c <<= 1;
     nl_catd __cat = (nl_catd)__c;
     char* __n = catgets(__cat, __set, __msgid, __ndflt.c_str());
     string_type __w;
-    __widen_from_utf8<sizeof(char_type)*__CHAR_BIT__>()(back_inserter(__w),
+    __widen_from_utf8<sizeof(char_type)*__CHAR_BIT__>()(std::back_inserter(__w),
                                                         __n, __n + _VSTD::strlen(__n));
     return __w;
 #else // !_LIBCPP_HAS_CATOPEN
     (void)__c;
     (void)__set;
     (void)__msgid;
     return __dflt;
 #endif // _LIBCPP_HAS_CATOPEN

 {
 _LIBCPP_SUPPRESS_DEPRECATED_POP
     if (__cv_ == 0 || __bufptr_ == 0)
         return traits_type::eof();
     bool __initial = __read_mode();
     char_type __1buf;
     if (this->gptr() == 0)
         this->setg(&__1buf, &__1buf+1, &__1buf+1);
-    const size_t __unget_sz = __initial ? 0 : min<size_t>((this->egptr() - this->eback()) / 2, 4);
+    const size_t __unget_sz = __initial ? 0 : std::min<size_t>((this->egptr() - this->eback()) / 2, 4);
     int_type __c = traits_type::eof();
     if (this->gptr() == this->egptr())
     {
         _VSTD::memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type));
         if (__always_noconv_)
         {
             streamsize __nmemb = static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz);
             __nmemb = __bufptr_->sgetn((char*)this->eback() + __unget_sz, __nmemb);
else if (__cm_ & ios_base::in)
             int __width = __cv_->encoding();
             __c = __extbufend_ - __extbufnext_;
             if (__width > 0)
                 __c += __width * (this->egptr() - this->gptr());
             else
             {
                 if (this->gptr() != this->egptr())
                 {
-                    reverse(this->gptr(), this->egptr());
+                    std::reverse(this->gptr(), this->egptr());
                     codecvt_base::result __r;
                     const char_type* __e = this->gptr();
                     char* __extbe;
                     do
                     {
                         __r = __cv_->out(__st_, __e, this->egptr(), __e,
                                          __extbuf_, __extbuf_ + __ebs_, __extbe);
                         switch (__r)

libcxx/include/math.h

 
 #undef signbit
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
 signbit(_A1 __lcpp_x) _NOEXCEPT
 {
-    return __libcpp_signbit((typename std::__promote<_A1>::type)__lcpp_x);
+    return ::__libcpp_signbit((typename std::__promote<_A1>::type)__lcpp_x);
 }
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<
     std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type
 signbit(_A1 __lcpp_x) _NOEXCEPT
 { return __lcpp_x < 0; }

 
 #undef fpclassify
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_floating_point<_A1>::value, int>::type
 fpclassify(_A1 __lcpp_x) _NOEXCEPT
 {
-    return __libcpp_fpclassify((typename std::__promote<_A1>::type)__lcpp_x);
+    return ::__libcpp_fpclassify((typename std::__promote<_A1>::type)__lcpp_x);
 }
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, int>::type
 fpclassify(_A1 __lcpp_x) _NOEXCEPT
 { return __lcpp_x == 0 ? FP_ZERO : FP_NORMAL; }
 

 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<
     std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity,
     bool>::type
 isfinite(_A1 __lcpp_x) _NOEXCEPT
 {
-    return __libcpp_isfinite((typename std::__promote<_A1>::type)__lcpp_x);
+    return ::__libcpp_isfinite((typename std::__promote<_A1>::type)__lcpp_x);
 }
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<
     std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity,
     bool>::type
 isfinite(_A1) _NOEXCEPT

 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<
     std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity,
     bool>::type
 isinf(_A1 __lcpp_x) _NOEXCEPT
 {
-    return __libcpp_isinf((typename std::__promote<_A1>::type)__lcpp_x);
+    return ::__libcpp_isinf((typename std::__promote<_A1>::type)__lcpp_x);
 }
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<
     std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity,
     bool>::type
 isinf(_A1) _NOEXCEPT

 
 #undef isnan
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
 isnan(_A1 __lcpp_x) _NOEXCEPT
 {
-    return __libcpp_isnan((typename std::__promote<_A1>::type)__lcpp_x);
+    return ::__libcpp_isnan((typename std::__promote<_A1>::type)__lcpp_x);
 }
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, bool>::type
 isnan(_A1) _NOEXCEPT
 { return false; }
 

 
 #undef isnormal
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
 isnormal(_A1 __lcpp_x) _NOEXCEPT
 {
-    return __libcpp_isnormal((typename std::__promote<_A1>::type)__lcpp_x);
+    return ::__libcpp_isnormal((typename std::__promote<_A1>::type)__lcpp_x);
 }
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, bool>::type
 isnormal(_A1 __lcpp_x) _NOEXCEPT
 { return __lcpp_x != 0; }
 

 <
     std::is_arithmetic<_A1>::value &&
     std::is_arithmetic<_A2>::value,
     bool
 >::type
 isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
 {
     typedef typename std::__promote<_A1, _A2>::type type;
-    return __libcpp_isgreater((type)__lcpp_x, (type)__lcpp_y);
+    return ::__libcpp_isgreater((type)__lcpp_x, (type)__lcpp_y);
 }
 
 #endif // isgreater
 
 // isgreaterequal
 
 #ifdef isgreaterequal
 

 <
     std::is_arithmetic<_A1>::value &&
     std::is_arithmetic<_A2>::value,
     bool
 >::type
 isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
 {
     typedef typename std::__promote<_A1, _A2>::type type;
-    return __libcpp_isgreaterequal((type)__lcpp_x, (type)__lcpp_y);
+    return ::__libcpp_isgreaterequal((type)__lcpp_x, (type)__lcpp_y);
 }
 
 #endif // isgreaterequal
 
 // isless
 
 #ifdef isless
 

 <
     std::is_arithmetic<_A1>::value &&
     std::is_arithmetic<_A2>::value,
     bool
 >::type
 isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
 {
     typedef typename std::__promote<_A1, _A2>::type type;
-    return __libcpp_isless((type)__lcpp_x, (type)__lcpp_y);
+    return ::__libcpp_isless((type)__lcpp_x, (type)__lcpp_y);
 }
 
 #endif // isless
 
 // islessequal
 
 #ifdef islessequal
 

 <
     std::is_arithmetic<_A1>::value &&
     std::is_arithmetic<_A2>::value,
     bool
 >::type
 islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
 {
     typedef typename std::__promote<_A1, _A2>::type type;
-    return __libcpp_islessequal((type)__lcpp_x, (type)__lcpp_y);
+    return ::__libcpp_islessequal((type)__lcpp_x, (type)__lcpp_y);
 }
 
 #endif // islessequal
 
 // islessgreater
 
 #ifdef islessgreater
 

 <
     std::is_arithmetic<_A1>::value &&
     std::is_arithmetic<_A2>::value,
     bool
 >::type
 islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
 {
     typedef typename std::__promote<_A1, _A2>::type type;
-    return __libcpp_islessgreater((type)__lcpp_x, (type)__lcpp_y);
+    return ::__libcpp_islessgreater((type)__lcpp_x, (type)__lcpp_y);
 }
 
 #endif // islessgreater
 
 // isunordered
 
 #ifdef isunordered
 

 <
     std::is_arithmetic<_A1>::value &&
     std::is_arithmetic<_A2>::value,
     bool
 >::type
 isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
 {
     typedef typename std::__promote<_A1, _A2>::type type;
-    return __libcpp_isunordered((type)__lcpp_x, (type)__lcpp_y);
+    return ::__libcpp_isunordered((type)__lcpp_x, (type)__lcpp_y);
 }
 
 #endif // isunordered
 
 // abs
 //
 // handled in stdlib.h
 

libcxx/include/mutex

 template <class _L0, class _L1, class _L2, class... _L3>
 _LIBCPP_HIDE_FROM_ABI int
 try_lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3)
 {
     int __r = 0;
     unique_lock<_L0> __u0(__l0, try_to_lock);
     if (__u0.owns_lock())
     {
-        __r = try_lock(__l1, __l2, __l3...);
+        __r = std::try_lock(__l1, __l2, __l3...);
         if (__r == -1)
             __u0.release();
         else
             ++__r;
     }
     return __r;
 }
 

 {
     while (true)
     {
         switch (__i)
         {
         case 0:
             {
                 unique_lock<_L0> __u0(__l0);
-                __i = try_lock(__l1, __l2, __l3...);
+                __i = std::try_lock(__l1, __l2, __l3...);
                 if (__i == -1)
                 {
                     __u0.release();
                     return;
                 }
             }
             ++__i;
             __libcpp_thread_yield();
             break;
         case 1:
             {
                 unique_lock<_L1> __u1(__l1);
-                __i = try_lock(__l2, __l3..., __l0);
+                __i = std::try_lock(__l2, __l3..., __l0);
                 if (__i == -1)
                 {
                     __u1.release();
                     return;
                 }
             }
             if (__i == sizeof...(_L3) + 1)
                 __i = 0;
             else
                 __i += 2;
             __libcpp_thread_yield();
             break;
         default:
-            __lock_first(__i - 2, __l2, __l3..., __l0, __l1);
+            std::__lock_first(__i - 2, __l2, __l3..., __l0, __l1);
             return;
         }
     }
 }
 
 template <class _L0, class _L1, class _L2, class ..._L3>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
 {
-    __lock_first(0, __l0, __l1, __l2, __l3...);
+    std::__lock_first(0, __l0, __l1, __l2, __l3...);
 }
 
 template <class _L0>
 inline _LIBCPP_INLINE_VISIBILITY
 void __unlock(_L0& __l0) {
     __l0.unlock();
 }
 

 void
 call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args)
 {
     if (__libcpp_acquire_load(&__flag.__state_) != ~once_flag::_State_type(0))
     {
         typedef tuple<_Callable&&, _Args&&...> _Gp;
         _Gp __f(_VSTD::forward<_Callable>(__func), _VSTD::forward<_Args>(__args)...);
         __call_once_param<_Gp> __p(__f);
-        __call_once(__flag.__state_, &__p, &__call_once_proxy<_Gp>);
+        std::__call_once(__flag.__state_, &__p, &__call_once_proxy<_Gp>);
     }
 }
 
 #else  // _LIBCPP_CXX03_LANG
 
 template<class _Callable>
 inline _LIBCPP_INLINE_VISIBILITY
 void

libcxx/include/new

#endif
   return __libcpp_operator_new(__size);
 }
 
 template <class ..._Args>
 _LIBCPP_INLINE_VISIBILITY
 void __do_deallocate_handle_size(void *__ptr, size_t __size, _Args ...__args) {
 #ifdef _LIBCPP_HAS_NO_SIZED_DEALLOCATION
   (void)__size;
-  return __libcpp_operator_delete(__ptr, __args...);
+  return std::__libcpp_operator_delete(__ptr, __args...);
 #else
-  return __libcpp_operator_delete(__ptr, __size, __args...);
+  return std::__libcpp_operator_delete(__ptr, __size, __args...);
 #endif
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 void __libcpp_deallocate(void* __ptr, size_t __size, size_t __align) {
 #if defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
     (void)__align;
     return __do_deallocate_handle_size(__ptr, __size);

libcxx/include/ostream

 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         sentry __s(*this);
         if (__s)
         {
             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = use_facet<_Fp>(this->getloc());
+            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
             if (__f.put(*this, *this, this->fill(), __n).failed())
                 this->setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         this->__set_badbit_and_consider_rethrow();
#ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         sentry __s(*this);
         if (__s)
         {
             ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = use_facet<_Fp>(this->getloc());
+            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
             if (__f.put(*this, *this, this->fill(),
                         __flags == ios_base::oct || __flags == ios_base::hex ?
                         static_cast<long>(static_cast<unsigned short>(__n))  :
                         static_cast<long>(__n)).failed())
                 this->setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }

 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         sentry __s(*this);
         if (__s)
         {
             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = use_facet<_Fp>(this->getloc());
+            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
             if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
                 this->setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         this->__set_badbit_and_consider_rethrow();
#ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         sentry __s(*this);
         if (__s)
         {
             ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = use_facet<_Fp>(this->getloc());
+            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
             if (__f.put(*this, *this, this->fill(),
                         __flags == ios_base::oct || __flags == ios_base::hex ?
                         static_cast<long>(static_cast<unsigned int>(__n))  :
                         static_cast<long>(__n)).failed())
                 this->setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }

 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         sentry __s(*this);
         if (__s)
         {
             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = use_facet<_Fp>(this->getloc());
+            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
             if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
                 this->setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         this->__set_badbit_and_consider_rethrow();

 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         sentry __s(*this);
         if (__s)
         {
             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = use_facet<_Fp>(this->getloc());
+            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
             if (__f.put(*this, *this, this->fill(), __n).failed())
                 this->setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         this->__set_badbit_and_consider_rethrow();

 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         sentry __s(*this);
         if (__s)
         {
             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = use_facet<_Fp>(this->getloc());
+            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
             if (__f.put(*this, *this, this->fill(), __n).failed())
                 this->setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         this->__set_badbit_and_consider_rethrow();

 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         sentry __s(*this);
         if (__s)
         {
             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = use_facet<_Fp>(this->getloc());
+            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
             if (__f.put(*this, *this, this->fill(), __n).failed())
                 this->setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         this->__set_badbit_and_consider_rethrow();

 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         sentry __s(*this);
         if (__s)
         {
             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = use_facet<_Fp>(this->getloc());
+            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
             if (__f.put(*this, *this, this->fill(), __n).failed())
                 this->setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         this->__set_badbit_and_consider_rethrow();

 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         sentry __s(*this);
         if (__s)
         {
             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = use_facet<_Fp>(this->getloc());
+            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
             if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed())
                 this->setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         this->__set_badbit_and_consider_rethrow();

 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         sentry __s(*this);
         if (__s)
         {
             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = use_facet<_Fp>(this->getloc());
+            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
             if (__f.put(*this, *this, this->fill(), __n).failed())
                 this->setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         this->__set_badbit_and_consider_rethrow();

 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         sentry __s(*this);
         if (__s)
         {
             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = use_facet<_Fp>(this->getloc());
+            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
             if (__f.put(*this, *this, this->fill(), __n).failed())
                 this->setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         this->__set_badbit_and_consider_rethrow();

 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         sentry __s(*this);
         if (__s)
         {
             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = use_facet<_Fp>(this->getloc());
+            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
             if (__f.put(*this, *this, this->fill(), __n).failed())
                 this->setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         this->__set_badbit_and_consider_rethrow();

 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
         if (__s)
         {
             typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
-            if (__pad_and_output(_Ip(__os),
+            if (std::__pad_and_output(_Ip(__os),
                                       __str,
                                       (__os.flags() & ios_base::adjustfield) == ios_base::left ?
                                           __str + __len :
                                           __str,
                                       __str + __len,
                                       __os,
                                       __os.fill()).failed())
                 __os.setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __os.__set_badbit_and_consider_rethrow();
     }
#ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
         if (__s)
         {
             _CharT __c = __os.widen(__cn);
             typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
-            if (__pad_and_output(_Ip(__os),
+            if (std::__pad_and_output(_Ip(__os),
                                       &__c,
                                       (__os.flags() & ios_base::adjustfield) == ios_base::left ?
                                           &__c + 1 :
                                           &__c,
                                       &__c + 1,
                                       __os,
                                       __os.fill()).failed())
                 __os.setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __os.__set_badbit_and_consider_rethrow();
     }
#endif // _LIBCPP_NO_EXCEPTIONS
             {
                 __wb = (_CharT*)malloc(__len*sizeof(_CharT));
                 if (__wb == 0)
                     __throw_bad_alloc();
                 __h.reset(__wb);
             }
             for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p)
                 *__p = __os.widen(*__strn);
-            if (__pad_and_output(_Ip(__os),
+            if (std::__pad_and_output(_Ip(__os),
                                       __wb,
                                       (__os.flags() & ios_base::adjustfield) == ios_base::left ?
                                           __wb + __len :
                                           __wb,
                                       __wb + __len,
                                       __os,
                                       __os.fill()).failed())
                 __os.setstate(ios_base::badbit | ios_base::failbit);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __os.__set_badbit_and_consider_rethrow();
     }
operator<<(basic_ostream<_CharT, _Traits>& __os, unique_ptr<_Yp, _Dp> const& __p)
     return __os << __p.get();
 }
 
 template <class _CharT, class _Traits, size_t _Size>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
 {
     return __os << __x.template to_string<_CharT, _Traits>
-                        (use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
-                         use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
+                        (std::use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
+                         std::use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
 }
 
 #if _LIBCPP_STD_VER > 17
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class _Traits>
 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete;
 

libcxx/include/regex

regex_traits<_CharT>::transform(_ForwardIterator __f, _ForwardIterator __l) const
     string_type __s(__f, __l);
     return __col_->transform(__s.data(), __s.data() + __s.size());
 }
 
 template <class _CharT>
 void
 regex_traits<_CharT>::__init()
 {
-    __ct_ = &use_facet<ctype<char_type> >(__loc_);
-    __col_ = &use_facet<collate<char_type> >(__loc_);
+    __ct_ = &std::use_facet<ctype<char_type> >(__loc_);
+    __col_ = &std::use_facet<collate<char_type> >(__loc_);
 }
 
 template <class _CharT>
 typename regex_traits<_CharT>::locale_type
 regex_traits<_CharT>::imbue(locale_type __l)
 {
     locale __r = __loc_;
     __loc_ = __l;

 typename regex_traits<_CharT>::string_type
 regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f,
                                            _ForwardIterator __l, char) const
 {
     string_type __s(__f, __l);
     string_type __r;
     if (!__s.empty())
     {
-        __r = __get_collation_name(__s.c_str());
+        __r = std::__get_collation_name(__s.c_str());
         if (__r.empty() && __s.size() <= 2)
         {
             __r = __col_->transform(__s.data(), __s.data() + __s.size());
             if (__r.size() == 1 || __r.size() == 12)
                 __r = __s;
             else
                 __r.clear();
         }

 template <class _ForwardIterator>
 typename regex_traits<_CharT>::char_class_type
 regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f,
                                          _ForwardIterator __l,
                                          bool __icase, char) const
 {
     string_type __s(__f, __l);
     __ct_->tolower(&__s[0], &__s[0] + __s.size());
-    return __get_classname(__s.c_str(), __icase);
+    return std::__get_classname(__s.c_str(), __icase);
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class _CharT>
 template <class _ForwardIterator>
 typename regex_traits<_CharT>::char_class_type
 regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f,
                                          _ForwardIterator __l,
__l_anchor_multiline<_CharT>::__exec(__state& __s) const
     if (__s.__at_first_ && __s.__current_ == __s.__first_ &&
         !(__s.__flags_ & regex_constants::match_not_bol))
     {
         __s.__do_ = __state::__accept_but_not_consume;
         __s.__node_ = this->first();
     }
     else if (__multiline_ &&
              !__s.__at_first_ &&
-             __is_eol(*_VSTD::prev(__s.__current_)))
+             std::__is_eol(*_VSTD::prev(__s.__current_)))
     {
         __s.__do_ = __state::__accept_but_not_consume;
         __s.__node_ = this->first();
     }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;

 __r_anchor_multiline<_CharT>::__exec(__state& __s) const
 {
     if (__s.__current_ == __s.__last_ &&
         !(__s.__flags_ & regex_constants::match_not_eol))
     {
         __s.__do_ = __state::__accept_but_not_consume;
         __s.__node_ = this->first();
     }
-    else if (__multiline_ && __is_eol(*__s.__current_))
+    else if (__multiline_ && std::__is_eol(*__s.__current_))
     {
         __s.__do_ = __state::__accept_but_not_consume;
         __s.__node_ = this->first();
     }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
void __add_range(string_type __b, string_type __e)
                 }
                 else
                 {
                     for (size_t __i = 0; __i < __b.size(); ++__i)
                         __b[__i] = __traits_.translate(__b[__i]);
                     for (size_t __i = 0; __i < __e.size(); ++__i)
                         __e[__i] = __traits_.translate(__e[__i]);
                 }
-                __ranges_.push_back(make_pair(
+                __ranges_.push_back(std::make_pair(
                                   __traits_.transform(__b.begin(), __b.end()),
                                   __traits_.transform(__e.begin(), __e.end())));
             }
             else
             {
                 if (__b.size() != 1 || __e.size() != 1)
                     __throw_regex_error<regex_constants::error_range>();
                 if (__icase_)
                 {
                     __b[0] = __traits_.translate_nocase(__b[0]);
                     __e[0] = __traits_.translate_nocase(__e[0]);
                 }
-                __ranges_.push_back(make_pair(_VSTD::move(__b), _VSTD::move(__e)));
+                __ranges_.push_back(std::make_pair(_VSTD::move(__b), _VSTD::move(__e)));
             }
         }
     _LIBCPP_INLINE_VISIBILITY
     void __add_digraph(_CharT __c1, _CharT __c2)
         {
             if (__icase_)
-                __digraphs_.push_back(make_pair(__traits_.translate_nocase(__c1),
+                __digraphs_.push_back(std::make_pair(__traits_.translate_nocase(__c1),
                                                      __traits_.translate_nocase(__c2)));
             else if (__collate_)
-                __digraphs_.push_back(make_pair(__traits_.translate(__c1),
+                __digraphs_.push_back(std::make_pair(__traits_.translate(__c1),
                                                      __traits_.translate(__c2)));
             else
-                __digraphs_.push_back(make_pair(__c1, __c2));
+                __digraphs_.push_back(std::make_pair(__c1, __c2));
         }
     _LIBCPP_INLINE_VISIBILITY
     void __add_equivalence(const string_type& __s)
         {__equivalences_.push_back(__s);}
     _LIBCPP_INLINE_VISIBILITY
     void __add_class(typename regex_traits<_CharT>::char_class_type __mask)
         {__mask_ |= __mask;}
     _LIBCPP_INLINE_VISIBILITY
template <class _OutputIter, class _ST, class _SA>
             {return format(__output_iter, __fmt.data(), __fmt.data() + __fmt.size(), __flags);}
     template <class _ST, class _SA>
         _LIBCPP_INLINE_VISIBILITY
         basic_string<char_type, _ST, _SA>
         format(const basic_string<char_type, _ST, _SA>& __fmt,
                regex_constants::match_flag_type __flags = regex_constants::format_default) const
         {
             basic_string<char_type, _ST, _SA> __r;
-            format(back_inserter(__r), __fmt.data(), __fmt.data() + __fmt.size(),
+            format(std::back_inserter(__r), __fmt.data(), __fmt.data() + __fmt.size(),
                    __flags);
             return __r;
         }
     _LIBCPP_INLINE_VISIBILITY
     string_type
         format(const char_type* __fmt,
                regex_constants::match_flag_type __flags = regex_constants::format_default) const
         {
             string_type __r;
-            format(back_inserter(__r), __fmt,
+            format(std::back_inserter(__r), __fmt,
                    __fmt + char_traits<char_type>::length(__fmt), __flags);
             return __r;
         }
 
     // allocator:
     _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const {return __matches_.get_allocator();}
 

 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _ST, _SA>
 regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
               const basic_regex<_CharT, _Traits>& __e,
               const basic_string<_CharT, _FST, _FSA>& __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     basic_string<_CharT, _ST, _SA> __r;
-    _VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
+    _VSTD::regex_replace(std::back_inserter(__r), __s.begin(), __s.end(), __e,
                         __fmt.c_str(), __flags);
     return __r;
 }
 
 template <class _Traits, class _CharT, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _ST, _SA>
 regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
               const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     basic_string<_CharT, _ST, _SA> __r;
-    _VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
+    _VSTD::regex_replace(std::back_inserter(__r), __s.begin(), __s.end(), __e,
                         __fmt, __flags);
     return __r;
 }
 
 template <class _Traits, class _CharT, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT>
 regex_replace(const _CharT* __s,
               const basic_regex<_CharT, _Traits>& __e,
               const basic_string<_CharT, _ST, _SA>& __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     basic_string<_CharT> __r;
-    _VSTD::regex_replace(back_inserter(__r), __s,
+    _VSTD::regex_replace(std::back_inserter(__r), __s,
                         __s + char_traits<_CharT>::length(__s), __e,
                         __fmt.c_str(), __flags);
     return __r;
 }
 
 template <class _Traits, class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT>
 regex_replace(const _CharT* __s,
               const basic_regex<_CharT, _Traits>& __e,
               const _CharT* __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     basic_string<_CharT> __r;
-    _VSTD::regex_replace(back_inserter(__r), __s,
+    _VSTD::regex_replace(std::back_inserter(__r), __s,
                         __s + char_traits<_CharT>::length(__s), __e,
                         __fmt, __flags);
     return __r;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iterator>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_REGEX

libcxx/include/scoped_allocator

 template <class _Alloc>
 false_type
 __has_outer_allocator_test(const volatile _Alloc& __a);
 
 template <class _Alloc>
 struct __has_outer_allocator
     : public common_type
              <
-                 decltype(__has_outer_allocator_test(declval<_Alloc&>()))
+                 decltype(std::__has_outer_allocator_test(declval<_Alloc&>()))
              >::type
 {
 };
 
 template <class _Alloc, bool = __has_outer_allocator<_Alloc>::value>
 struct __outermost
 {
     typedef _Alloc type;

libcxx/include/semaphore

public:
     }
     template <class Rep, class Period>
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     bool try_acquire_for(chrono::duration<Rep, Period> const& __rel_time)
     {
         if (__rel_time == chrono::duration<Rep, Period>::zero())
             return try_acquire();
         auto const __test_fn = [this]() { return try_acquire(); };
-        return __libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy(), __rel_time);
+        return std::__libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy(), __rel_time);
     }
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     bool try_acquire()
     {
         auto __old = __a_.load(memory_order_acquire);
         while (true) {
             if (__old == 0)
                 return false;

libcxx/include/string

 template<class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
                                                 size_type __pos,
                                                 size_type __n) const _NOEXCEPT
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find(): received nullptr");
-    return __str_find<value_type, size_type, traits_type, npos>
+    return std::__str_find<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str,
                                                 size_type __pos) const _NOEXCEPT
 {
-    return __str_find<value_type, size_type, traits_type, npos>
+    return std::__str_find<value_type, size_type, traits_type, npos>
         (data(), size(), __str.data(), __pos, __str.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
     typename basic_string<_CharT, _Traits, _Allocator>::size_type
 >
 basic_string<_CharT, _Traits, _Allocator>::find(const _Tp &__t,
                                                 size_type __pos) const _NOEXCEPT
 {
     __self_view __sv = __t;
-    return __str_find<value_type, size_type, traits_type, npos>
+    return std::__str_find<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
                                                 size_type __pos) const _NOEXCEPT
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::find(): received nullptr");
-    return __str_find<value_type, size_type, traits_type, npos>
+    return std::__str_find<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find(value_type __c,
                                                 size_type __pos) const _NOEXCEPT
 {
-    return __str_find<value_type, size_type, traits_type, npos>
+    return std::__str_find<value_type, size_type, traits_type, npos>
         (data(), size(), __c, __pos);
 }
 
 // rfind
 
 template<class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
                                                  size_type __pos,
                                                  size_type __n) const _NOEXCEPT
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::rfind(): received nullptr");
-    return __str_rfind<value_type, size_type, traits_type, npos>
+    return std::__str_rfind<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str,
                                                  size_type __pos) const _NOEXCEPT
 {
-    return __str_rfind<value_type, size_type, traits_type, npos>
+    return std::__str_rfind<value_type, size_type, traits_type, npos>
         (data(), size(), __str.data(), __pos, __str.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
     typename basic_string<_CharT, _Traits, _Allocator>::size_type
 >
 basic_string<_CharT, _Traits, _Allocator>::rfind(const _Tp& __t,
                                                 size_type __pos) const _NOEXCEPT
 {
     __self_view __sv = __t;
-    return __str_rfind<value_type, size_type, traits_type, npos>
+    return std::__str_rfind<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
                                                  size_type __pos) const _NOEXCEPT
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::rfind(): received nullptr");
-    return __str_rfind<value_type, size_type, traits_type, npos>
+    return std::__str_rfind<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::rfind(value_type __c,
                                                  size_type __pos) const _NOEXCEPT
 {
-    return __str_rfind<value_type, size_type, traits_type, npos>
+    return std::__str_rfind<value_type, size_type, traits_type, npos>
         (data(), size(), __c, __pos);
 }
 
 // find_first_of
 
 template<class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
                                                          size_type __pos,
                                                          size_type __n) const _NOEXCEPT
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_of(): received nullptr");
-    return __str_find_first_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_first_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __str,
                                                          size_type __pos) const _NOEXCEPT
 {
-    return __str_find_first_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_first_of<value_type, size_type, traits_type, npos>
         (data(), size(), __str.data(), __pos, __str.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
     typename basic_string<_CharT, _Traits, _Allocator>::size_type
 >
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const _Tp& __t,
                                                 size_type __pos) const _NOEXCEPT
 {
     __self_view __sv = __t;
-    return __str_find_first_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_first_of<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
                                                          size_type __pos) const _NOEXCEPT
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::find_first_of(): received nullptr");
-    return __str_find_first_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_first_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c,
                                                          size_type __pos) const _NOEXCEPT
 {
     return find(__c, __pos);
 }
 
 // find_last_of
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
                                                         size_type __pos,
                                                         size_type __n) const _NOEXCEPT
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_of(): received nullptr");
-    return __str_find_last_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_last_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __str,
                                                         size_type __pos) const _NOEXCEPT
 {
-    return __str_find_last_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_last_of<value_type, size_type, traits_type, npos>
         (data(), size(), __str.data(), __pos, __str.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
     typename basic_string<_CharT, _Traits, _Allocator>::size_type
 >
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const _Tp& __t,
                                                 size_type __pos) const _NOEXCEPT
 {
     __self_view __sv = __t;
-    return __str_find_last_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_last_of<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
                                                         size_type __pos) const _NOEXCEPT
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::find_last_of(): received nullptr");
-    return __str_find_last_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_last_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c,
                                                         size_type __pos) const _NOEXCEPT
 {
     return rfind(__c, __pos);
 }
 
 // find_first_not_of
 
 template<class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
                                                              size_type __pos,
                                                              size_type __n) const _NOEXCEPT
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_not_of(): received nullptr");
-    return __str_find_first_not_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string& __str,
                                                              size_type __pos) const _NOEXCEPT
 {
-    return __str_find_first_not_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __str.data(), __pos, __str.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
     typename basic_string<_CharT, _Traits, _Allocator>::size_type
 >
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const _Tp& __t,
                                                 size_type __pos) const _NOEXCEPT
 {
     __self_view __sv = __t;
-    return __str_find_first_not_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
                                                              size_type __pos) const _NOEXCEPT
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::find_first_not_of(): received nullptr");
-    return __str_find_first_not_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c,
                                                              size_type __pos) const _NOEXCEPT
 {
-    return __str_find_first_not_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __c, __pos);
 }
 
 // find_last_not_of
 
 template<class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
                                                             size_type __pos,
                                                             size_type __n) const _NOEXCEPT
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_not_of(): received nullptr");
-    return __str_find_last_not_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string& __str,
                                                             size_type __pos) const _NOEXCEPT
 {
-    return __str_find_last_not_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __str.data(), __pos, __str.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
     typename basic_string<_CharT, _Traits, _Allocator>::size_type
 >
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const _Tp& __t,
                                                 size_type __pos) const _NOEXCEPT
 {
     __self_view __sv = __t;
-    return __str_find_last_not_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
                                                             size_type __pos) const _NOEXCEPT
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::find_last_not_of(): received nullptr");
-    return __str_find_last_not_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c,
                                                             size_type __pos) const _NOEXCEPT
 {
-    return __str_find_last_not_of<value_type, size_type, traits_type, npos>
+    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __c, __pos);
 }
 
 // compare
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
 _LIBCPP_CONSTEXPR_SINCE_CXX20

 const typename basic_string<_CharT, _Traits, _Allocator>::size_type
                basic_string<_CharT, _Traits, _Allocator>::npos;
 
 template <class _CharT, class _Allocator>
 struct __string_hash : public __unary_function<basic_string<_CharT, char_traits<_CharT>, _Allocator>, size_t>
 {
     size_t
     operator()(const basic_string<_CharT, char_traits<_CharT>, _Allocator>& __val) const _NOEXCEPT
-    { return __do_string_hash(__val.data(), __val.data() + __val.size()); }
+    { return std::__do_string_hash(__val.data(), __val.data() + __val.size()); }
 };
 
 template <class _Allocator>
 struct hash<basic_string<char, char_traits<char>, _Allocator> > : __string_hash<char, _Allocator> {};
 
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
 template <class _Allocator>
 struct hash<basic_string<char8_t, char_traits<char8_t>, _Allocator> > : __string_hash<char8_t, _Allocator> {};

libcxx/include/string_view

int compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const
         return substr(__pos1, __n1).compare(basic_string_view(__s, __n2));
     }
 
     // find
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
-        return __str_find<value_type, size_type, traits_type, npos>
+        return std::__str_find<value_type, size_type, traits_type, npos>
             (data(), size(), __s.data(), __pos, __s.size());
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find(_CharT __c, size_type __pos = 0) const _NOEXCEPT
     {
-        return __str_find<value_type, size_type, traits_type, npos>
+        return std::__str_find<value_type, size_type, traits_type, npos>
             (data(), size(), __c, __pos);
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find(): received nullptr");
-        return __str_find<value_type, size_type, traits_type, npos>
+        return std::__str_find<value_type, size_type, traits_type, npos>
             (data(), size(), __s, __pos, __n);
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__s != nullptr, "string_view::find(): received nullptr");
-        return __str_find<value_type, size_type, traits_type, npos>
+        return std::__str_find<value_type, size_type, traits_type, npos>
             (data(), size(), __s, __pos, traits_type::length(__s));
     }
 
     // rfind
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type rfind(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
-        return __str_rfind<value_type, size_type, traits_type, npos>
+        return std::__str_rfind<value_type, size_type, traits_type, npos>
             (data(), size(), __s.data(), __pos, __s.size());
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type rfind(_CharT __c, size_type __pos = npos) const _NOEXCEPT
     {
-        return __str_rfind<value_type, size_type, traits_type, npos>
+        return std::__str_rfind<value_type, size_type, traits_type, npos>
             (data(), size(), __c, __pos);
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::rfind(): received nullptr");
-        return __str_rfind<value_type, size_type, traits_type, npos>
+        return std::__str_rfind<value_type, size_type, traits_type, npos>
             (data(), size(), __s, __pos, __n);
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type rfind(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__s != nullptr, "string_view::rfind(): received nullptr");
-        return __str_rfind<value_type, size_type, traits_type, npos>
+        return std::__str_rfind<value_type, size_type, traits_type, npos>
             (data(), size(), __s, __pos, traits_type::length(__s));
     }
 
     // find_first_of
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_first_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): received nullptr");
-        return __str_find_first_of<value_type, size_type, traits_type, npos>
+        return std::__str_find_first_of<value_type, size_type, traits_type, npos>
             (data(), size(), __s.data(), __pos, __s.size());
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_first_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT
     { return find(__c, __pos); }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_of(): received nullptr");
-        return __str_find_first_of<value_type, size_type, traits_type, npos>
+        return std::__str_find_first_of<value_type, size_type, traits_type, npos>
             (data(), size(), __s, __pos, __n);
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_first_of(const _CharT* __s, size_type __pos=0) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_of(): received nullptr");
-        return __str_find_first_of<value_type, size_type, traits_type, npos>
+        return std::__str_find_first_of<value_type, size_type, traits_type, npos>
             (data(), size(), __s, __pos, traits_type::length(__s));
     }
 
     // find_last_of
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_last_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): received nullptr");
-        return __str_find_last_of<value_type, size_type, traits_type, npos>
+        return std::__str_find_last_of<value_type, size_type, traits_type, npos>
             (data(), size(), __s.data(), __pos, __s.size());
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_last_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT
     { return rfind(__c, __pos); }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_of(): received nullptr");
-        return __str_find_last_of<value_type, size_type, traits_type, npos>
+        return std::__str_find_last_of<value_type, size_type, traits_type, npos>
             (data(), size(), __s, __pos, __n);
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_last_of(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_of(): received nullptr");
-        return __str_find_last_of<value_type, size_type, traits_type, npos>
+        return std::__str_find_last_of<value_type, size_type, traits_type, npos>
             (data(), size(), __s, __pos, traits_type::length(__s));
     }
 
     // find_first_not_of
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_first_not_of(basic_string_view __s, size_type __pos=0) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): received nullptr");
-        return __str_find_first_not_of<value_type, size_type, traits_type, npos>
+        return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
             (data(), size(), __s.data(), __pos, __s.size());
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_first_not_of(_CharT __c, size_type __pos=0) const _NOEXCEPT
     {
-        return __str_find_first_not_of<value_type, size_type, traits_type, npos>
+        return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
             (data(), size(), __c, __pos);
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): received nullptr");
-        return __str_find_first_not_of<value_type, size_type, traits_type, npos>
+        return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
             (data(), size(), __s, __pos, __n);
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_first_not_of(const _CharT* __s, size_type __pos=0) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_not_of(): received nullptr");
-        return __str_find_first_not_of<value_type, size_type, traits_type, npos>
+        return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
             (data(), size(), __s, __pos, traits_type::length(__s));
     }
 
     // find_last_not_of
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_last_not_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): received nullptr");
-        return __str_find_last_not_of<value_type, size_type, traits_type, npos>
+        return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
             (data(), size(), __s.data(), __pos, __s.size());
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_last_not_of(_CharT __c, size_type __pos=npos) const _NOEXCEPT
     {
-        return __str_find_last_not_of<value_type, size_type, traits_type, npos>
+        return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
             (data(), size(), __c, __pos);
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): received nullptr");
-        return __str_find_last_not_of<value_type, size_type, traits_type, npos>
+        return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
             (data(), size(), __s, __pos, __n);
     }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     size_type find_last_not_of(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
     {
         _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_not_of(): received nullptr");
-        return __str_find_last_not_of<value_type, size_type, traits_type, npos>
+        return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
             (data(), size(), __s, __pos, traits_type::length(__s));
     }
 
 #if _LIBCPP_STD_VER > 17
     constexpr _LIBCPP_INLINE_VISIBILITY
     bool starts_with(basic_string_view __s) const noexcept
     { return size() >= __s.size() && compare(0, __s.size(), __s) == 0; }
 
operator<<(basic_ostream<_CharT, _Traits>& __os,
            basic_string_view<_CharT, _Traits> __str);
 
 // [string.view.hash]
 template<class _CharT>
 struct __string_view_hash : public __unary_function<basic_string_view<_CharT, char_traits<_CharT> >, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const basic_string_view<_CharT, char_traits<_CharT> > __val) const _NOEXCEPT {
-        return __do_string_hash(__val.data(), __val.data() + __val.size());
+        return std::__do_string_hash(__val.data(), __val.data() + __val.size());
     }
 };
 
 template <>
 struct hash<basic_string_view<char, char_traits<char> > > : __string_view_hash<char> {};
 
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
 template <>

libcxx/include/thread

 }
 
 template <class _Tp>
 void
 __thread_specific_ptr<_Tp>::set_pointer(pointer __p)
 {
     _LIBCPP_ASSERT(get() == nullptr,
                    "Attempting to overwrite thread local data");
-    __libcpp_tls_set(__key_, __p);
+    std::__libcpp_tls_set(__key_, __p);
 }
 
 template<>
 struct _LIBCPP_TEMPLATE_VIS hash<__thread_id>
     : public __unary_function<__thread_id, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(__thread_id __v) const _NOEXCEPT

libcxx/include/tuple

constexpr size_t __find_idx_return(size_t __curr_i, size_t __res, bool __matches) {
     return !__matches ? __res :
         (__res == __not_found ? __curr_i : __ambiguous);
 }
 
 template <size_t _Nx>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr size_t __find_idx(size_t __i, const bool (&__matches)[_Nx]) {
   return __i == _Nx ? __not_found :
-      __find_idx_return(__i, __find_idx(__i + 1, __matches), __matches[__i]);
+      __find_detail::__find_idx_return(__i, __find_detail::__find_idx(__i + 1, __matches), __matches[__i]);
 }
 
 template <class _T1, class ..._Args>
 struct __find_exactly_one_checked {
     static constexpr bool __matches[sizeof...(_Args)] = {is_same<_T1, _Args>::value...};
     static constexpr size_t value = __find_detail::__find_idx(0, __matches);
     static_assert(value != __not_found, "type not found in type list" );
     static_assert(value != __ambiguous, "type occurs more than once in type list");

libcxx/include/unordered_map

unordered_map(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
       : unordered_map(__il, __n, hasher(), key_equal(), __a) {}
     _LIBCPP_INLINE_VISIBILITY
     unordered_map(initializer_list<value_type> __il, size_type __n, const hasher& __hf,
       const allocator_type& __a)
       : unordered_map(__il, __n, __hf, key_equal(), __a) {}
 #endif
     _LIBCPP_INLINE_VISIBILITY
     ~unordered_map() {
-        static_assert(sizeof(__diagnose_unordered_container_requirements<_Key, _Hash, _Pred>(0)), "");
+        static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Key, _Hash, _Pred>(0)), "");
     }
 
     _LIBCPP_INLINE_VISIBILITY
     unordered_map& operator=(const unordered_map& __u)
     {
 #ifndef _LIBCPP_CXX03_LANG
         __table_ = __u.__table_;
 #else
unordered_multimap(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
       : unordered_multimap(__il, __n, hasher(), key_equal(), __a) {}
     _LIBCPP_INLINE_VISIBILITY
     unordered_multimap(initializer_list<value_type> __il, size_type __n, const hasher& __hf,
       const allocator_type& __a)
       : unordered_multimap(__il, __n, __hf, key_equal(), __a) {}
 #endif
     _LIBCPP_INLINE_VISIBILITY
     ~unordered_multimap() {
-        static_assert(sizeof(__diagnose_unordered_container_requirements<_Key, _Hash, _Pred>(0)), "");
+        static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Key, _Hash, _Pred>(0)), "");
     }
 
     _LIBCPP_INLINE_VISIBILITY
     unordered_multimap& operator=(const unordered_multimap& __u)
     {
 #ifndef _LIBCPP_CXX03_LANG
         __table_ = __u.__table_;
 #else

libcxx/include/unordered_set

#if _LIBCPP_STD_VER > 11
     inline _LIBCPP_INLINE_VISIBILITY
     unordered_set(initializer_list<value_type> __il, size_type __n,
                                   const hasher& __hf, const allocator_type& __a)
         : unordered_set(__il, __n, __hf, key_equal(), __a) {}
 #endif
 #endif // _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     ~unordered_set() {
-        static_assert(sizeof(__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
+        static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
     }
 
     _LIBCPP_INLINE_VISIBILITY
     unordered_set& operator=(const unordered_set& __u)
     {
         __table_ = __u.__table_;
         return *this;
     }
unordered_multiset(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
       : unordered_multiset(__il, __n, hasher(), key_equal(), __a) {}
     inline _LIBCPP_INLINE_VISIBILITY
     unordered_multiset(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a)
       : unordered_multiset(__il, __n, __hf, key_equal(), __a) {}
 #endif
 #endif // _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     ~unordered_multiset() {
-        static_assert(sizeof(__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
+        static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
     }
 
     _LIBCPP_INLINE_VISIBILITY
     unordered_multiset& operator=(const unordered_multiset& __u)
     {
         __table_ = __u.__table_;
         return *this;
     }

libcxx/include/valarray

 };
 
 template <class _Tp>
 struct __abs_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
-        {return abs(__x);}
+        {return std::abs(__x);}
 };
 
 template <class _Tp>
 struct __acos_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
-        {return acos(__x);}
+        {return std::acos(__x);}
 };
 
 template <class _Tp>
 struct __asin_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
-        {return asin(__x);}
+        {return std::asin(__x);}
 };
 
 template <class _Tp>
 struct __atan_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
-        {return atan(__x);}
+        {return std::atan(__x);}
 };
 
 template <class _Tp>
 struct __atan2_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return atan2(__x, __y);}
+        {return std::atan2(__x, __y);}
 };
 
 template <class _Tp>
 struct __cos_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
-        {return cos(__x);}
+        {return std::cos(__x);}
 };
 
 template <class _Tp>
 struct __cosh_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
-        {return cosh(__x);}
+        {return std::cosh(__x);}
 };
 
 template <class _Tp>
 struct __exp_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
-        {return exp(__x);}
+        {return std::exp(__x);}
 };
 
 template <class _Tp>
 struct __log_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
-        {return log(__x);}
+        {return std::log(__x);}
 };
 
 template <class _Tp>
 struct __log10_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
-        {return log10(__x);}
+        {return std::log10(__x);}
 };
 
 template <class _Tp>
 struct __pow_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return pow(__x, __y);}
+        {return std::pow(__x, __y);}
 };
 
 template <class _Tp>
 struct __sin_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
-        {return sin(__x);}
+        {return std::sin(__x);}
 };
 
 template <class _Tp>
 struct __sinh_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
-        {return sinh(__x);}
+        {return std::sinh(__x);}
 };
 
 template <class _Tp>
 struct __sqrt_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
-        {return sqrt(__x);}
+        {return std::sqrt(__x);}
 };
 
 template <class _Tp>
 struct __tan_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
-        {return tan(__x);}
+        {return std::tan(__x);}
 };
 
 template <class _Tp>
 struct __tanh_expr
 {
     typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
-        {return tanh(__x);}
+        {return std::tanh(__x);}
 };
 
 template <class _ValExpr>
 class __slice_expr
 {
     typedef __libcpp_remove_reference_t<_ValExpr>  _RmExpr;
 public:
     typedef typename _RmExpr::value_type value_type;

libcxx/include/variant

for (_Trait __t : __traits) {
     }
   }
   return __result;
 }
 
 template <typename... _Types>
 struct __traits {
   static constexpr _Trait __copy_constructible_trait =
-      __common_trait({__trait<_Types,
+      __variant_detail::__common_trait({__trait<_Types,
                               is_trivially_copy_constructible,
                               is_copy_constructible>...});
 
   static constexpr _Trait __move_constructible_trait =
-      __common_trait({__trait<_Types,
+      __variant_detail::__common_trait({__trait<_Types,
                               is_trivially_move_constructible,
                               is_move_constructible>...});
 
-  static constexpr _Trait __copy_assignable_trait = __common_trait(
+  static constexpr _Trait __copy_assignable_trait = __variant_detail::__common_trait(
       {__copy_constructible_trait,
        __trait<_Types, is_trivially_copy_assignable, is_copy_assignable>...});
 
-  static constexpr _Trait __move_assignable_trait = __common_trait(
+  static constexpr _Trait __move_assignable_trait = __variant_detail::__common_trait(
       {__move_constructible_trait,
        __trait<_Types, is_trivially_move_assignable, is_move_assignable>...});
 
-  static constexpr _Trait __destructible_trait = __common_trait(
+  static constexpr _Trait __destructible_trait = __variant_detail::__common_trait(
       {__trait<_Types, is_trivially_destructible, is_destructible>...});
 };
 
 namespace __access {
 
 struct __union {
   template <class _Vp>
   _LIBCPP_HIDE_FROM_ABI

 _LIBCPP_HIDE_FROM_ABI
 constexpr bool __holds_alternative(const variant<_Types...>& __v) noexcept {
   return __v.index() == _Ip;
 }
 
 template <class _Tp, class... _Types>
 _LIBCPP_HIDE_FROM_ABI
 constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept {
-  return __holds_alternative<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+  return std::__holds_alternative<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 template <size_t _Ip, class _Vp>
 _LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 constexpr auto&& __generic_get(_Vp&& __v) {
   using __variant_detail::__access::__variant;
-  if (!__holds_alternative<_Ip>(__v)) {
+  if (!std::__holds_alternative<_Ip>(__v)) {
     __throw_bad_variant_access();
   }
   return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value;
 }
 
 template <size_t _Ip, class... _Types>
 _LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 constexpr variant_alternative_t<_Ip, variant<_Types...>>& get(
     variant<_Types...>& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
-  return __generic_get<_Ip>(__v);
+  return std::__generic_get<_Ip>(__v);
 }
 
 template <size_t _Ip, class... _Types>
 _LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 constexpr variant_alternative_t<_Ip, variant<_Types...>>&& get(
     variant<_Types...>&& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
-  return __generic_get<_Ip>(_VSTD::move(__v));
+  return std::__generic_get<_Ip>(_VSTD::move(__v));
 }
 
 template <size_t _Ip, class... _Types>
 _LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 constexpr const variant_alternative_t<_Ip, variant<_Types...>>& get(
     const variant<_Types...>& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
-  return __generic_get<_Ip>(__v);
+  return std::__generic_get<_Ip>(__v);
 }
 
 template <size_t _Ip, class... _Types>
 _LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 constexpr const variant_alternative_t<_Ip, variant<_Types...>>&& get(
     const variant<_Types...>&& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
-  return __generic_get<_Ip>(_VSTD::move(__v));
+  return std::__generic_get<_Ip>(_VSTD::move(__v));
 }
 
 template <class _Tp, class... _Types>
 _LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 constexpr _Tp& get(variant<_Types...>& __v) {
   static_assert(!is_void_v<_Tp>);
   return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
constexpr const _Tp&& get(const variant<_Types...>&& __v) {
   return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(
       _VSTD::move(__v));
 }
 
 template <size_t _Ip, class _Vp>
 _LIBCPP_HIDE_FROM_ABI
 constexpr auto* __generic_get_if(_Vp* __v) noexcept {
   using __variant_detail::__access::__variant;
-  return __v && __holds_alternative<_Ip>(*__v)
+  return __v && std::__holds_alternative<_Ip>(*__v)
              ? _VSTD::addressof(__variant::__get_alt<_Ip>(*__v).__value)
              : nullptr;
 }
 
 template <size_t _Ip, class... _Types>
 _LIBCPP_HIDE_FROM_ABI
 constexpr add_pointer_t<variant_alternative_t<_Ip, variant<_Types...>>>
 get_if(variant<_Types...>* __v) noexcept {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
-  return __generic_get_if<_Ip>(__v);
+  return std::__generic_get_if<_Ip>(__v);
 }
 
 template <size_t _Ip, class... _Types>
 _LIBCPP_HIDE_FROM_ABI
 constexpr add_pointer_t<const variant_alternative_t<_Ip, variant<_Types...>>>
 get_if(const variant<_Types...>* __v) noexcept {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
-  return __generic_get_if<_Ip>(__v);
+  return std::__generic_get_if<_Ip>(__v);
 }
 
 template <class _Tp, class... _Types>
 _LIBCPP_HIDE_FROM_ABI
 constexpr add_pointer_t<_Tp>
 get_if(variant<_Types...>* __v) noexcept {
   static_assert(!is_void_v<_Tp>);
   return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
size_t __res =
                : __variant::__visit_alt(
                      [](const auto& __alt) {
                        using __alt_type = __remove_cvref_t<decltype(__alt)>;
                        using __value_type = remove_const_t<
                          typename __alt_type::__value_type>;
                        return hash<__value_type>{}(__alt.__value);
                      },
                      __v);
-    return __hash_combine(__res, hash<size_t>{}(__v.index()));
+    return std::__hash_combine(__res, hash<size_t>{}(__v.index()));
   }
 };
 
 // __unchecked_get is the same as std::get, except, it is UB to use it with the wrong
 // type whereas std::get will throw or returning nullptr. This makes it faster than
 // std::get.
 template <size_t _Ip, class _Vp>
 _LIBCPP_HIDE_FROM_ABI
 constexpr auto&& __unchecked_get(_Vp&& __v) noexcept {
   using __variant_detail::__access::__variant;
   return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value;
 }
 
 template <class _Tp, class... _Types>
 _LIBCPP_HIDE_FROM_ABI
 constexpr auto&& __unchecked_get(const variant<_Types...>& __v) noexcept {
-  return __unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+  return std::__unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 template <class _Tp, class... _Types>
 _LIBCPP_HIDE_FROM_ABI
 constexpr auto&& __unchecked_get(variant<_Types...>& __v) noexcept {
-  return __unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+  return std::__unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 #endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_VARIANT

libcxx/test/CMakeLists.txt

 macro(pythonize_bool var)
   if (${var})
     set(${var} True)
   else()
     set(${var} False)
   endif()
 endmacro()
 
+add_subdirectory(tools)
+
 set(LIBCXX_LIT_VARIANT "libcxx" CACHE STRING
     "Configuration variant to use for LIT.")
 
 set(LIBCXX_TEST_LINKER_FLAGS "" CACHE STRING
     "Additonal linker flags to pass when compiling the tests")
 set(LIBCXX_TEST_COMPILER_FLAGS "" CACHE STRING
     "Additonal linker flags to pass when compiling the tests")
 

libcxx/test/configs/cmake-bridge.cfg.in

 # Add substitutions for bootstrapping the test suite configuration
 import shlex
 config.substitutions.append(('%{cxx}', shlex.quote('@CMAKE_CXX_COMPILER@')))
 config.substitutions.append(('%{libcxx}', '@LIBCXX_SOURCE_DIR@'))
 config.substitutions.append(('%{include}', '@LIBCXX_GENERATED_INCLUDE_DIR@'))
 config.substitutions.append(('%{target-include}', '@LIBCXX_GENERATED_INCLUDE_TARGET_DIR@'))
 config.substitutions.append(('%{lib}', '@LIBCXX_LIBRARY_DIR@'))
 config.substitutions.append(('%{executor}', '@LIBCXX_EXECUTOR@'))
+config.substitutions.append(('%{test-tools}', '@LIBCXX_TEST_TOOLS_PATH@'))

libcxx/test/libcxx/clang_tidy.sh.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: has-clang-tidy
 
 // The GCC compiler flags are not always compatible with clang-tidy.
 // UNSUPPORTED: gcc
 
 // TODO: run clang-tidy with modules enabled once they are supported
+// RUN: clang-tidy %s --warnings-as-errors=* -header-filter=.* --checks='-*,libcpp-*' --load=%{test-tools}/clang_tidy_checks/libcxx-tidy.plugin -- %{compile_flags} -fno-modules
 // RUN: clang-tidy %s --warnings-as-errors=* -header-filter=.* --config-file=%S/../../.clang-tidy -- -Wweak-vtables %{compile_flags} -fno-modules
 
 // Prevent <ext/hash_map> from generating deprecated warnings for this test.
 #if defined(__DEPRECATED)
 #    undef __DEPRECATED
 #endif
 
 /*

libcxx/test/tools/CMakeLists.txt

+
+set(LIBCXX_TEST_TOOLS_PATH ${CMAKE_CURRENT_BINARY_DIR} PARENT_SCOPE)
+
+add_subdirectory(clang_tidy_checks)

libcxx/test/tools/clang_tidy_checks/CMakeLists.txt

+
+find_package(Clang 16.0)
+
+set(SOURCES
+    robust_against_adl.cpp
+    libcpp_module.cpp)
+
+
+if(NOT Clang_FOUND)
+  message(STATUS "Could not find a suitable version of the Clang development package;
+                  custom libc++ clang-tidy checks will not be available.")
+  return()
+endif()
+
+message(STATUS "Found system-installed LLVM ${LLVM_PACKAGE_VERSION} with headers in ${LLVM_INCLUDE_DIRS}")
+
+set(CMAKE_CXX_STANDARD 20)
+
+# Link only against clangTidy itself, not anything that clangTidy uses; otherwise we run setup code multiple times
+# which results in clang-tidy crashing
+set_target_properties(clangTidy PROPERTIES INTERFACE_LINK_LIBRARIES "")
+# ClangTargets.cmake doesn't set the include paths, so we have to do it
+target_include_directories(clangTidy INTERFACE
+                           ${CLANG_INCLUDE_DIRS}
+                           ${LLVM_INCLUDE_DIRS}
+                           ${LLVM_MAIN_INCLUDE_DIR}/../../clang-tools-extra
+                          )
+target_compile_options(clangTidy INTERFACE -fno-rtti)
+
+add_library(cxx-tidy MODULE ${SOURCES})
+target_link_libraries(cxx-tidy clangTidy)
+
+set_target_properties(cxx-tidy PROPERTIES
+                      CXX_STANDARD 20
+                      CXX_STANDARD_REQUIRED YES
+                      CXX_EXTENSIONS NO)
+
+set_target_properties(cxx-tidy PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+set(CMAKE_SHARED_MODULE_SUFFIX_CXX .plugin) # Use a single suffix to simplify how we can find it from Lit

libcxx/test/tools/clang_tidy_checks/libcpp_module.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang-tidy/ClangTidyModule.h"
+#include "clang-tidy/ClangTidyModuleRegistry.h"
+#include "robust_against_adl.hpp"
+
+namespace {
+class LibcxxTestModule : public clang::tidy::ClangTidyModule {
+public:
+  void addCheckFactories(clang::tidy::ClangTidyCheckFactories& check_factories) override {
+    check_factories.registerCheck<libcpp::robust_against_adl_check>("libcpp-robust-against-adl");
+  }
+};
+} // namespace
+
+clang::tidy::ClangTidyModuleRegistry::Add<LibcxxTestModule> libcpp_module{
+    "libcpp-module", "Adds libc++-specific checks."};

libcxx/test/tools/clang_tidy_checks/robust_against_adl.hpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang-tidy/ClangTidyCheck.h"
+
+namespace libcpp {
+class robust_against_adl_check : public clang::tidy::ClangTidyCheck {
+public:
+  robust_against_adl_check(llvm::StringRef, clang::tidy::ClangTidyContext*);
+  void registerMatchers(clang::ast_matchers::MatchFinder*) override;
+  void check(const clang::ast_matchers::MatchFinder::MatchResult&) override;
+};
+} // namespace libcpp

libcxx/test/tools/clang_tidy_checks/robust_against_adl.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang-tidy/ClangTidyCheck.h"
+#include "clang-tidy/ClangTidyModuleRegistry.h"
+
+#include "robust_against_adl.hpp"
+
+#include <algorithm>
+
+namespace {
+AST_MATCHER(clang::UnresolvedLookupExpr, requiresADL) { return Node.requiresADL(); }
+
+AST_MATCHER(clang::CallExpr, isOperator) { return llvm::isa<clang::CXXOperatorCallExpr>(Node); }
+
+AST_MATCHER(clang::UnresolvedLookupExpr, isCustomizationPoint) {
+  // TODO: Are make_error_code and make_error_condition actually customization points?
+  return std::ranges::any_of(
+      std::array{"swap", "make_error_code", "make_error_condition", "begin", "end", "size", "rend", "rbegin"},
+      [&](const char* func) { return Node.getName().getAsString() == func; });
+}
+
+AST_MATCHER(clang::CXXMethodDecl, isStatic) { return Node.isStatic(); }
+
+} // namespace
+
+namespace libcpp {
+robust_against_adl_check::robust_against_adl_check(llvm::StringRef name, clang::tidy::ClangTidyContext* context)
+    : clang::tidy::ClangTidyCheck(name, context) {}
+
+void robust_against_adl_check::registerMatchers(clang::ast_matchers::MatchFinder* finder) {
+  using namespace clang::ast_matchers;
+  finder->addMatcher(
+      callExpr(unless(isOperator()),
+               unless(argumentCountIs(0)),
+               has(unresolvedLookupExpr(requiresADL(), unless(isCustomizationPoint()))),
+               unless(callee(cxxMethodDecl(isStatic()))))
+          .bind("ADLcall"),
+      this);
+}
+
+void robust_against_adl_check::check(const clang::ast_matchers::MatchFinder::MatchResult& result) {
+  if (const auto* call = result.Nodes.getNodeAs<clang::CallExpr>("ADLcall"); call != nullptr) {
+    diag(call->getBeginLoc(), "ADL lookup");
+  }
+}
+} // namespace libcpp

libcxx/utils/libcxx/test/features.py

 _isClang      = lambda cfg: '__clang__' in compilerMacros(cfg) and '__apple_build_version__' not in compilerMacros(cfg)
 _isAppleClang = lambda cfg: '__apple_build_version__' in compilerMacros(cfg)
 _isGCC        = lambda cfg: '__GNUC__' in compilerMacros(cfg) and '__clang__' not in compilerMacros(cfg)
 _isMSVC       = lambda cfg: '_MSC_VER' in compilerMacros(cfg)
 _msvcVersion  = lambda cfg: (int(compilerMacros(cfg)['_MSC_VER']) // 100, int(compilerMacros(cfg)['_MSC_VER']) % 100)
 
 def _hasSuitableClangTidy(cfg):
   try:
-    return int(re.search('[0-9]+', commandOutput(cfg, ['clang-tidy --version'])).group()) >= 13
+    return int(re.search('[0-9]+', commandOutput(cfg, ['clang-tidy --version'])).group()) >= 13 and runScriptExitCode(
+      cfg, ['stat %{test-tools}/clang_tidy_checks/libcxx-tidy.plugin']) == 0
   except ConfigurationRuntimeError:
     return False
 
 def _hasSuitableClangQuery(cfg):
   try:
     return int(re.search('[0-9]+', commandOutput(cfg, ['clang-query --version'])).group()) >= 13
   except ConfigurationRuntimeError:
     return False
DEFAULT_FEATURES = [
   # utilities. Test executing "bash -c 'bash --version'" to see if bash
   # manages to find binaries to execute.
   Feature(name='executor-has-no-bash',
           when=lambda cfg: runScriptExitCode(cfg, ['%{exec} bash -c \'bash --version\'']) != 0),
   Feature(name='has-clang-tidy',
           when=_hasSuitableClangTidy),
   Feature(name='has-clang-query',
           when=_hasSuitableClangQuery),
 
   Feature(name='apple-clang',                                                                                                      when=_isAppleClang),
   Feature(name=lambda cfg: 'apple-clang-{__clang_major__}'.format(**compilerMacros(cfg)),                                          when=_isAppleClang),
   Feature(name=lambda cfg: 'apple-clang-{__clang_major__}.{__clang_minor__}'.format(**compilerMacros(cfg)),                        when=_isAppleClang),
   Feature(name=lambda cfg: 'apple-clang-{__clang_major__}.{__clang_minor__}.{__clang_patchlevel__}'.format(**compilerMacros(cfg)), when=_isAppleClang),
 
   Feature(name='clang',                                                                                                            when=_isClang),
   Feature(name=lambda cfg: 'clang-{__clang_major__}'.format(**compilerMacros(cfg)),                                                when=_isClang),
   Feature(name=lambda cfg: 'clang-{__clang_major__}.{__clang_minor__}'.format(**compilerMacros(cfg)),                              when=_isClang),