[libcxx][NFC] replaces `<utility>` includes with specific headers

[cjdb]

Summary

Depends on D104942.

[cjdb]

rebases to activate CI (I think it flaked)

[cjdb]

found missing header

[cjdb]

fixes benchmarks

[ldionne]

libcxx/include/__functional/greater.h

52–55 ↗

(On Diff #354720)

What's the rationale for making this change here? Why not include __utility/forward.h?

libcxx/include/type_traits

1366–1375

Why this? And most importantly, why is it in this patch?

[cjdb]

libcxx/include/__functional/greater.h

52–55 ↗

(On Diff #354720)

Oh, did this slip through? I was experimenting with something and then abandoned it. Will fix.

libcxx/include/type_traits

1366–1375

Seems I did a copy/paste instead of cut/paste. declval already had its own header but was never removed from type_traits, and we're not violating the ODR by declaring it twice in two different places (but diagnostics point to <type_traits> instead of <utility>).

[cjdb]

rebases to acivate CI

[cjdb]

adds <cstddef> and qualifies std::nullptr_t

[Mordante]

Nice cleanup!

libcxx/include/__functional/greater.h

52–55 ↗

(On Diff #354720)

I noticed the same change at other places too.

libcxx/include/__split_buffer

6

Please sort the headers.

libcxx/include/algorithm

655

Can you remove the duplicated includes and sort them. Not part of your change, but would be nice to do it along in this patch,

libcxx/include/mutex

200

D104942 landed __functional/invoke.h, can you use that? If not please update the comment.

[cjdb]

libcxx/include/__functional/greater.h

52–55 ↗

(On Diff #354720)

It's moot because these files don't exist any more.

libcxx/include/mutex

200

Out of scope: I'll apply it in D104982.

[cjdb]

libcxx/include/mutex

200

After further inspection, __invoke still lives in type_traits. Won't fix in D104982.

[cjdb]

rebases on to main

[ldionne]

libcxx/include/__functional/identity.h

27

Same here, this shouldn't be part of this change.

libcxx/include/concepts

216

Same.. those shouldn't be part of this patch (and if you want to do it throughout in a different patch, let's discuss beforehand).

libcxx/include/module.modulemap

716

What happens if you don't export __tuple?

[cjdb]

libcxx/include/concepts

216

Hmm... I didn't realise I did it to so many things. I owe @Mordante an apology in that case.

I'll do an audit before uploading a new revision.

libcxx/include/module.modulemap

716

Bad things. Seriously though, it means that whatever standard stuff pair.h exports which currently lives in __tuple won't be transitively exported. I haven't properly looked into what __tuple owns, but there are a few things, and we'll need to detangle them from tuple's dependencies.

Both of those tasks are far lower on my P-list: I'm trying to focus more on improving potential UX for our existing header splices as well as implementing ranges algos.

[Mordante]

libcxx/include/module.modulemap

716

@cjdb This sounds like the same issue I have with <optional> in <__format/format_context.h> (D103357)

[EricWF]

So we're splitting up the headers (which I don't love, but will hold my tongue for the most part).

The intention is to provide better name hygene for our users. Meaning headers will export _fewer_ names than they do at present.
This is an intentional BREAKING change. Users will have to update their code to include the correct headers before it will compile.

Before we do this we need to:

1. Announce and discuss this change, it's rational, and its benefits to *all libc++ vendors*.
2. Document the list of names removed from every header. This list should be complete.
3. Ensure Clang's error messages tell users _which_ headers to include. Or at least don't tell users to include the wrong (implementation) headers.

[cjdb]

In D104980#2862532, @EricWF wrote:

So we're splitting up the headers (which I don't love, but will hold my tongue for the most part).

The intention is to provide better name hygene for our users. Meaning headers will export _fewer_ names than they do at present.
This is an intentional BREAKING change. Users will have to update their code to include the correct headers before it will compile.

Before we do this we need to:

1. Announce and discuss this change, it's rational, and its benefits to *all libc++ vendors*.
2. Document the list of names removed from every header. This list should be complete.
3. Ensure Clang's error messages tell users _which_ headers to include. Or at least don't tell users to include the wrong (implementation) headers.

Agreed. Specifically responding to (3): D105439 is the first of a few patches that I'm working on to get Clang to minimise the pain from breakages and prevent users from making certain mistakes in the interim.

[ldionne]

In D104980#2862532, @EricWF wrote:

So we're splitting up the headers (which I don't love, but will hold my tongue for the most part).

The intention is to provide better name hygene for our users. Meaning headers will export _fewer_ names than they do at present.
This is an intentional BREAKING change. Users will have to update their code to include the correct headers before it will compile.

Before we do this we need to:

1. Announce and discuss this change, it's rational, and its benefits to *all libc++ vendors*.
2. Document the list of names removed from every header. This list should be complete.
3. Ensure Clang's error messages tell users _which_ headers to include. Or at least don't tell users to include the wrong (implementation) headers.

It is indeed a breaking change, albeit one that is easy to remediate for users. But on a large scale, I agree it can be challenging to tackle.

While there is a clear benefit in making the headers less monolithic, minimizing the includes themselves is, as someone who just wants to ship an updated libc++, primarily a pain point. I'm willing to play ball and go through the pain of fixing my direct users (even though that's a huge pain), but if another vendor finds this change too disruptive, I can also get behind that. At the end of the day, the pain is real, but the benefit has a component of "pedantic correctness" to it. It would be a lot easier to make this change if we somehow could make it gradually, but I think the only way to do that would be for users to make sure their code always builds with modules enabled and disabled.

[cjdb]

In D104980#2862916, @ldionne wrote:

In D104980#2862532, @EricWF wrote:

So we're splitting up the headers (which I don't love, but will hold my tongue for the most part).

The intention is to provide better name hygene for our users. Meaning headers will export _fewer_ names than they do at present.
This is an intentional BREAKING change. Users will have to update their code to include the correct headers before it will compile.

Before we do this we need to:

1. Announce and discuss this change, it's rational, and its benefits to *all libc++ vendors*.
2. Document the list of names removed from every header. This list should be complete.
3. Ensure Clang's error messages tell users _which_ headers to include. Or at least don't tell users to include the wrong (implementation) headers.

It is indeed a breaking change, albeit one that is easy to remediate for users. But on a large scale, I agree it can be challenging to tackle.

While there is a clear benefit in making the headers less monolithic, minimizing the includes themselves is, as someone who just wants to ship an updated libc++, primarily a pain point. I'm willing to play ball and go through the pain of fixing my direct users (even though that's a huge pain), but if another vendor finds this change too disruptive, I can also get behind that. At the end of the day, the pain is real, but the benefit has a component of "pedantic correctness" to it. It would be a lot easier to make this change if we somehow could make it gradually, but I think the only way to do that would be for users to make sure their code always builds with modules enabled and disabled.

I'm starting to form a longer-term plan, so it would be best if we held off on merging this (and its children) till after the branch point at the end of the month. I have no idea how long it will take for my ideas to get integrated into Clang (and other relevant LLVM tools, if necessary). @ldionne I think it would also be good for us to not immediately fix anyone, so that we can get deployment experience (across multiple customers) for the features I end up implementing. Then we can publish a guide explaining how users ought to migrate to libc++next.

[cjdb]

There might be a potential workaround for this effort that lets us make progress, while also not throwing the world under the bus. <Windows.h> has a WIN32_LEAN_AND_MEAN macro that users can opt into if they want a slimmer <Windows.h>. We could have a similar macro that users opt into if they want slimmer libc++ headers for the time being. Once we've gotten tooling to a spot where we're happy users have automated remediation, we can then remove our use of this macro, and deprecate _LIBCPP_LEAN_AND_MEAN.

In summary: no one gets broken, anyone who wants slimmer headers gets them, and we eventually get to the "ideal" state. @ldionne, @EricWF, WDYT?

[ldionne]

In D104980#2880792, @cjdb wrote:

There might be a potential workaround for this effort that lets us make progress, while also not throwing the world under the bus. <Windows.h> has a WIN32_LEAN_AND_MEAN macro that users can opt into if they want a slimmer <Windows.h>. We could have a similar macro that users opt into if they want slimmer libc++ headers for the time being. Once we've gotten tooling to a spot where we're happy users have automated remediation, we can then remove our use of this macro, and deprecate _LIBCPP_LEAN_AND_MEAN.

In summary: no one gets broken, anyone who wants slimmer headers gets them, and we eventually get to the "ideal" state. @ldionne, @EricWF, WDYT?

Part of me wants to say "no, let's not add yet another configuration that'll only make things more complicated", and part of me wants to say "yes, that will allow us to keep making progress on this header minimization without breaking users".

However, since there is very little benefit to minimizing the headers if nobody's going to turn on that LEAN_AND_MEAN flag, I'm not sure. Instead, here's what I think would be best:

1. Minimize the includes in all the detail headers, and in the public headers too.
2. However, for "backwards compatibility", keep the unnecessary includes in the public headers, but group them and put them at the end of all the #includes:

#include <__utility/whatever.h>
#include <__ranges/whatever.h>

// Kept for backwards compatibility until we can remove them
#include <utility>
#include <whatever>

Eventually, when we're ready to make the move, we'll be able to very easily make the jump for everyone by just removing those stray includes from all public headers. We might need to do a few adjustments before we can drop them (because as time passes, we might sometimes start relying on a few transitive includes by mistake here and there), but that should be much easier to do than what we're doing now.

I guess I'm just somewhat reluctant to adding yet another user-visible knob.

libcxx/include/algorithm

655

I would definitely wait for a separate NFC commit, since doing it here will obscure the changes we're making in this patch, which are all precisely #include-related.

[cjdb]

In D104980#2880948, @ldionne wrote:

In D104980#2880792, @cjdb wrote:

There might be a potential workaround for this effort that lets us make progress, while also not throwing the world under the bus. <Windows.h> has a WIN32_LEAN_AND_MEAN macro that users can opt into if they want a slimmer <Windows.h>. We could have a similar macro that users opt into if they want slimmer libc++ headers for the time being. Once we've gotten tooling to a spot where we're happy users have automated remediation, we can then remove our use of this macro, and deprecate _LIBCPP_LEAN_AND_MEAN.

In summary: no one gets broken, anyone who wants slimmer headers gets them, and we eventually get to the "ideal" state. @ldionne, @EricWF, WDYT?

Part of me wants to say "no, let's not add yet another configuration that'll only make things more complicated", and part of me wants to say "yes, that will allow us to keep making progress on this header minimization without breaking users".

However, since there is very little benefit to minimizing the headers if nobody's going to turn on that LEAN_AND_MEAN flag, I'm not sure. Instead, here's what I think would be best:

Someone from the Chrome toolchain team sent me an email this morning asking if we can trim our headers, since their include graph blames our user-facing headers as a huge build time sink. My news to them about our current stalling left a bad taste in my mouth, but I was inspired by something that they said about D90072 to think creatively, and then remembered WIN32_LEAN_AND_MEAN. Since they reached out to me, this has gone from "I think this is a space to improve" to "there is a customer requesting something in this space". If they like the idea, I think it's worth entertaining, since Chrome takes forever to build. I've asked someone from that team to chime in as well.

1. Minimize the includes in all the detail headers, and in the public headers too.
2. However, for "backwards compatibility", keep the unnecessary includes in the public headers, but group them and put them at the end of all the #includes:

#include <__utility/whatever.h>
#include <__ranges/whatever.h>

// Kept for backwards compatibility until we can remove them
#include <utility>
#include <whatever>

Eventually, when we're ready to make the move, we'll be able to very easily make the jump for everyone by just removing those stray includes from all public headers. We might need to do a few adjustments before we can drop them (because as time passes, we might sometimes start relying on a few transitive includes by mistake here and there), but that should be much easier to do than what we're doing now.

If we're vigilant about our modules build (and I think we're starting to automate a check in that space), then this should only happen while we're including user-facing headers.

I guess I'm just somewhat reluctant to adding yet another user-visible knob.

I don't really like it any more than you do, but it's a user-visible knob with a very short life expectancy.

[• Quuxplusone]

Someone from the Chrome toolchain team sent me an email this morning asking if we can trim our headers, since their include graph blames our user-facing headers as a huge build time sink.

Compared to all the other stuff in a big project like Chrome, blaming libc++ surprises me. Are they claiming that Chrome builds faster against libstdc++, then? Any chance of getting them to go public with their measurements? And they're blaming specifically the size of the headers (including, I should add, the disk traffic from opening and closing all these little files), not anything about the actual contents/implementation? E.g. I myself have done a blog post titled "37% of HyperRogue's compilation time is due to std::function" (2019-01-06), but that's nothing to do with disk traffic nor compiler-internal data structures, and everything to do with the bloated std::function API/ABI itself.

I don't really like it any more than you do, but it's a user-visible knob with a very short life expectancy.

User-visible features never really have short life expectancies. ISTR someone talking about "Hyrum's Law" on this very Phabricator instance, fairly recently... ;)

[cjdb]

In D104980#2881239, @Quuxplusone wrote:

Someone from the Chrome toolchain team sent me an email this morning asking if we can trim our headers, since their include graph blames our user-facing headers as a huge build time sink.

Compared to all the other stuff in a big project like Chrome, blaming libc++ surprises me. Are they claiming that Chrome builds faster against libstdc++, then?

No. Chrome isn't built against libstdc++ (I'm not sure if it's even possible). Granted, libstdc++ is out of scope.

Any chance of getting them to go public with their measurements?

Good question, but I don't have an answer for you.

And they're blaming specifically the size of the headers (including, I should add, the disk traffic from opening and closing all these little files), not anything about the actual contents/implementation? E.g. I myself have done a blog post titled "37% of HyperRogue's compilation time is due to std::function" (2019-01-06), but that's nothing to do with disk traffic nor compiler-internal data structures, and everything to do with the bloated std::function API/ABI itself.

I'll also leave this question to the Chrome toolchain team to answer, but it seems to me that the little files are hardly a blip on the radar, and that a dominating factor is that we're (libc++) unnecessarily transitively including a lot more than we need to be.

I don't really like it any more than you do, but it's a user-visible knob with a very short life expectancy.

User-visible features never really have short life expectancies. ISTR someone talking about "Hyrum's Law" on this very Phabricator instance, fairly recently... ;)

This won't end up being a Hyrumbug. Hyrum's law states that given a sufficiently large user base and enough time, anything that is observable eventually becomes the interface, even if it's intended to be an implementation detail, which will lead to breaks on anything that's public facing. In this case, we'd have a public-facing macro (so it's already exempt), that would be deprecated when it's no longer necessary (so users stop defining it), and even once we remove said deprecation notice, it won't break anyone. It'll just be a benign eyesore in some code.

[hans]

However, since there is very little benefit to minimizing the headers if nobody's going to turn on that LEAN_AND_MEAN flag, I'm not sure. Instead, here's what I think would be best:

Someone from the Chrome toolchain team sent me an email this morning asking if we can trim our headers, since their include graph blames our user-facing headers as a huge build time sink. My news to them about our current stalling left a bad taste in my mouth, but I was inspired by something that they said about D90072 to think creatively, and then remembered WIN32_LEAN_AND_MEAN. Since they reached out to me, this has gone from "I think this is a space to improve" to "there is a customer requesting something in this space". If they like the idea, I think it's worth entertaining, since Chrome takes forever to build. I've asked someone from that team to chime in as well.

If there were a LIBCPP_LEAN_AND_MEAN flag which reduced the header sizes meaningfully, we'd certainly use it.

In order to enable it, having Clang diagnostics with good fixit hints would certainly help, but we could probably do without it too with some scripting, so don't block on that on our account.

In D104980#2881239, @Quuxplusone wrote:

Someone from the Chrome toolchain team sent me an email this morning asking if we can trim our headers, since their include graph blames our user-facing headers as a huge build time sink.

Compared to all the other stuff in a big project like Chrome, blaming libc++ surprises me. Are they claiming that Chrome builds faster against libstdc++, then? Any chance of getting them to go public with their measurements? And they're blaming specifically the size of the headers (including, I should add, the disk traffic from opening and closing all these little files), not anything about the actual contents/implementation? E.g. I myself have done a blog post titled "37% of HyperRogue's compilation time is due to std::function" (2019-01-06), but that's nothing to do with disk traffic nor compiler-internal data structures, and everything to do with the bloated std::function API/ABI itself.

We're not blaming our slow builds on libc++, but we're looking everywhere we can, and if the libc++ headers could be made slimmer, it would certainly help since we rely on many of them almost everywhere, and I'd expect it would be a win for other projects too.

The numbers we're looking at are public, and can be found here: https://commondatastorage.googleapis.com/chromium-browser-clang/include-analysis.html That doesn't measure compile time, but compiler input size. In other measurements we've seen a strong correlation between compiler input size and compile time. It's not surprising that libc++ headers are on top since they're included everywhere, but that also means there's a high chance slimmer libc++ headers would have measurable impact for us.

[hans]

The numbers we're looking at are public, and can be found here: https://commondatastorage.googleapis.com/chromium-browser-clang/include-analysis.html That doesn't measure compile time, but compiler input size. In other measurements we've seen a strong correlation between compiler input size and compile time. It's not surprising that libc++ headers are on top since they're included everywhere, but that also means there's a high chance slimmer libc++ headers would have measurable impact for us.

The same analysis for an LLVM build is available here: https://commondatastorage.googleapis.com/chromium-browser-clang/llvm-include-analysis.html though that uses libstdc++ (and hasn't been updated in a while). The standard headers show up on top, and I assume that's common across most c++ projects.

libcxx/benchmarks/algorithms.bench.cpp

 
 #include <algorithm>
 #include <cstdint>
+#include <functional>
 #include <map>
 #include <random>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "CartesianBenchmarks.h"
 #include "GenerateInput.h"
makeCartesianProductBenchmark<StableSort, AllValueTypes, AllOrders>(
       Quantities);
   makeCartesianProductBenchmark<MakeHeap, AllValueTypes, AllOrders>(Quantities);
   makeCartesianProductBenchmark<SortHeap, AllValueTypes>(Quantities);
   makeCartesianProductBenchmark<MakeThenSortHeap, AllValueTypes, AllOrders>(
       Quantities);
   makeCartesianProductBenchmark<PushHeap, AllValueTypes, AllOrders>(Quantities);
   makeCartesianProductBenchmark<PopHeap, AllValueTypes>(Quantities);
   benchmark::RunSpecifiedBenchmarks();
-}
+}
 

libcxx/include/__algorithm/comp_ref_type.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_COMP_REF_TYPE_H
 #define _LIBCPP___ALGORITHM_COMP_REF_TYPE_H
 
 #include <__config>
+#include <__utility/declval.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__algorithm/equal_range.h

 #define _LIBCPP___ALGORITHM_EQUAL_RANGE_H
 
 #include <__config>
 #include <__algorithm/comp.h>
 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/half_positive.h>
 #include <__algorithm/lower_bound.h>
 #include <__algorithm/upper_bound.h>
+#include <__utility/pair.h>
 #include <iterator>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__algorithm/inplace_merge.h

 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/comp.h>
 #include <__algorithm/lower_bound.h>
 #include <__algorithm/min.h>
 #include <__algorithm/move.h>
 #include <__algorithm/rotate.h>
 #include <__algorithm/upper_bound.h>
 #include <__iterator/iterator_traits.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
 #include <__utility/swap.h>
 #include <memory>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__algorithm/minmax.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_MINMAX_H
 #define _LIBCPP___ALGORITHM_MINMAX_H
 
 #include <__config>
 #include <__algorithm/comp.h>
+#include <__utility/pair.h>
 #include <initializer_list>
-#include <utility>
 
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__algorithm/minmax_element.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_MINMAX_ELEMENT_H
 #define _LIBCPP___ALGORITHM_MINMAX_ELEMENT_H
 
 #include <__config>
 #include <__algorithm/comp.h>
 #include <__iterator/iterator_traits.h>
-#include <utility>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__algorithm/mismatch.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_MISMATCH_H
 #define _LIBCPP___ALGORITHM_MISMATCH_H
 
 #include <__config>
 #include <__algorithm/comp.h>
 #include <__iterator/iterator_traits.h>
-#include <utility>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__algorithm/move.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_MOVE_H
 #define _LIBCPP___ALGORITHM_MOVE_H
 
 #include <__config>
 #include <__algorithm/unwrap_iter.h>
 #include <__utility/move.h>
 #include <cstring>
-#include <utility>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__algorithm/move_backward.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_MOVE_BACKWARD_H
 #define _LIBCPP___ALGORITHM_MOVE_BACKWARD_H
 
 #include <__config>
 #include <__algorithm/unwrap_iter.h>
+#include <__utility/move.h>
 #include <cstring>
-#include <utility>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__algorithm/partition.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_PARTITION_H
 #define _LIBCPP___ALGORITHM_PARTITION_H
 
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__utility/swap.h>
-#include <utility> // pair
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__algorithm/partition_copy.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_PARTITION_COPY_H
 #define _LIBCPP___ALGORITHM_PARTITION_COPY_H
 
 #include <__config>
 #include <__iterator/iterator_traits.h>
-#include <utility> // pair
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__algorithm/remove_if.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_REMOVE_IF_H
 #define _LIBCPP___ALGORITHM_REMOVE_IF_H
 
 #include <__config>
 #include <__algorithm/find_if.h>
-#include <utility>
+#include <__utility/move.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__algorithm/rotate.h

 
 #include <__algorithm/move.h>
 #include <__algorithm/move_backward.h>
 #include <__algorithm/swap_ranges.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
 #include <__utility/swap.h>
 #include <iterator>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__algorithm/search.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_SEARCH_H
 #define _LIBCPP___ALGORITHM_SEARCH_H
 
 #include <__algorithm/comp.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
+#include <__utility/pair.h>
 #include <type_traits>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__algorithm/shift_left.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_SHIFT_LEFT_H
 #define _LIBCPP___ALGORITHM_SHIFT_LEFT_H
 
 #include <__config>
 #include <__algorithm/move.h>
 #include <__iterator/iterator_traits.h>
-#include <type_traits> // swap
+#include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__algorithm/shift_right.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_SHIFT_RIGHT_H
 #define _LIBCPP___ALGORITHM_SHIFT_RIGHT_H
 
 #include <__config>
 #include <__algorithm/move.h>
 #include <__algorithm/move_backward.h>
 #include <__algorithm/swap_ranges.h>
 #include <__iterator/iterator_traits.h>
-#include <type_traits> // swap
+#include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__algorithm/sort.h

 #define _LIBCPP___ALGORITHM_SORT_H
 
 #include <__config>
 #include <__algorithm/comp.h>
 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/min_element.h>
 #include <__algorithm/partial_sort.h>
 #include <__algorithm/unwrap_iter.h>
+#include <__utility/move.h>
 #include <__utility/swap.h>
 #include <memory>
-#include <type_traits> // swap
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__algorithm/stable_partition.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_STABLE_PARTITION_H
 #define _LIBCPP___ALGORITHM_STABLE_PARTITION_H
 
 #include <__config>
 #include <__algorithm/rotate.h>
 #include <__iterator/iterator_traits.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
 #include <__utility/swap.h>
 #include <memory>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__algorithm/stable_sort.h

 #define _LIBCPP___ALGORITHM_STABLE_SORT_H
 
 #include <__config>
 #include <__algorithm/comp.h>
 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/inplace_merge.h>
 #include <__algorithm/sort.h>
 #include <__iterator/iterator_traits.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
 #include <__utility/swap.h>
 #include <memory>
-#include <type_traits> // swap
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__algorithm/unique_copy.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_UNIQUE_COPY_H
 #define _LIBCPP___ALGORITHM_UNIQUE_COPY_H
 
 #include <__config>
 #include <__algorithm/comp.h>
 #include <__iterator/iterator_traits.h>
-#include <utility>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__algorithm/unwrap_iter.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_UNWRAP_ITER_H
 #define _LIBCPP___ALGORITHM_UNWRAP_ITER_H
 
 #include <__config>
 #include <iterator>
 #include <__memory/pointer_traits.h>
+#include <__utility/declval.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__functional/bind.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_BIND_H
 #define _LIBCPP___FUNCTIONAL_BIND_H
 
 #include <__config>
 #include <__functional/weak_result_type.h>
 #include <__functional/invoke.h>
+#include <__utility/forward.h>
 #include <cstddef>
 #include <tuple>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

libcxx/include/__functional/bind_front.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_BIND_FRONT_H
 #define _LIBCPP___FUNCTIONAL_BIND_FRONT_H
 
 #include <__config>
 #include <__functional/perfect_forward.h>
 #include <__functional/invoke.h>
+#include <__utility/forward.h>
 #include <type_traits>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17

libcxx/include/__functional/default_searcher.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_DEFAULT_SEARCHER_H
 #define _LIBCPP___FUNCTIONAL_DEFAULT_SEARCHER_H
 
 #include <__algorithm/search.h>
 #include <__config>
 #include <__functional/operations.h>
 #include <__iterator/iterator_traits.h>
-#include <utility>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14

libcxx/include/__functional/function.h

 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/invoke.h>
 #include <__functional/unary_function.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/shared_ptr.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/piecewise_construct.h>
 #include <exception>
 #include <memory> // TODO: replace with <__memory/__builtin_new_allocator.h>
 #include <type_traits>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // bad_function_call

libcxx/include/__functional/identity.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_IDENTITY_H
 #define _LIBCPP___FUNCTIONAL_IDENTITY_H
 
 #include <__config>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 struct identity {
     template<class _Tp>
     _LIBCPP_NODISCARD_EXT constexpr _Tp&& operator()(_Tp&& __t) const noexcept
     {
-        return _VSTD::forward<_Tp>(__t);
+        return static_cast<_Tp&&>(__t);
     }
 
     using is_transparent = void;
 };
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FUNCTIONAL_IDENTITY_H

libcxx/include/__functional/mem_fn.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_MEM_FN_H
 #define _LIBCPP___FUNCTIONAL_MEM_FN_H
 
 #include <__config>
 #include <__functional/weak_result_type.h>
 #include <__functional/binary_function.h>
 #include <__functional/invoke.h>
-#include <utility>
+#include <__utility/forward.h>
+#include <type_traits> // __invoke
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>

libcxx/include/__functional/not_fn.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_NOT_FN_H
 #define _LIBCPP___FUNCTIONAL_NOT_FN_H
 
 #include <__config>
 #include <__functional/perfect_forward.h>
 #include <__functional/invoke.h>
-#include <utility>
+#include <__utility/forward.h>
+#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14

libcxx/include/__functional/perfect_forward.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_PERFECT_FORWARD_H
 #define _LIBCPP___FUNCTIONAL_PERFECT_FORWARD_H
 
 #include <__config>
+#include <__utility/forward.h>
+#include <__utility/move.h>
 #include <tuple>
 #include <type_traits>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14

libcxx/include/__functional/ranges_operations.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_RANGES_OPERATIONS_H
 #define _LIBCPP___FUNCTIONAL_RANGES_OPERATIONS_H
 
 #include <__config>
 #include <concepts>
-#include <utility>
+#include <__utility/forward.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)

libcxx/include/__functional/reference_wrapper.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_REFERENCE_WRAPPER_H
 #define _LIBCPP___FUNCTIONAL_REFERENCE_WRAPPER_H
 
 #include <__config>
 #include <__functional/weak_result_type.h>
 #include <__memory/addressof.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__functional/weak_result_type.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_WEAK_RESULT_TYPE_H
 #define _LIBCPP___FUNCTIONAL_WEAK_RESULT_TYPE_H
 
 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/unary_function.h>
+#include <__utility/declval.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__functional_base

 #include <__functional/unary_function.h>
 #include <__functional/weak_result_type.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <exception>
 #include <new>
 #include <type_traits>
 #include <typeinfo>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_FUNCTIONAL_BASE

libcxx/include/__hash_table

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP__HASH_TABLE
 #define _LIBCPP__HASH_TABLE
 
 #include <__bits> // __libcpp_clz
 #include <__config>
 #include <__debug>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+#include <__utility/swap.h>
 #include <algorithm>
 #include <cmath>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <type_traits>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__iterator/advance.h

 #define _LIBCPP___ITERATOR_ADVANCE_H
 
 #include <__config>
 #include <__debug>
 #include <__function_like.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
+#include <__utility/declval.h>
+#include <__utility/move.h>
 #include <cstdlib>
 #include <concepts>
 #include <limits>
 #include <type_traits>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__iterator/back_insert_iterator.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_BACK_INSERT_ITERATOR_H
 #define _LIBCPP___ITERATOR_BACK_INSERT_ITERATOR_H
 
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/iterator.h>
 #include <__memory/addressof.h>
+#include <__utility/move.h>
 #include <cstddef>
-#include <utility> // std::move
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__iterator/front_insert_iterator.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_FRONT_INSERT_ITERATOR_H
 #define _LIBCPP___ITERATOR_FRONT_INSERT_ITERATOR_H
 
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/iterator.h>
 #include <__memory/addressof.h>
+#include <__utility/move.h>
 #include <cstddef>
-#include <utility> // std::move
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__iterator/incrementable_traits.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_INCREMENTABLE_TRAITS_H
 #define _LIBCPP___ITERATOR_INCREMENTABLE_TRAITS_H
 
 #include <__config>
+#include <__utility/declval.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__iterator/insert_iterator.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_INSERT_ITERATOR_H
 #define _LIBCPP___ITERATOR_INSERT_ITERATOR_H
 
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/iterator.h>
 #include <__memory/addressof.h>
+#include <__utility/move.h>
 #include <cstddef>
-#include <utility> // std::move
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__iterator/iter_move.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_ITER_MOVE_H
 #define _LIBCPP___ITERATOR_ITER_MOVE_H
 
 #include <__config>
 #include <__iterator/iterator_traits.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
+#include <__utility/move.h>
 #include <concepts> // __class_or_enum
 #include <type_traits>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__iterator/iter_swap.h

 #define _LIBCPP___ITERATOR_ITER_SWAP_H
 
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
 #include <__ranges/access.h>
+#include <__utility/declval.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__iterator/iterator_traits.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_ITERATOR_TRAITS_H
 #define _LIBCPP___ITERATOR_ITERATOR_TRAITS_H
 
 #include <__config>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/readable_traits.h>
+#include <__utility/declval.h>
+#include <__utility/pair.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__locale

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___LOCALE
 #define _LIBCPP___LOCALE
 
 #include <__availability>
 #include <__config>
 #include <string>
 #include <memory>
-#include <utility>
 #include <mutex>
 #include <cstdint>
 #include <cctype>
 #include <locale.h>
 #if defined(_LIBCPP_MSVCRT_LIKE)
 # include <cstring>
 # include <__support/win32/locale_win32.h>
 #elif defined(__NuttX__)

libcxx/include/__memory/allocation_guard.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_ALLOCATION_GUARD_H
 #define _LIBCPP___MEMORY_ALLOCATION_GUARD_H
 
 #include <__config>
 #include <__memory/allocator_traits.h>
+#include <__utility/move.h>
 #include <cstddef>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__memory/allocator_traits.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_ALLOCATOR_TRAITS_H
 #define _LIBCPP___MEMORY_ALLOCATOR_TRAITS_H
 
 #include <__config>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <limits>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

libcxx/include/__memory/compressed_pair.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_COMPRESSED_PAIR_H
 #define _LIBCPP___MEMORY_COMPRESSED_PAIR_H
 
 #include <__config>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+#include <__utility/piecewise_construct.h>
 #include <tuple> // needed in c++03 for some constructors
 #include <type_traits>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__memory/construct_at.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_CONSTRUCT_AT_H
 #define _LIBCPP___MEMORY_CONSTRUCT_AT_H
 
 #include <__config>
 #include <__debug>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__memory/pointer_traits.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_POINTER_TRAITS_H
 #define _LIBCPP___MEMORY_POINTER_TRAITS_H
 
 #include <__config>
 #include <__memory/addressof.h>
+#include <__utility/declval.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__memory/raw_storage_iterator.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_RAW_STORAGE_ITERATOR_H
 #define _LIBCPP___MEMORY_RAW_STORAGE_ITERATOR_H
 
 #include <__config>
 #include <__memory/addressof.h>
+#include <__utility/move.h>
 #include <cstddef>
 #include <iterator>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__memory/shared_ptr.h

 #include <__functional/reference_wrapper.h>
 #include <__memory/addressof.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/allocator.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/unique_ptr.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+#include <__utility/swap.h>
 #include <cstddef>
 #include <cstdlib> // abort
 #include <iosfwd>
 #include <stdexcept>
 #include <typeinfo>
 #include <type_traits>
-#include <utility>
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #  include <atomic>
 #endif
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
 #   include <__memory/auto_ptr.h>
 #endif
 

libcxx/include/__memory/temporary_buffer.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_TEMPORARY_BUFFER_H
 #define _LIBCPP___MEMORY_TEMPORARY_BUFFER_H
 
 #include <__config>
+#include <__utility/pair.h>
 #include <cstddef>
 #include <new>
-#include <utility> // pair
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__memory/uninitialized_algorithms.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_UNINITIALIZED_ALGORITHMS_H
 #define _LIBCPP___MEMORY_UNINITIALIZED_ALGORITHMS_H
 
 #include <__config>
 #include <__memory/addressof.h>
 #include <__memory/construct_at.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
 #include <iterator>
-#include <utility>
+
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__memory/unique_ptr.h

 
 #include <__config>
 #include <__functional_base>
 #include <__functional/hash.h>
 #include <__functional/operations.h>
 #include <__memory/allocator_traits.h> // __pointer
 #include <__memory/compressed_pair.h>
 #include <__utility/forward.h>
+#include <__utility/move.h>
 #include <cstddef>
 #include <type_traits>
-#include <utility>
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
 #   include <__memory/auto_ptr.h>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

libcxx/include/__mutex_base

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MUTEX_BASE
 #define _LIBCPP___MUTEX_BASE
 
 #include <__config>
 #include <__threading_support>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <chrono>
 #include <system_error>
 #include <time.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

libcxx/include/__node_handle

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___NODE_HANDLE
 #define _LIBCPP___NODE_HANDLE
 
 #include <__config>
 #include <__debug>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <memory>
 #include <optional>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__ranges/access.h

 // -*- C++ -*-
 //===------------------------ __ranges/access.h ---------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP___RANGES_ACCESS_H
 #define _LIBCPP___RANGES_ACCESS_H
 
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/readable_traits.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__utility/__decay_copy.h>
+#include <__utility/as_const.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
+#include <__utility/move.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__ranges/concepts.h

 #include <__iterator/iter_move.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/data.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/size.h>
+#include <__utility/declval.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__ranges/drop_view.h

 #define _LIBCPP___RANGES_DROP_VIEW_H
 
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/concepts.h>
 #include <__ranges/access.h>
 #include <__ranges/view_interface.h>
 #include <__ranges/all.h>
+#include <__utility/declval.h>
+#include <__utility/move.h>
 #include <type_traits>
 #include <optional>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__ranges/ref_view.h

 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/empty.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.h>
+#include <__utility/declval.h>
+#include <__utility/forward.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__ranges/size.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP___RANGES_SIZE_H
 #define _LIBCPP___RANGES_SIZE_H
 
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__utility/__decay_copy.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

libcxx/include/__ranges/subrange.h

 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/advance.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.h>
+#include <__tuple>
+#include <__utility/move.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__ranges/view_interface.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP___RANGES_VIEW_INTERFACE_H
 #define _LIBCPP___RANGES_VIEW_INTERFACE_H
 
 #include <__config>
+#include <__debug>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/prev.h>
 #include <__memory/pointer_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/empty.h>
 #include <__ranges/enable_view.h>
+#include <__utility/declval.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__split_buffer

 // -*- C++ -*-
 #ifndef _LIBCPP_SPLIT_BUFFER
 #define _LIBCPP_SPLIT_BUFFER
 
 #include <__config>
+#include <__utility/move.h>
 #include <__utility/forward.h>
+#include <__utility/swap.h>
 #include <algorithm>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__tree

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TREE
 #define _LIBCPP___TREE
 
 #include <__config>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+#include <__utility/swap.h>
 #include <algorithm>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <stdexcept>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/__tuple

 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
 get(const tuple<_Tp...>&&) _NOEXCEPT;
 
 #endif // !defined(_LIBCPP_CXX03_LANG)
 
 // pair specializations
 
+template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS pair;
+
 template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};
 
 template <size_t _Ip, class _T1, class _T2>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 get(pair<_T1, _T2>&) _NOEXCEPT;
 
 template <size_t _Ip, class _T1, class _T2>

libcxx/include/__utility/integer_sequence.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___UTILITY_INTEGER_SEQUENCE_H
 #define _LIBCPP___UTILITY_INTEGER_SEQUENCE_H
 
 #include <__config>
+#include <__tuple>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/algorithm

 
 #include <__config>
 #include <__debug>
 #include <__bits> // __libcpp_clz
 #include <cstddef>
 #include <cstring>
 #include <functional>
 #include <initializer_list>
-#include <utility> // needed to provide swap_ranges.
 #include <memory>
 #include <iterator>
 #include <memory>
 #include <type_traits>
-#include <utility> // swap_ranges
 #include <version>
 
 #include <__algorithm/adjacent_find.h>
 #include <__algorithm/all_of.h>
 #include <__algorithm/any_of.h>
 #include <__algorithm/binary_search.h>
 #include <__algorithm/clamp.h>
 #include <__algorithm/comp.h>

libcxx/include/any

 
 } // namespace std
 
 */
 
 #include <__availability>
 #include <__config>
 #include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
 #include <cstdlib>
 #include <memory>
 #include <type_traits>
 #include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/array

 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__tuple>
+#include <__utility/integer_sequence.h>
+#include <__utility/move.h>
 #include <algorithm>
 #include <cstdlib> // for _LIBCPP_UNREACHABLE
 #include <iterator>
 #include <stdexcept>
 #include <type_traits>
-#include <utility>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/barrier

namespace std
   };
 
 }
 
 */
 
 #include <__availability>
 #include <__config>
+#include <__utility/move.h>
 #include <atomic>
 #ifndef _LIBCPP_HAS_NO_TREE_BARRIER
 # include <memory>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

libcxx/include/charconv

 
 } // namespace std
 
 */
 
 #include <__availability>
 #include <__config>
 #include <__errc>
+#include <__utility/declval.h>
 #include <__utility/to_underlying.h>
 #include <cmath> // for log2f
 #include <cstdint>
 #include <cstdlib> // for _LIBCPP_UNREACHABLE
 #include <cstring>
 #include <limits>
 #include <type_traits>
 

libcxx/include/concepts

template<class R, class T, class U>
     concept strict_weak_order = see below;
 }
 
 */
 
 #include <__config>
 #include <__functional/invoke.h>
 #include <__functional_base>
+#include <__utility/declval.h>
+#include <__utility/exchange.h>
 #include <type_traits>
-#include <utility>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

 concept floating_point = is_floating_point_v<_Tp>;
 
 // [concept.assignable]
 template<class _Lhs, class _Rhs>
 concept assignable_from =
   is_lvalue_reference_v<_Lhs> &&
   common_reference_with<__make_const_lvalue_ref<_Lhs>, __make_const_lvalue_ref<_Rhs>> &&
   requires (_Lhs __lhs, _Rhs&& __rhs) {
-    { __lhs = _VSTD::forward<_Rhs>(__rhs) } -> same_as<_Lhs>;
+    { __lhs = static_cast<_Rhs&&>(__rhs) } -> same_as<_Lhs>;
   };
 
 // [concept.destructible]
 
 template<class _Tp>
 concept destructible = is_nothrow_destructible_v<_Tp>;
 
 // [concept.constructible]
namespace ranges::__swap {
   void swap(_Tp&, _Tp&) = delete;
 
 
   // [1]
   template<class _Tp, class _Up>
   concept __unqualified_swappable_with =
     (__class_or_enum<remove_cvref_t<_Tp>> || __class_or_enum<remove_cvref_t<_Up>>) &&
     requires(_Tp&& __t, _Up&& __u) {
-      swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
+      swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u));
     };
 
   struct __fn;
 
   template<class _Tp, class _Up, size_t _Size>
   concept __swappable_arrays =
     !__unqualified_swappable_with<_Tp(&)[_Size], _Up(&)[_Size]> &&
     extent_v<_Tp> == extent_v<_Up> &&
     requires(_Tp(& __t)[_Size], _Up(& __u)[_Size], const __fn& __swap) {
       __swap(__t[0], __u[0]);
     };
 
   template<class _Tp>
   concept __exchangeable =
     !__unqualified_swappable_with<_Tp&, _Tp&> &&
     move_constructible<_Tp> &&
     assignable_from<_Tp&, _Tp>;
 
   struct __fn {
     // 2.1   `S` is `(void)swap(E1, E2)`* if `E1` or `E2` has class or enumeration type and...
     // *The name `swap` is used here unqualified.
     template<class _Tp, class _Up>
     requires __unqualified_swappable_with<_Tp, _Up>
     constexpr void operator()(_Tp&& __t, _Up&& __u) const
-    noexcept(noexcept(swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
+    noexcept(noexcept(swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u))))
     {
-      swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
+      swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u));
     }
 
     // 2.2   Otherwise, if `E1` and `E2` are lvalues of array types with equal extent and...
     template<class _Tp, class _Up, size_t _Size>
     requires __swappable_arrays<_Tp, _Up, _Size>
     constexpr void operator()(_Tp(& __t)[_Size], _Up(& __u)[_Size]) const
     noexcept(noexcept((*this)(*__t, *__u)))
     {
       // TODO(cjdb): replace with `ranges::swap_ranges`.
       for (size_t __i = 0; __i < _Size; ++__i) {
         (*this)(__t[__i], __u[__i]);
       }
     }
 
     // 2.3   Otherwise, if `E1` and `E2` are lvalues of the same type `T` that models...
     template<__exchangeable _Tp>
     constexpr void operator()(_Tp& __x, _Tp& __y) const
     noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_assignable_v<_Tp>)
     {
-      __y = _VSTD::exchange(__x, _VSTD::move(__y));
+      __y = _VSTD::exchange(__x, static_cast<_Tp&&>(__y));
     }
   };
 } // namespace ranges::__swap
 
 namespace ranges::inline __cpo {
   inline constexpr auto swap = __swap::__fn{};
 } // namespace ranges::__cpo
 
 template<class _Tp>
 concept swappable = requires(_Tp& __a, _Tp& __b) { ranges::swap(__a, __b); };
 
 template<class _Tp, class _Up>
 concept swappable_with =
   common_reference_with<_Tp, _Up> &&
   requires(_Tp&& __t, _Up&& __u) {
-    ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Tp>(__t));
-    ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Up>(__u));
-    ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
-    ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Tp>(__t));
+    ranges::swap(static_cast<_Tp&&>(__t), static_cast<_Tp&&>(__t));
+    ranges::swap(static_cast<_Up&&>(__u), static_cast<_Up&&>(__u));
+    ranges::swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u));
+    ranges::swap(static_cast<_Up&&>(__u), static_cast<_Tp&&>(__t));
   };
 
 // [concept.booleantestable]
 template<class _Tp>
 concept __boolean_testable_impl = convertible_to<_Tp, bool>;
 
 template<class _Tp>
 concept __boolean_testable = __boolean_testable_impl<_Tp> && requires(_Tp&& __t) {
-  { !std::forward<_Tp>(__t) } -> __boolean_testable_impl;
+  { !static_cast<_Tp&&>(__t) } -> __boolean_testable_impl;
 };
 
 // [concept.equalitycomparable]
 template<class _Tp, class _Up>
 concept __weakly_equality_comparable_with =
   requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
     { __t == __u } -> __boolean_testable;
     { __t != __u } -> __boolean_testable;

 concept semiregular = copyable<_Tp> && default_initializable<_Tp>;
 
 template<class _Tp>
 concept regular = semiregular<_Tp> && equality_comparable<_Tp>;
 
 // [concept.invocable]
 template<class _Fn, class... _Args>
 concept invocable = requires(_Fn&& __fn, _Args&&... __args) {
-  _VSTD::invoke(_VSTD::forward<_Fn>(__fn), _VSTD::forward<_Args>(__args)...); // not required to be equality preserving
+  _VSTD::invoke(static_cast<_Fn&&>(__fn), static_cast<_Args&&>(__args)...); // not required to be equality preserving
 };
 
 // [concept.regular.invocable]
 template<class _Fn, class... _Args>
 concept regular_invocable = invocable<_Fn, _Args...>;
 
 // [concept.predicate]
 template<class _Fn, class... _Args>

libcxx/include/condition_variable

 };
 
 }  // std
 
 */
 
 #include <__config>
 #include <__mutex_base>
+#include <__utility/move.h>
 #include <memory>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 

libcxx/include/deque

 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__split_buffer>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <algorithm>
 #include <compare>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <stdexcept>
 #include <type_traits>
 #include <version>

libcxx/include/experimental/memory_resource

 #include <experimental/__config>
 #include <experimental/__memory>
 #include <limits>
 #include <memory>
 #include <new>
 #include <stdexcept>
 #include <__tuple>
 #include <type_traits>
-#include <utility>
 #include <cstddef>
 #include <cstdlib>
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

libcxx/include/experimental/propagate_const

 #include <experimental/__config>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 11
 
 #include <type_traits>
-#include <utility>
 #include <functional>
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS_V2
 
 
 template <class _Tp>
 class propagate_const;
 

libcxx/include/ext/hash_map

operator!=(const hash_multimap<Key, T, Hash, Pred, Alloc>& x,
                const hash_multimap<Key, T, Hash, Pred, Alloc>& y);
 
 }  // __gnu_cxx
 
 */
 
 #include <__config>
 #include <__hash_table>
+#include <__utility/pair.h>
 #include <functional>
 #include <stdexcept>
 #include <type_traits>
 #include <ext/__hash>
 
 #if defined(__DEPRECATED) && __DEPRECATED
 #if defined(_LIBCPP_WARNING)
     _LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>")

libcxx/include/ext/hash_set

template <class Value, class Hash, class Pred, class Alloc>
     operator!=(const hash_multiset<Value, Hash, Pred, Alloc>& x,
                const hash_multiset<Value, Hash, Pred, Alloc>& y);
 }  // __gnu_cxx
 
 */
 
 #include <__config>
 #include <__hash_table>
+#include <__utility/pair.h>
 #include <functional>
 #include <ext/__hash>
 
 #if defined(__DEPRECATED) && __DEPRECATED
 #if defined(_LIBCPP_WARNING)
     _LIBCPP_WARNING("Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>")
 #else
 #   warning Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>

libcxx/include/filesystem

 } }  // namespaces std::filesystem
 
 */
 
 #include <__availability>
 #include <__config>
 #include <__debug>
 #include <__utility/forward.h>
+#include <__utility/move.h>
 #include <chrono>
 #include <compare>
 #include <cstddef>
 #include <cstdlib>
 #include <iosfwd>
 #include <iterator>
 #include <memory>
 #include <stack>
 #include <string>
 #include <string_view>
 #include <system_error>
-#include <utility>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 # include <locale>
 # include <iomanip> // for quoted
 #endif
 
 #if defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)

libcxx/include/forward_list

template <class T, class Allocator, class Predicate>
     erase_if(forward_list<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
 #include <__config>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <algorithm>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/fstream

 }  // std
 
 */
 
 #include <__availability>
 #include <__config>
 #include <__debug>
 #include <__locale>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <cstdio>
 #include <cstdlib>
 #include <istream>
 #include <ostream>
 
 #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 #   include <filesystem>
 #endif

libcxx/include/functional

 #include <__functional/unwrap_ref.h>
 #include <__utility/forward.h>
 #include <concepts>
 #include <exception>
 #include <memory>
 #include <tuple>
 #include <type_traits>
 #include <typeinfo>
-#include <utility>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_FUNCTIONAL

libcxx/include/future

 
 #include <__availability>
 #include <__config>
 #include <__debug>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <__utility/__decay_copy.h>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <chrono>
 #include <exception>
 #include <memory>
 #include <mutex>
 #include <system_error>
 #include <thread>
+#include <type_traits> // __invoke
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS
 #error <future> is not supported on this single threaded system
 #else // !_LIBCPP_HAS_NO_THREADS

libcxx/include/ios

 storage-class-specifier const error_category& iostream_category() noexcept;
 
 }  // std
 
 */
 
 #include <__config>
 #include <__locale>
+#include <__utility/swap.h>
 #include <iosfwd>
 #include <system_error>
 
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #include <atomic>     // for __xindex_
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/istream

 template <class Stream, class T>
   Stream&& operator>>(Stream&& is, T&& x);
 
 }  // std
 
 */
 
 #include <__config>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <ostream>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/iterator

 #include <__iterator/ostreambuf_iterator.h>
 #include <__iterator/prev.h>
 #include <__iterator/projected.h>
 #include <__iterator/readable_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/addressof.h>
 #include <__memory/pointer_traits.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
+#include <__utility/move.h>
 #include <compare>
 #include <concepts> // Mandated by the Standard.
 #include <cstddef>
 #include <initializer_list>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/list

 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <algorithm>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <type_traits>
 #include <version>
 

libcxx/include/locale

 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__locale>
+#include <__utility/move.h>
 #include <algorithm>
 #ifndef __APPLE__
 # include <cstdarg>
 #endif
 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
 #include <ios>

libcxx/include/map

 */
 
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+#include <__utility/piecewise_construct.h>
+#include <__utility/swap.h>
 #include <compare>
 #include <functional>
 #include <initializer_list>
 #include <iterator> // __libcpp_erase_if_container
 #include <memory>
 #include <type_traits>
-#include <utility>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/memory

 #include <__memory/pointer_safety.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/raw_storage_iterator.h>
 #include <__memory/shared_ptr.h>
 #include <__memory/temporary_buffer.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__memory/unique_ptr.h>
 #include <__memory/uses_allocator.h>
+#include <__utility/declval.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <compare>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <iosfwd>
 #include <iterator>
 #include <new>
 #include <stdexcept>
 #include <tuple>
 #include <type_traits>
 #include <typeinfo>
-#include <utility>
 #include <version>
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
 #   include <__memory/auto_ptr.h>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/module.modulemap

module __utility {
       module as_const            { header "__utility/as_const.h"            }
       module cmp                 { header "__utility/cmp.h"                 }
       module declval             { header "__utility/declval.h"             }
       module exchange            { header "__utility/exchange.h"            }
       module forward             { header "__utility/forward.h"             }
       module in_place            { header "__utility/in_place.h"            }
       module integer_sequence    { header "__utility/integer_sequence.h"    }
       module move                { header "__utility/move.h"                }
-      module pair                { header "__utility/pair.h"                }
+      module pair {
+        export __tuple
+        header "__utility/pair.h"
+      }
       module piecewise_construct { header "__utility/piecewise_construct.h" }
       module rel_ops             { header "__utility/rel_ops.h"             }
       module swap                { header "__utility/swap.h"                }
       module to_underlying       { header "__utility/to_underlying.h"       }
     }
   }
   module valarray {
     header "valarray"

libcxx/include/mutex

 }  // std
 
 */
 
 #include <__config>
 #include <__mutex_base>
 #include <__threading_support>
 #include <__utility/forward.h>
+#include <__utility/move.h>
 #include <cstdint>
 #include <functional>
 #include <memory>
 #ifndef _LIBCPP_CXX03_LANG
 # include <tuple>
 #endif
+#include <type_traits> // __invoke
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/numeric

template<class T>
     constexpr T* midpoint(T* a, T* b);        // C++20
 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
+#include <__utility/move.h>
 #include <cmath> // for isnormal
 #include <functional>
 #include <iterator>
 #include <limits> // for numeric_limits
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/optional

 } // namespace std
 
 */
 
 #include <__availability>
 #include <__config>
 #include <__debug>
 #include <__functional_base>
+#include <__utility/declval.h>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <compare>
 #include <functional>
 #include <initializer_list>
 #include <new>
 #include <stdexcept>
 #include <type_traits>
-#include <utility>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/ostream

 template <class Stream, class T>
   Stream&& operator<<(Stream&& os, const T& x);
 
 }  // std
 
 */
 
 #include <__config>
+#include <__utility/declval.h>
+#include <__utility/move.h>
 #include <bitset>
 #include <ios>
 #include <iterator>
 #include <locale>
 #include <streambuf>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/queue

 
 }  // std
 
 */
 
 #include <__config>
 #include <__memory/uses_allocator.h>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <algorithm>
 #include <compare>
 #include <deque>
 #include <functional>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/random

operator>>(basic_istream<charT, traits>& is,
                piecewise_linear_distribution& x);
 };
 
 } // std
 */
 
 #include <__config>
 #include <__random/uniform_int_distribution.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <algorithm>
 #include <cmath>
 #include <concepts>
 #include <cstddef>
 #include <cstdint>
 #include <initializer_list>
 #include <iosfwd>
 #include <limits>

libcxx/include/regex

 
 } // std
 */
 
 #include <__config>
 #include <__debug>
 #include <__iterator/wrap_iter.h>
 #include <__locale>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+#include <__utility/swap.h>
 #include <compare>
 #include <deque>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <stdexcept>
 #include <string>
-#include <utility>
 #include <vector>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/scoped_allocator

template <class OuterA1, class OuterA2, class... InnerAllocs>
     operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
                const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
 
 }  // std
 
 */
 
 #include <__config>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+#include <__utility/piecewise_construct.h>
 #include <memory>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/set

 */
 
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
 #include <compare>
 #include <functional>
 #include <initializer_list>
 #include <iterator> // __libcpp_erase_if_container
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/span

 
 */
 
 #include <__config>
 #include <__debug>
 #include <__iterator/wrap_iter.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
+#include <__utility/declval.h>
 #include <array>        // for array
 #include <cstddef>      // for byte
 #include <iterator>     // for iterators
 #include <limits>
 #include <type_traits>  // for remove_cv, etc
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/sstream

 typedef basic_stringstream<char>    stringstream;
 typedef basic_stringstream<wchar_t> wstringstream;
 
 }  // std
 
 */
 
 #include <__config>
+#include <__utility/move.h>
 #include <istream>
 #include <ostream>
 #include <string>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

libcxx/include/stack

 
 }  // std
 
 */
 
 #include <__config>
 #include <__memory/uses_allocator.h>
 #include <__utility/forward.h>
+#include <__utility/move.h>
 #include <deque>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/string

 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__functional_base>
 #include <__iterator/wrap_iter.h>
+#include <__utility/move.h>
 #include <algorithm>
 #include <compare>
 #include <cstdio>  // EOF
 #include <cstring>
 #include <cwchar>
 #include <initializer_list>
 #include <iosfwd>
 #include <iterator>
 #include <memory>
 #include <stdexcept>
 #include <string_view>
 #include <type_traits>
-#include <utility>
 #include <version>
 
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 # include <cstdint>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/strstream

private:
     strstreambuf sb; // exposition only
 };
 
 }  // std
 
 */
 
 #include <__config>
+#include <__utility/move.h>
 #include <istream>
 #include <ostream>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/thread

 
 #include <__config>
 #include <__debug>
 #include <__functional_base>
 #include <__mutex_base>
 #include <__threading_support>
 #include <__utility/__decay_copy.h>
 #include <__utility/forward.h>
+#include <__utility/move.h>
 #include <chrono>
 #include <cstddef>
 #include <functional>
 #include <iosfwd>
 #include <memory>
 #include <system_error>
 #include <tuple>
 #include <type_traits>

libcxx/include/tuple

 */
 
 #include <__config>
 #include <__functional/unwrap_ref.h>
 #include <__functional_base>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <__tuple>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
+#include <__utility/piecewise_construct.h>
 #include <compare>
 #include <cstddef>
 #include <type_traits>
-#include <utility>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/type_traits

template <class...>
       template<class B> struct negation;                                 // C++17
       template<class B>
         inline constexpr bool negation_v = negation<B>::value;           // C++17
 
 }
 
 */
 #include <__config>
+#include <__utility/declval.h>
 #include <cstddef>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_rvalue_reference
 {typedef _LIBCPP_NODEBUG_TYPE  typename __add_rvalue_reference_impl<_Tp>::type type;};
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
 #endif
 
-// Suppress deprecation notice for volatile-qualified return type resulting
-// from volatile-qualified types _Tp.
-_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;
-
 // __uncvref
 
 template <class _Tp>
 struct __uncvref  {
     typedef _LIBCPP_NODEBUG_TYPE typename remove_cv<typename remove_reference<_Tp>::type>::type type;
 };
 
 template <class _Tp>

libcxx/include/unordered_map

 */
 
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__hash_table>
 #include <__node_handle>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+#include <__utility/piecewise_construct.h>
 #include <compare>
 #include <functional>
 #include <iterator> // __libcpp_erase_if_container
 #include <stdexcept>
 #include <tuple>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/unordered_set

 
 */
 
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__hash_table>
 #include <__node_handle>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
+#include <__utility/pair.h>
+#include <__utility/move.h>
 #include <compare>
 #include <functional>
 #include <iterator> // __libcpp_erase_if_container
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

libcxx/include/utility

 template <class T>
     constexpr underlying_type_t<T> to_underlying( T value ) noexcept; // C++2b
 
 }  // std
 
 */
 
 #include <__config>
-#include <__debug>
-#include <__tuple>
 #include <__utility/as_const.h>
 #include <__utility/cmp.h>
 #include <__utility/declval.h>
 #include <__utility/exchange.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/rel_ops.h>
 #include <__utility/swap.h>
 #include <__utility/to_underlying.h>
-#include <compare>
-#include <initializer_list>
+#include <compare>            // listed in [utility.syn]
+#include <initializer_list>   // listed in [utility.syn]
 #include <version>
 
 #endif // _LIBCPP_UTILITY

libcxx/include/variant

namespace std {
   template <> struct hash<monostate>;
 
 } // namespace std
 
 */
 
 #include <__availability>
 #include <__config>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/integer_sequence.h>
+#include <__utility/move.h>
 #include <__tuple>
 #include <array>
 #include <compare>
 #include <exception>
 #include <functional>
 #include <initializer_list>
 #include <limits>
 #include <new>
 #include <tuple>
 #include <type_traits>
-#include <utility>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/vector

 
 #include <__config>
 #include <__bit_reference>
 #include <__debug>
 #include <__functional_base>
 #include <__iterator/wrap_iter.h>
 #include <__split_buffer>
 #include <__utility/forward.h>
+#include <__utility/move.h>
 #include <algorithm>
 #include <climits>
 #include <compare>
 #include <cstring>
 #include <initializer_list>
 #include <iosfwd> // for forward declaration of vector
 #include <limits>
 #include <memory>

libcxx/test/std/ranges/range.access/range.prim/empty.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
 // std::ranges::empty
 
 #include <ranges>
 
 #include <cassert>
+#include <utility>
+
 #include "test_macros.h"
 #include "test_iterators.h"
 
 using RangeEmptyT = decltype(std::ranges::empty);
 using RangeSizeT = decltype(std::ranges::size);
 
 static_assert(!std::is_invocable_v<RangeEmptyT, int[]>);
 static_assert(!std::is_invocable_v<RangeEmptyT, int(&)[]>);

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.fail.cpp

 // template<class T, class U>
 //   constexpr bool cmp_greater_equal(T t, U u) noexcept; // C++20
 
 // template<class R, class T>
 //   constexpr bool in_range(T t) noexcept;      // C++20
 
 #include <utility>
 
+#include <cstddef>
+
 #include "test_macros.h"
 
 struct NonEmptyT {
   int val;
   NonEmptyT() : val(0) {}
   NonEmptyT(int val) : val(val) {}
   operator int&() { return val; }
   operator int() const { return val; }
int main() {
   test<char>();
   test<wchar_t>();
   test<float>();
   test<double>();
   test<long double>();
   test<std::byte>();
   test<NonEmptyT>();
   test<ColorT>();
-  test<nullptr_t>();
+  test<std::nullptr_t>();
   test<EmptyT>();
 
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
   test_char8t<char8_t>();
 #endif // _LIBCPP_HAS_NO_CHAR8_T
 
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
   test_uchars<char16_t>();
   test_uchars<char32_t>();
 #endif // _LIBCPP_HAS_NO_UNICODE_CHARS
 
   return 0;
 }