File iwyu_include_picker.patch of Package include-what-you-use

diff --git a/iwyu_include_picker.cc b/iwyu_include_picker.cc
index cd69da4..caded48 100644
--- a/iwyu_include_picker.cc
+++ b/iwyu_include_picker.cc
@@ -78,14 +78,14 @@ struct IncludeMapEntry {      // A POD so we can make the input static
 namespace {
 
 // Listed below are all IWYU's native symbol and include mappings,
-// loosely based on GCC 4.4's libc and libstdc++.
+// loosely based on GCC 12's libc and libstdc++.
 
 // Symbol -> include mappings for GNU libc
 const IncludeMapEntry libc_symbol_map[] = {
   // For library symbols that can be defined in more than one header
   // file, maps from symbol-name to legitimate header files.
   // This list was generated via
-  // grep -R '__.*_defined' /usr/include | perl -nle 'm,/usr/include/([^:]*):#\s*\S+ __(.*)_defined, and print qq@    { "$2", kPublic, "<$1>", kPublic },@' | sort -u
+  // grep -R '__.*_defined' /usr/include | perl -nle 'm,/usr/include/([^:]*):#\s*\S+ __(.*)_defined, and print qq@  { "$2", kPrivate, "<$1>", kPublic },@' | sort -u
   // I ignored all entries that only appeared once on the list (eg uint32_t).
   // I then added in NULL, which according to [diff.null] C.2.2.3, can
   // be defined in <clocale>, <cstddef>, <cstdio>, <cstdlib>,
@@ -265,6 +265,23 @@ const IncludeMapEntry stdlib_cxx_symbol_map[] = {
   { "std::size_t", kPrivate, "<ctime>", kPublic },
   { "std::size_t", kPrivate, "<cuchar>", kPublic },
   { "std::size_t", kPrivate, "<cwchar>", kPublic },
+
+  { "std::pair", kPrivate, "<map>", kPublic },
+  { "std::pair", kPrivate, "<multimap>", kPublic },
+  { "std::pair", kPrivate, "<utility>", kPublic },
+
+  { "std::istringstream", kPrivate, "<sstream>", kPublic },
+  { "std::ostringstream", kPrivate, "<sstream>", kPublic },
+  { "std::stringstream", kPrivate, "<sstream>", kPublic },
+  { "std::wistringstream", kPrivate, "<sstream>", kPublic },
+  { "std::wostringstream", kPrivate, "<sstream>", kPublic },
+  { "std::wstringstream", kPrivate, "<sstream>", kPublic },
+  { "std::ifstream", kPrivate, "<fstream>", kPublic },
+  { "std::ofstream", kPrivate, "<fstream>", kPublic },
+  { "std::fstream", kPrivate, "<fstream>", kPublic },
+  { "std::wifstream", kPrivate, "<fstream>", kPublic },
+  { "std::wofstream", kPrivate, "<fstream>", kPublic },
+  { "std::wfstream", kPrivate, "<fstream>", kPublic },
 };
 
 // Symbol -> include mappings for GNU libstdc++
@@ -275,51 +292,63 @@ const IncludeMapEntry libstdcpp_symbol_map[] = {
 
 const IncludeMapEntry libc_include_map[] = {
   // Private -> public include mappings for GNU libc
-  // ( cd /usr/include && grep '^ *# *include' {sys/,net/,}* | perl -nle 'm/^([^:]+).*<([^>]+)>/ && print qq@    { "<$2>", kPrivate, "<$1>", kPublic },@' | grep bits/ | sort )
+  // ( cd /usr/include && grep '^ *# *include' {sys/,net/,}* | perl -nle 'm/^([^:]+).*<([^>]+)>/ && print qq@  { "<$2>", kPrivate, "<$1>", kPublic },@' | grep bits/ | sort )
   // When I saw more than one mapping for these, I typically picked
   // what I thought was the "best" one.
   { "<bits/a.out.h>", kPrivate, "<a.out.h>", kPublic },
-  { "<bits/auxv.h>", kPrivate, "<sys/auxv.h>", kPublic },
+  { "<bits/argp-ldbl.h>", kPrivate, "<argp.h>", kPublic },
   { "<bits/byteswap.h>", kPrivate, "<byteswap.h>", kPublic },
+  { "<bits/byteswap.h>", kPrivate, "<endian.h>", kPublic },
   { "<bits/cmathcalls.h>", kPrivate, "<complex.h>", kPublic },
   { "<bits/confname.h>", kPrivate, "<unistd.h>", kPublic },
+  { "<bits/cpu-set.h>", kPrivate, "<sched.h>", kPublic },
+  { "<bits/dirent_ext.h>", kPrivate, "<dirent.h>", kPublic },
   { "<bits/dirent.h>", kPrivate, "<dirent.h>", kPublic },
   { "<bits/dlfcn.h>", kPrivate, "<dlfcn.h>", kPublic },
+  { "<bits/dl_find_object.h>", kPrivate, "<dlfcn.h>", kPublic },
   { "<bits/elfclass.h>", kPrivate, "<link.h>", kPublic },
   { "<bits/endian.h>", kPrivate, "<endian.h>", kPublic },
   { "<bits/environments.h>", kPrivate, "<unistd.h>", kPublic },
   { "<bits/epoll.h>", kPrivate, "<sys/epoll.h>", kPublic },
+  { "<bits/err-ldbl.h>", kPrivate, "<err.h>", kPublic },
   { "<bits/errno.h>", kPrivate, "<errno.h>", kPublic },
   { "<bits/error.h>", kPrivate, "<error.h>", kPublic },
+  { "<bits/error-ldbl.h>", kPrivate, "<error.h>", kPublic },
   { "<bits/eventfd.h>", kPrivate, "<sys/eventfd.h>", kPublic },
   { "<bits/fcntl.h>", kPrivate, "<fcntl.h>", kPublic },
   { "<bits/fcntl2.h>", kPrivate, "<fcntl.h>", kPublic },
   { "<bits/fenv.h>", kPrivate, "<fenv.h>", kPublic },
-  { "<bits/fenvinline.h>", kPrivate, "<fenv.h>", kPublic },
-  { "<bits/huge_val.h>", kPrivate, "<math.h>", kPublic },
-  { "<bits/huge_valf.h>", kPrivate, "<math.h>", kPublic },
-  { "<bits/huge_vall.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/floatn.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/flt-eval-method.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/fp-fast.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/fp-logb.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/getopt_core.h>", kPrivate, "<getopt.h>", kPublic },
+  { "<bits/getopt_ext.h>", kPrivate, "<getopt.h>", kPublic },
+  { "<bits/getopt_posix.h>", kPrivate, "<stdio.h>", kPublic },
+  { "<bits/getopt_posix.h>", kPrivate, "<unistd.h>", kPublic },
   { "<bits/hwcap.h>", kPrivate, "<sys/auxv.h>", kPublic },
-  { "<bits/inf.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/indirect-return.h>", kPrivate, "<ucontext.h>", kPublic },
   { "<bits/inotify.h>", kPrivate, "<sys/inotify.h>", kPublic },
   { "<bits/ioctl-types.h>", kPrivate, "<sys/ioctl.h>", kPublic },
   { "<bits/ioctls.h>", kPrivate, "<sys/ioctl.h>", kPublic },
   { "<bits/ipc.h>", kPrivate, "<sys/ipc.h>", kPublic },
   { "<bits/ipctypes.h>", kPrivate, "<sys/ipc.h>", kPublic },
-  { "<bits/libio-ldbl.h>", kPrivate, "<libio.h>", kPublic },
+  { "<bits/iscanonical.h>", kPrivate, "<math.h>", kPublic },
   { "<bits/link.h>", kPrivate, "<link.h>", kPublic },
+  { "<bits/link_lavcurrent.h>", kPrivate, "<link.h>", kPublic },
   { "<bits/locale.h>", kPrivate, "<locale.h>", kPublic },
-  { "<bits/math-finite.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/long-double.h>", kPrivate, "<sys/cdefs.h>", kPublic },
+  { "<bits/mathcalls-helper-functions.h>", kPrivate, "<math.h>", kPublic },
   { "<bits/mathcalls.h>", kPrivate, "<math.h>", kPublic },
-  { "<bits/mathdef.h>", kPrivate, "<math.h>", kPublic },
-  { "<bits/mathinline.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/mathcalls-narrow.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/mathdef.h>", kPrivate, "<complex.h>", kPublic },
+  { "<bits/math-vector.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/mman_ext.h>", kPrivate, "<sys/mman.h>", kPublic },
   { "<bits/mman.h>", kPrivate, "<sys/mman.h>", kPublic },
-  { "<bits/mman-shared.h>", kPrivate, "<sys/mman.h>", kPublic },
   { "<bits/monetary-ldbl.h>", kPrivate, "<monetary.h>", kPublic },
   { "<bits/mqueue.h>", kPrivate, "<mqueue.h>", kPublic },
   { "<bits/mqueue2.h>", kPrivate, "<mqueue.h>", kPublic },
   { "<bits/msq.h>", kPrivate, "<sys/msg.h>", kPublic },
-  { "<bits/nan.h>", kPrivate, "<math.h>", kPublic },
   { "<bits/netdb.h>", kPrivate, "<netdb.h>", kPublic },
   { "<bits/param.h>", kPrivate, "<sys/param.h>", kPublic },
   { "<bits/poll.h>", kPrivate, "<sys/poll.h>", kPrivate },
@@ -328,66 +357,107 @@ const IncludeMapEntry libc_include_map[] = {
   { "<bits/posix2_lim.h>", kPrivate, "<limits.h>", kPublic },
   { "<bits/posix_opt.h>", kPrivate, "<unistd.h>", kPublic },
   { "<bits/printf-ldbl.h>", kPrivate, "<printf.h>", kPublic },
+  { "<bits/procfs-extra.h>", kPrivate, "<sys/procfs.h>", kPublic },
+  { "<bits/procfs.h>", kPrivate, "<sys/procfs.h>", kPublic },
+  { "<bits/procfs-id.h>", kPrivate, "<sys/procfs.h>", kPublic },
+  { "<bits/procfs-prregset.h>", kPrivate, "<sys/procfs.h>", kPublic },
+  { "<bits/pthread_stack_min-dynamic.h>", kPrivate, "<pthread.h>", kPublic },
   { "<bits/pthreadtypes.h>", kPrivate, "<pthread.h>", kPublic },
+  { "<bits/ptrace-shared.h>", kPrivate, "<sys/ptrace.h>", kPublic },
   { "<bits/resource.h>", kPrivate, "<sys/resource.h>", kPublic },
+  { "<bits/rseq.h>", kPrivate, "<sys/rseq.h>", kPublic },
   { "<bits/sched.h>", kPrivate, "<sched.h>", kPublic },
   { "<bits/select.h>", kPrivate, "<sys/select.h>", kPublic },
   { "<bits/select2.h>", kPrivate, "<sys/select.h>", kPublic },
-  { "<bits/sem.h>", kPrivate, "<sys/sem.h>", kPublic },
   { "<bits/semaphore.h>", kPrivate, "<semaphore.h>", kPublic },
+  { "<bits/sem.h>", kPrivate, "<sys/sem.h>", kPublic },
   { "<bits/setjmp.h>", kPrivate, "<setjmp.h>", kPublic },
   { "<bits/setjmp2.h>", kPrivate, "<setjmp.h>", kPublic },
   { "<bits/shm.h>", kPrivate, "<sys/shm.h>", kPublic },
   { "<bits/sigaction.h>", kPrivate, "<signal.h>", kPublic },
   { "<bits/sigcontext.h>", kPrivate, "<signal.h>", kPublic },
-  { "<bits/siginfo.h>", kPrivate, "<signal.h>", kPublic },
-  { "<bits/signum.h>", kPrivate, "<signal.h>", kPublic },
-  { "<bits/sigset.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/sigevent-consts.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/siginfo-consts.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/signal_ext.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/signalfd.h>", kPrivate, "<sys/signalfd.h>", kPublic },
+  { "<bits/signum-generic.h>", kPrivate, "<signal.h>", kPublic },
   { "<bits/sigstack.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/sigstksz.h>", kPrivate, "<signal.h>", kPublic },
   { "<bits/sigthread.h>", kPrivate, "<signal.h>", kPublic },
   { "<bits/sockaddr.h>", kPrivate, "<sys/un.h>", kPublic },
   { "<bits/socket.h>", kPrivate, "<sys/socket.h>", kPublic },
   { "<bits/socket2.h>", kPrivate, "<sys/socket.h>", kPublic },
-  { "<bits/socket_type.h>", kPrivate, "<sys/socket.h>", kPublic },
+  { "<bits/ss_flags.h>", kPrivate, "<signal.h>", kPublic },
   { "<bits/stab.def>", kPrivate, "<stab.h>", kPublic },
   { "<bits/stat.h>", kPrivate, "<sys/stat.h>", kPublic },
   { "<bits/statfs.h>", kPrivate, "<sys/statfs.h>", kPublic },
   { "<bits/statvfs.h>", kPrivate, "<sys/statvfs.h>", kPublic },
-  { "<bits/stdio-ldbl.h>", kPrivate, "<stdio.h>", kPublic },
-  { "<bits/stdio-lock.h>", kPrivate, "<libio.h>", kPublic },
+  { "<bits/statx.h>", kPrivate, "<sys/stat.h>", kPublic },
+  { "<bits/stdint-intn.h>", kPrivate, "<stdint.h>", kPublic },
+  { "<bits/stdint-uintn.h>", kPrivate, "<stdint.h>", kPublic },
   { "<bits/stdio.h>", kPrivate, "<stdio.h>", kPublic },
   { "<bits/stdio2.h>", kPrivate, "<stdio.h>", kPublic },
+  { "<bits/stdio2-decl.h>", kPrivate, "<stdio.h>", kPublic },
+  { "<bits/stdio-ldbl.h>", kPrivate, "<stdio.h>", kPublic },
   { "<bits/stdio_lim.h>", kPrivate, "<stdio.h>", kPublic },
   { "<bits/stdlib-bsearch.h>", kPrivate, "<stdlib.h>", kPublic },
   { "<bits/stdlib-float.h>", kPrivate, "<stdlib.h>", kPublic },
-  { "<bits/stdlib-ldbl.h>", kPrivate, "<stdlib.h>", kPublic },
   { "<bits/stdlib.h>", kPrivate, "<stdlib.h>", kPublic },
-  { "<bits/string.h>", kPrivate, "<string.h>", kPublic },
-  { "<bits/string2.h>", kPrivate, "<string.h>", kPublic },
-  { "<bits/string3.h>", kPrivate, "<string.h>", kPublic },
-  { "<bits/stropts.h>", kPrivate, "<stropts.h>", kPublic },
-  { "<bits/struct_stat.h>", kPrivate, "<sys/stat.h>", kPublic },
-  { "<bits/struct_stat.h>", kPrivate, "<ftw.h>", kPublic },
-  { "<bits/sys_errlist.h>", kPrivate, "<stdio.h>", kPublic },
+  { "<bits/stdlib-ldbl.h>", kPrivate, "<stdlib.h>", kPublic },
+  { "<bits/string_fortified.h>", kPrivate, "<string.h>", kPublic },
+  { "<bits/strings_fortified.h>", kPrivate, "<strings.h>", kPublic },
   { "<bits/syscall.h>", kPrivate, "<sys/syscall.h>", kPublic },
-  { "<bits/sysctl.h>", kPrivate, "<sys/sysctl.h>", kPublic },
+  { "<bits/syslog.h>", kPrivate, "<sys/syslog.h>", kPrivate },
   { "<bits/syslog-ldbl.h>", kPrivate, "<sys/syslog.h>", kPrivate },
   { "<bits/syslog-path.h>", kPrivate, "<sys/syslog.h>", kPrivate },
-  { "<bits/syslog.h>", kPrivate, "<sys/syslog.h>", kPrivate },
-  { "<bits/termios-c_lflag.h>", kPrivate, "<termios.h>", kPublic },
-  { "<bits/termios-struct.h>", kPrivate, "<termios.h>", kPublic },
-  { "<bits/termios-tcflow.h>", kPrivate, "<termios.h>", kPublic },
+  { "<bits/sysmacros.h>", kPrivate, "<sys/sysmacros.h>", kPublic },
   { "<bits/termios.h>", kPrivate, "<termios.h>", kPublic },
+  { "<bits/thread-shared-types.h>", kPrivate, "<threads.h>", kPublic },
   { "<bits/time.h>", kPrivate, "<time.h>", kPublic },
-  { "<bits/time.h>", kPrivate, "<sys/time.h>", kPublic },
   { "<bits/timerfd.h>", kPrivate, "<sys/timerfd.h>", kPublic },
+  { "<bits/timesize.h>", kPrivate, "<features-time64.h>", kPublic },
   { "<bits/timex.h>", kPrivate, "<sys/timex.h>", kPublic },
+  { "<bits/types/clockid_t.h>", kPrivate, "<sys/types.h>", kPublic },
+  { "<bits/types/clock_t.h>", kPrivate, "<time.h>", kPublic },
+  { "<bits/types/cookie_io_functions_t.h>", kPrivate, "<stdio.h>", kPublic },
+  { "<bits/types/error_t.h>", kPrivate, "<errno.h>", kPublic },
+  { "<bits/types/FILE.h>", kPrivate, "<stdio.h>", kPublic },
+  { "<bits/types/__FILE.h>", kPrivate, "<stdio.h>", kPublic },
+  { "<bits/types/__fpos64_t.h>", kPrivate, "<stdio.h>", kPublic },
+  { "<bits/types/__fpos_t.h>", kPrivate, "<stdio.h>", kPublic },
   { "<bits/types.h>", kPrivate, "<sys/types.h>", kPublic },
+  { "<bits/types/locale_t.h>", kPrivate, "<locale.h>", kPublic },
+  { "<bits/types/__mbstate_t.h>", kPrivate, "<gconv.h>", kPublic },
+  { "<bits/types/mbstate_t.h>", kPrivate, "<uchar.h>", kPublic },
+  { "<bits/types/res_state.h>", kPrivate, "<resolv.h>", kPublic },
+  { "<bits/types/sig_atomic_t.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/types/sigevent_t.h>", kPrivate, "<signal.h>", kPublic },
   { "<bits/types/siginfo_t.h>", kPrivate, "<signal.h>", kPublic },
-  { "<bits/types/siginfo_t.h>", kPrivate, "<sys/wait.h>", kPublic },
-  { "<bits/uio.h>", kPrivate, "<sys/uio.h>", kPublic },
+  { "<bits/types/sigset_t.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/types/sigval_t.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/types/__sigset_t.h>", kPrivate, "<sys/poll.h>", kPrivate },
+  { "<bits/types/stack_t.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/types/struct_FILE.h>", kPrivate, "<stdio.h>", kPublic },
+  { "<bits/types/struct_iovec.h>", kPrivate, "<sys/socket.h>", kPublic },
+  { "<bits/types/struct_iovec.h>", kPrivate, "<sys/uio.h>", kPublic },
+  { "<bits/types/struct_itimerspec.h>", kPrivate, "<sys/timerfd.h>", kPublic },
+  { "<bits/types/struct___jmp_buf_tag.h>", kPrivate, "<setjmp.h>", kPublic },
+  { "<bits/types/struct_osockaddr.h>", kPrivate, "<sys/socket.h>", kPublic },
+  { "<bits/types/struct_rusage.h>", kPrivate, "<sys/wait.h>", kPublic },
+  { "<bits/types/struct_sigstack.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/types/struct_timeb.h>", kPrivate, "<sys/timeb.h>", kPublic },
+  { "<bits/types/struct_timespec.h>", kPrivate, "<time.h>", kPublic },
+  { "<bits/types/struct_timeval.h>", kPrivate, "<sys/time.h>", kPublic },
+  { "<bits/types/struct_tm.h>", kPrivate, "<time.h>", kPublic },
+  { "<bits/types/timer_t.h>", kPrivate, "<sys/types.h>", kPublic },
+  { "<bits/types/wint_t.h>", kPrivate, "<gconv.h>", kPublic },
+  { "<bits/types/wint_t.h>", kPrivate, "<wchar.h>", kPublic },
+  { "<bits/types/wint_t.h>", kPrivate, "<wctype.h>", kPublic },
+  { "<bits/uintn-identity.h>", kPrivate, "<endian.h>", kPublic },
+  { "<bits/uio-ext.h>", kPrivate, "<sys/uio.h>", kPublic },
+  { "<bits/uio_lim.h>", kPrivate, "<sys/uio.h>", kPublic },
+  { "<bits/unistd_ext.h>", kPrivate, "<unistd.h>", kPublic },
   { "<bits/unistd.h>", kPrivate, "<unistd.h>", kPublic },
-  { "<bits/ustat.h>", kPrivate, "<sys/ustat.h>", kPrivate },
   { "<bits/utmp.h>", kPrivate, "<utmp.h>", kPublic },
   { "<bits/utmpx.h>", kPrivate, "<utmpx.h>", kPublic },
   { "<bits/utsname.h>", kPrivate, "<sys/utsname.h>", kPublic },
@@ -396,61 +466,155 @@ const IncludeMapEntry libc_include_map[] = {
   { "<bits/wchar-ldbl.h>", kPrivate, "<wchar.h>", kPublic },
   { "<bits/wchar.h>", kPrivate, "<wchar.h>", kPublic },
   { "<bits/wchar2.h>", kPrivate, "<wchar.h>", kPublic },
+  { "<bits/wctype-wchar.h>", kPrivate, "<wchar.h>", kPublic },
+  { "<bits/wctype-wchar.h>", kPrivate, "<wctype.h>", kPublic },
   { "<bits/wordsize.h>", kPrivate, "<limits.h>", kPublic },
   { "<bits/xopen_lim.h>", kPrivate, "<limits.h>", kPublic },
-  { "<bits/xtitypes.h>", kPrivate, "<stropts.h>", kPublic },
   // Sometimes libc tells you what mapping to do via an '#error':
   // # error "Never use <bits/dlfcn.h> directly; include <dlfcn.h> instead."
   // or
   // # error "Never include <bits/socket_type.h> directly; use <sys/socket.h> instead."
-  // ( cd /usr/include && grep -R '^ *# *error "Never use\|include' * | perl -nle 'm/<([^>]+).*directly.*<([^>]+)/ && print qq@    { "<$1>", kPrivate, "<$2>", kPublic },@' | sort )
+  // ( cd /usr/include && grep -R '^ *# *error "Never use\|include' * | perl -nle 'm/<([^>]+).*directly.*<([^>]+)/ && print qq@  { "<$1>", kPrivate, "<$2>", kPublic },@' | sort )
   { "<bits/a.out.h>", kPrivate, "<a.out.h>", kPublic },
-  { "<bits/byteswap-16.h>", kPrivate, "<byteswap.h>", kPublic },
+  { "<bits/argp-ldbl.h>", kPrivate, "<argp.h>", kPublic },
   { "<bits/byteswap.h>", kPrivate, "<byteswap.h>", kPublic },
   { "<bits/cmathcalls.h>", kPrivate, "<complex.h>", kPublic },
   { "<bits/confname.h>", kPrivate, "<unistd.h>", kPublic },
+  { "<bits/cpu-set.h>", kPrivate, "<sched.h>", kPublic },
+  { "<bits/dirent_ext.h>", kPrivate, "<dirent.h>", kPublic },
   { "<bits/dirent.h>", kPrivate, "<dirent.h>", kPublic },
   { "<bits/dlfcn.h>", kPrivate, "<dlfcn.h>", kPublic },
+  { "<bits/dl_find_object.h>", kPrivate, "<dlfcn.h>", kPublic },
   { "<bits/elfclass.h>", kPrivate, "<link.h>", kPublic },
-  { "<bits/endian.h>", kPrivate, "<endian.h>", kPublic },
+  { "<bits/endianness.h>", kPrivate, "<endian.h>", kPublic },
   { "<bits/epoll.h>", kPrivate, "<sys/epoll.h>", kPublic },
+  { "<bits/err-ldbl.h>", kPrivate, "<err.h>", kPublic },
+  { "<bits/errno.h>", kPrivate, "<errno.h>", kPublic },
+  { "<bits/error.h>", kPrivate, "<error.h>", kPublic },
+  { "<bits/error-ldbl.h>", kPrivate, "<error.h>", kPublic },
   { "<bits/eventfd.h>", kPrivate, "<sys/eventfd.h>", kPublic },
   { "<bits/fcntl-linux.h>", kPrivate, "<fcntl.h>", kPublic },
+  { "<bits/fcntl2.h>", kPrivate, "<fcntl.h>", kPublic },
   { "<bits/fcntl.h>", kPrivate, "<fcntl.h>", kPublic },
   { "<bits/fenv.h>", kPrivate, "<fenv.h>", kPublic },
-  { "<bits/huge_val.h>", kPrivate, "<math.h>", kPublic },
-  { "<bits/huge_valf.h>", kPrivate, "<math.h>", kPublic },
-  { "<bits/huge_vall.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/flt-eval-method.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/fp-fast.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/fp-logb.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/hwcap.h>", kPrivate, "<sys/auxv.h>", kPublic },
+  { "<bits/indirect-return.h>", kPrivate, "<ucontext.h>", kPublic },
   { "<bits/in.h>", kPrivate, "<netinet/in.h>", kPublic },
-  { "<bits/inf.h>", kPrivate, "<math.h>", kPublic },
   { "<bits/inotify.h>", kPrivate, "<sys/inotify.h>", kPublic },
   { "<bits/ioctl-types.h>", kPrivate, "<sys/ioctl.h>", kPublic },
   { "<bits/ioctls.h>", kPrivate, "<sys/ioctl.h>", kPublic },
   { "<bits/ipc.h>", kPrivate, "<sys/ipc.h>", kPublic },
+  { "<bits/ipc-perm.h>", kPrivate, "<sys/ipc.h>", kPublic },
   { "<bits/ipctypes.h>", kPrivate, "<sys/ipc.h>", kPublic },
+  { "<bits/iscanonical.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/link.h>", kPrivate, "<link.h>", kPublic },
+  { "<bits/link_lavcurrent.h>", kPrivate, "<link.h>", kPublic },
   { "<bits/locale.h>", kPrivate, "<locale.h>", kPublic },
-  { "<bits/math-finite.h>", kPrivate, "<math.h>", kPublic },
-  { "<bits/mathdef.h>", kPrivate, "<math.h>", kPublic },
-  { "<bits/mathinline.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/mathcalls.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/mathcalls-narrow.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/mathdef.h>", kPrivate, "<complex.h>", kPublic },
+  { "<bits/mman_ext.h>", kPrivate, "<sys/mman.h>", kPublic },
   { "<bits/mman-linux.h>", kPrivate, "<sys/mman.h>", kPublic },
   { "<bits/mman.h>", kPrivate, "<sys/mman.h>", kPublic },
+  { "<bits/mman-map-flags-generic.h>", kPrivate, "<sys/mman.h>", kPublic },
+  { "<bits/mman-shared.h>", kPrivate, "<sys/mman.h>", kPublic },
+  { "<bits/monetary-ldbl.h>", kPrivate, "<monetary.h>", kPublic },
+  { "<bits/mqueue2.h>", kPrivate, "<mqueue.h>", kPublic },
   { "<bits/mqueue.h>", kPrivate, "<mqueue.h>", kPublic },
   { "<bits/msq.h>", kPrivate, "<sys/msg.h>", kPublic },
-  { "<bits/nan.h>", kPrivate, "<math.h>", kPublic },
+  { "<bits/msq.h>", kPrivate, "<sys/msg.h>", kPublic },
+  { "<bits/msq.h>", kPrivate, "<sys/msg.h>", kPublic },
+  { "<bits/netdb.h>", kPrivate, "<netdb.h>", kPublic },
   { "<bits/param.h>", kPrivate, "<sys/param.h>", kPublic },
+  { "<bits/platform/x86.h>", kPrivate, "<sys/platform/x86.h>", kPublic },
   { "<bits/poll.h>", kPrivate, "<sys/poll.h>", kPrivate },
-  { "<bits/predefs.h>", kPrivate, "<features.h>", kPublic },
+  { "<bits/poll2.h>", kPrivate, "<sys/poll.h>", kPrivate },
+  { "<bits/printf-ldbl.h>", kPrivate, "<printf.h>", kPublic },
+  { "<bits/procfs-extra.h>", kPrivate, "<sys/procfs.h>", kPublic },
+  { "<bits/procfs.h>", kPrivate, "<sys/procfs.h>", kPublic },
+  { "<bits/procfs-id.h>", kPrivate, "<sys/procfs.h>", kPublic },
+  { "<bits/procfs-prregset.h>", kPrivate, "<sys/procfs.h>", kPublic },
+  { "<bits/ptrace-shared.h>", kPrivate, "<sys/ptrace.h>", kPublic },
   { "<bits/resource.h>", kPrivate, "<sys/resource.h>", kPublic },
+  { "<bits/rseq.h>", kPrivate, "<sys/rseq.h>", kPublic },
+  { "<bits/sched.h>", kPrivate, "<sched.h>", kPublic },
+  { "<bits/select2.h>", kPrivate, "<sys/select.h>", kPublic },
   { "<bits/select.h>", kPrivate, "<sys/select.h>", kPublic },
   { "<bits/semaphore.h>", kPrivate, "<semaphore.h>", kPublic },
+  { "<bits/sem.h>", kPrivate, "<sys/sem.h>", kPublic },
+  { "<bits/setjmp2.h>", kPrivate, "<setjmp.h>", kPublic },
+  { "<bits/setjmp.h>", kPrivate, "<setjmp.h>", kPublic },
+  { "<bits/shm.h>", kPrivate, "<sys/shm.h>", kPublic },
+  { "<bits/shmlba.h>", kPrivate, "<sys/shm.h>", kPublic },
+  { "<bits/sigaction.h>", kPrivate, "<signal.h>", kPublic },
   { "<bits/sigcontext.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/sigevent-consts.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/siginfo-consts.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/signal_ext.h>", kPrivate, "<signal.h>", kPublic },
   { "<bits/signalfd.h>", kPrivate, "<sys/signalfd.h>", kPublic },
+  { "<bits/signum-arch.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/signum-generic.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/sigstksz.h>", kPrivate, "<signal.h>", kPublic },
+  { "<bits/socket2.h>", kPrivate, "<sys/socket.h>", kPublic },
+  { "<bits/socket-constants.h>", kPrivate, "<sys/socket.h>", kPublic },
+  { "<bits/socket.h>", kPrivate, "<sys/socket.h>", kPublic },
+  { "<bits/socket_type.h>", kPrivate, "<sys/socket.h>", kPublic },
+  { "<bits/statfs.h>", kPrivate, "<sys/statfs.h>", kPublic },
+  { "<bits/stat.h>", kPrivate, "<sys/stat.h>", kPublic },
+  { "<bits/statvfs.h>", kPrivate, "<sys/statvfs.h>", kPublic },
+  { "<bits/statx-generic.h>", kPrivate, "<sys/stat.h>", kPublic },
+  { "<bits/statx.h>", kPrivate, "<sys/stat.h>", kPublic },
+  { "<bits/stdio2-decl.h>", kPrivate, "<stdio.h>", kPublic },
+  { "<bits/stdio2.h>", kPrivate, "<stdio.h>", kPublic },
+  { "<bits/stdio.h>", kPrivate, "<stdio.h>", kPublic },
+  { "<bits/stdio-ldbl.h>", kPrivate, "<stdio.h>", kPublic },
+  { "<bits/stdio_lim.h>", kPrivate, "<stdio.h>", kPublic },
   { "<bits/stdlib-float.h>", kPrivate, "<stdlib.h>", kPublic },
-  { "<bits/string.h>", kPrivate, "<string.h>", kPublic },
-  { "<bits/string2.h>", kPrivate, "<string.h>", kPublic },
-  { "<bits/string3.h>", kPrivate, "<string.h>", kPublic },
+  { "<bits/stdlib.h>", kPrivate, "<stdlib.h>", kPublic },
+  { "<bits/stdlib-ldbl.h>", kPrivate, "<stdlib.h>", kPublic },
+  { "<bits/string_fortified.h>", kPrivate, "<string.h>", kPublic },
+  { "<bits/struct_stat.h>", kPrivate, "<sys/stat.h>", kPublic },
+  { "<bits/syscall.h>", kPrivate, "<sys/syscall.h>", kPublic },
+  { "<bits/syslog.h>", kPrivate, "<sys/syslog.h>", kPrivate },
+  { "<bits/syslog-ldbl.h>", kPrivate, "<sys/syslog.h>", kPrivate },
+  { "<bits/sysmacros.h>", kPrivate, "<sys/sysmacros.h>", kPublic },
+  { "<bits/termios-baud.h>", kPrivate, "<termios.h>", kPublic },
+  { "<bits/termios_c_cc.h>", kPrivate, "<termios.h>", kPublic },
+  { "<bits/termios-c_cflag.h>", kPrivate, "<termios.h>", kPublic },
+  { "<bits/termios-ciflags.h>", kPrivate, "<termios.h>", kPublic },
+  { "<bits/termios-c_lflag.h>", kPrivate, "<termios.h>", kPublic },
+  { "<bits/termios-c_oflag.h>", kPrivate, "<termios.h>", kPublic },
+  { "<bits/termios.h>", kPrivate, "<termios.h>", kPublic },
+  { "<bits/termios-misc.h>", kPrivate, "<termios.h>", kPublic },
+  { "<bits/termios-struct.h>", kPrivate, "<termios.h>", kPublic },
+  { "<bits/termios-tcflow.h>", kPrivate, "<termios.h>", kPublic },
+  { "<bits/time64.h>", kPrivate, "<sys/types.h>", kPublic },
   { "<bits/timerfd.h>", kPrivate, "<sys/timerfd.h>", kPublic },
   { "<bits/typesizes.h>", kPrivate, "<sys/types.h>", kPublic },
+  { "<bits/types/struct_semid_ds.h>", kPrivate, "<sys/sem.h>", kPublic },
+  { "<bits/types/struct_semid_ds.h>", kPrivate, "<sys/sem.h>", kPublic },
+  { "<bits/types/struct_shmid_ds.h>", kPrivate, "<sys/shm.h>", kPublic },
+  { "<bits/types/struct_shmid_ds.h>", kPrivate, "<sys/shm.h>", kPublic },
+  { "<bits/types/struct_statx.h>", kPrivate, "<sys/stat.h>", kPublic },
+  { "<bits/types/struct_statx_timestamp.h>", kPrivate, "<sys/stat.h>", kPublic },
+  { "<bits/uintn-identity.h>", kPrivate, "<endian.h>", kPublic },
+  { "<bits/uio-ext.h>", kPrivate, "<sys/uio.h>", kPublic },
+  { "<bits/unistd_ext.h>", kPrivate, "<unistd.h>", kPublic },
+  { "<bits/unistd.h>", kPrivate, "<unistd.h>", kPublic },
+  { "<bits/utmp.h>", kPrivate, "<utmp.h>", kPublic },
+  { "<bits/utmpx.h>", kPrivate, "<utmpx.h>", kPublic },
+  { "<bits/utsname.h>", kPrivate, "<sys/utsname.h>", kPublic },
+  { "<bits/waitflags.h>", kPrivate, "<sys/wait.h>", kPublic },
+  { "<bits/waitstatus.h>", kPrivate, "<sys/wait.h>", kPublic },
+  { "<bits/wchar2.h>", kPrivate, "<wchar.h>", kPublic },
+  { "<bits/wchar-ldbl.h>", kPrivate, "<wchar.h>", kPublic },
+  { "<bits/wctype-wchar.h>", kPrivate, "<wchar.h>", kPublic },
+  { "<gnu/lib-names-32.h>", kPrivate, "<gnu/lib-names.h>", kPublic },
+  { "<gnu/lib-names-64.h>", kPrivate, "<gnu/lib-names.h>", kPublic },
+
   // Top-level #includes that just forward to another file:
   // $ for i in /usr/include/*; do [ -f $i ] && [ `wc -l < $i` = 1 ] && echo $i; done
   // (poll.h, syscall.h, syslog.h, ustat.h, wait.h).
@@ -467,8 +631,9 @@ const IncludeMapEntry libc_include_map[] = {
   // $ for i in /usr/include/bits/*; do for dir in asm linux; do grep -H -e $dir/`basename $i` $i; done; done
   { "<linux/errno.h>", kPrivate, "<bits/errno.h>", kPrivate },
   { "<asm/ioctls.h>", kPrivate, "<bits/ioctls.h>", kPrivate },
+  { "<linux/param.h>", kPrivate, "<bits/param.h>", kPrivate },
+  { "<asm/socket.h>", kPrivate, "<bits/socket.h>", kPrivate },
   { "<asm/socket.h>", kPrivate, "<bits/socket.h>", kPrivate },
-  { "<linux/socket.h>", kPrivate, "<bits/socket.h>", kPrivate },
   // Some asm files have 32- and 64-bit variants:
   // $ ls /usr/include/asm/*_{32,64}.h
   { "<asm/posix_types_32.h>", kPrivate, "<asm/posix_types.h>", kPublic },
@@ -498,12 +663,12 @@ const IncludeMapEntry stdlib_c_include_map[] = {
   // <cassert> back to <assert.h>.  (If you *did* want to replace
   // assert.h with cassert, you'd change it to a public->private
   // mapping.)  Here is how I identified the files to map:
-  // $ for i in /usr/include/c++/4.4/c* ; do ls /usr/include/`basename $i | cut -b2-`.h /usr/lib/gcc/*/4.4/include/`basename $i | cut -b2-`.h 2>/dev/null ; done
+  // $ for i in /usr/include/c++/12/c* ; do ls /usr/include/`basename $i | cut -b2-`.h /usr/lib/gcc/*/12/include/`basename $i | cut -b2-`.h 2>/dev/null ; done
   //
   // These headers are defined in [headers.cpp.c].
   // https://github.com/cplusplus/draft/blob/c+%2B20/source/lib-intro.tex
   //
-  // $ curl -s -N https://raw.githubusercontent.com/cplusplus/draft/c%2B%2B20/source/lib-intro.tex | sed -n '/begin{multicolfloattable}.*{headers.cpp.c}/,/end{multicolfloattable}/p' lib-intro.tex | grep tcode | perl -nle 'm/tcode{<c(.*)>}/ && print qq@  { "<$1.h>", kPublic, "<c$1>", kPublic },@' | sort
+  // $ curl -s -N https://raw.githubusercontent.com/cplusplus/draft/c%2B%2B20/source/lib-intro.tex | sed -n '/begin{multicolfloattable}.*{headers.cpp.c}/,/end{multicolfloattable}/p' | grep tcode | perl -nle 'm/tcode{<c(.*)>}/ && print qq@  { "<$1.h>", kPublic, "<c$1>", kPublic },@' | sort
   { "<assert.h>", kPublic, "<cassert>", kPublic },
   { "<complex.h>", kPublic, "<ccomplex>", kPublic },
   { "<ctype.h>", kPublic, "<cctype>", kPublic },
@@ -536,7 +701,7 @@ const char* stdlib_cpp_public_headers[] = {
   // These headers are defined in [headers.cpp].
   // https://github.com/cplusplus/draft/blob/c+%2B20/source/lib-intro.tex
   //
-  // $ curl -s -N https://raw.githubusercontent.com/cplusplus/draft/c%2B%2B20/source/lib-intro.tex | sed -n '/begin{multicolfloattable}.*{headers.cpp}/,/end{multicolfloattable}/p' lib-intro.tex | grep tcode | perl -nle 'm/tcode{(.*)}/ && print qq@  "$1",@' | sort
+  // $ curl -s -N https://raw.githubusercontent.com/cplusplus/draft/c%2B%2B20/source/lib-intro.tex | sed -n '/begin{multicolfloattable}.*{headers.cpp}/,/end{multicolfloattable}/p' | grep tcode | perl -nle 'm/tcode{(.*)}/ && print qq@  "$1",@' | sort
   "<algorithm>",
   "<any>",
   "<array>",
@@ -626,19 +791,23 @@ const IncludeMapEntry stdlib_cpp_include_map[] = {
   // #including each other (eg <iostream> #includes <istream>).  We
   // are pretty forgiving: if a user specifies any public header, we
   // generally don't require the others.
-  // ( cd /usr/crosstool/v12/gcc-4.3.1-glibc-2.3.6-grte/x86_64-unknown-linux-gnu/x86_64-unknown-linux-gnu/include/c++/4.3.1 && egrep '^ *# *include <(istream|ostream|iostream|fstream|sstream|streambuf|ios|iosfwd)>' *stream* ios | perl -nle 'm/^([^:]+).*[<"]([^>"]+)[>"]/ and print qq@    { "<$2>", kPublic, "<$1>", kPublic },@' | sort -u )
+  // ( cd /usr/include/c++/12 && egrep '^ *# *include <(istream|ostream|iostream|fstream|sstream|streambuf|ios|iosfwd)>' *stream* ios | perl -nle 'm/^([^:]+).*[<"]([^>"]+)[>"]/ and print qq@  { "<$2>", kPublic, "<$1>", kPublic },@' | sort -u )
   { "<ios>", kPublic, "<istream>", kPublic },
   { "<ios>", kPublic, "<ostream>", kPublic },
   { "<iosfwd>", kPublic, "<ios>", kPublic },
   { "<iosfwd>", kPublic, "<streambuf>", kPublic },
   { "<istream>", kPublic, "<fstream>", kPublic },
   { "<istream>", kPublic, "<iostream>", kPublic },
+  { "<istream>", kPublic, "<spanstream>", kPublic },
   { "<istream>", kPublic, "<sstream>", kPublic },
   { "<ostream>", kPublic, "<fstream>", kPublic },
   { "<ostream>", kPublic, "<iostream>", kPublic },
   { "<ostream>", kPublic, "<istream>", kPublic },
+  { "<ostream>", kPublic, "<spanstream>", kPublic },
   { "<ostream>", kPublic, "<sstream>", kPublic },
+  { "<sstream>", kPublic, "<syncstream>", kPublic },
   { "<streambuf>", kPublic, "<ios>", kPublic },
+  { "<streambuf>", kPublic, "<spanstream>", kPublic },
 };
 
 // Private -> public include mappings for GNU libstdc++
@@ -646,16 +815,19 @@ const IncludeMapEntry stdlib_cpp_include_map[] = {
 // Note: make sure to sync this setting with gcc.stl.headers.imp
 //
 const IncludeMapEntry libstdcpp_include_map[] = {
-  // cd /usr/include/c++/10 && grep -r headername | perl -nle 'm/^([^:]+).*@headername\{([^,]*)\}/ && print qq@  { "<$1>", kPrivate, "<$2>", kPublic },@' | sort -u
+  // ( cd /usr/include/c++/12 && grep -r headername | perl -nle 'm/^([^:]+).*@headername\{([^,]*)\}/ && print qq@  { "<$1>", kPrivate, "<$2>", kPublic },@' | sort -u )
   { "<backward/auto_ptr.h>", kPrivate, "<memory>", kPublic },
   { "<backward/backward_warning.h>", kPrivate, "<iosfwd>", kPublic },
   { "<backward/binders.h>", kPrivate, "<functional>", kPublic },
   { "<bits/algorithmfwd.h>", kPrivate, "<algorithm>", kPublic },
+  { "<bits/align.h>", kPrivate, "<memory>", kPublic },
   { "<bits/allocated_ptr.h>", kPrivate, "<memory>", kPublic },
   { "<bits/allocator.h>", kPrivate, "<memory>", kPublic },
   { "<bits/alloc_traits.h>", kPrivate, "<memory>", kPublic },
   { "<bits/atomic_base.h>", kPrivate, "<atomic>", kPublic },
   { "<bits/atomic_lockfree_defines.h>", kPrivate, "<atomic>", kPublic },
+  { "<bits/atomic_timed_wait.h>", kPrivate, "<atomic>", kPublic },
+  { "<bits/atomic_wait.h>", kPrivate, "<atomic>", kPublic },
   { "<bits/basic_ios.h>", kPrivate, "<ios>", kPublic },
   { "<bits/basic_ios.tcc>", kPrivate, "<ios>", kPublic },
   { "<bits/basic_string.h>", kPrivate, "<string>", kPublic },
@@ -664,9 +836,11 @@ const IncludeMapEntry libstdcpp_include_map[] = {
   { "<bits/c++0x_warning.h>", kPrivate, "<iosfwd>", kPublic },
   { "<bits/charconv.h>", kPrivate, "<charconv>", kPublic },
   { "<bits/char_traits.h>", kPrivate, "<string>", kPublic },
+  { "<bits/chrono.h>", kPrivate, "<chrono>", kPublic },
   { "<bits/codecvt.h>", kPrivate, "<locale>", kPublic },
   { "<bits/concept_check.h>", kPrivate, "<iterator>", kPublic },
-  { "<bits/cpp_type_traits.h>", kPrivate, "<ext/type_traits>", kPublic },
+  { "<bits/cow_string.h>", kPrivate, "<string>", kPublic },
+  { "<bits/cpp_type_traits.h>", kPrivate, "<ext/type_traits.h>", kPublic },
   { "<bits/cxxabi_forced.h>", kPrivate, "<cxxabi.h>", kPublic },
   { "<bits/deque.tcc>", kPrivate, "<deque>", kPublic },
   { "<bits/exception_defines.h>", kPrivate, "<exception>", kPublic },
@@ -684,7 +858,6 @@ const IncludeMapEntry libstdcpp_include_map[] = {
   { "<bits/gslice.h>", kPrivate, "<valarray>", kPublic },
   { "<bits/hash_bytes.h>", kPrivate, "<functional>", kPublic },
   { "<bits/indirect_array.h>", kPrivate, "<valarray>", kPublic },
-  { "<bits/int_limits.h>", kPrivate, "<limits>", kPublic },
   { "<bits/invoke.h>", kPrivate, "<functional>", kPublic },
   { "<bits/ios_base.h>", kPrivate, "<ios>", kPublic },
   { "<bits/istream.tcc>", kPrivate, "<istream>", kPublic },
@@ -699,9 +872,13 @@ const IncludeMapEntry libstdcpp_include_map[] = {
   { "<bits/locale_facets.tcc>", kPrivate, "<locale>", kPublic },
   { "<bits/localefwd.h>", kPrivate, "<locale>", kPublic },
   { "<bits/mask_array.h>", kPrivate, "<valarray>", kPublic },
+  { "<bits/max_size_type.h>", kPrivate, "<iterator>", kPublic },
   { "<bits/memoryfwd.h>", kPrivate, "<memory>", kPublic },
+  { "<bits/mofunc_impl.h>", kPrivate, "<functional>", kPublic },
   { "<bits/move.h>", kPrivate, "<utility>", kPublic },
+  { "<bits/move_only_function.h>", kPrivate, "<functional>", kPublic },
   { "<bits/nested_exception.h>", kPrivate, "<exception>", kPublic },
+  { "<bits/new_allocator.h>", kPrivate, "<memory>", kPublic },
   { "<bits/ostream_insert.h>", kPrivate, "<ostream>", kPublic },
   { "<bits/ostream.tcc>", kPrivate, "<ostream>", kPublic },
   { "<bits/parse_numbers.h>", kPrivate, "<chrono>", kPublic },
@@ -712,10 +889,12 @@ const IncludeMapEntry libstdcpp_include_map[] = {
   { "<bits/random.h>", kPrivate, "<random>", kPublic },
   { "<bits/random.tcc>", kPrivate, "<random>", kPublic },
   { "<bits/range_access.h>", kPrivate, "<iterator>", kPublic },
-  { "<bits/range_cmp.h>", kPrivate, "<functional>", kPublic },
   { "<bits/ranges_algobase.h>", kPrivate, "<algorithm>", kPublic },
   { "<bits/ranges_algo.h>", kPrivate, "<algorithm>", kPublic },
+  { "<bits/ranges_base.h>", kPrivate, "<ranges>", kPublic },
+  { "<bits/ranges_cmp.h>", kPrivate, "<functional>", kPublic },
   { "<bits/ranges_uninitialized.h>", kPrivate, "<memory>", kPublic },
+  { "<bits/ranges_util.h>", kPrivate, "<ranges>", kPublic },
   { "<bits/refwrap.h>", kPrivate, "<functional>", kPublic },
   { "<bits/regex_automaton.h>", kPrivate, "<regex>", kPublic },
   { "<bits/regex_automaton.tcc>", kPrivate, "<regex>", kPublic },
@@ -729,6 +908,7 @@ const IncludeMapEntry libstdcpp_include_map[] = {
   { "<bits/regex_scanner.h>", kPrivate, "<regex>", kPublic },
   { "<bits/regex_scanner.tcc>", kPrivate, "<regex>", kPublic },
   { "<bits/regex.tcc>", kPrivate, "<regex>", kPublic },
+  { "<bits/semaphore_base.h>", kPrivate, "<semaphore>", kPublic },
   { "<bits/shared_ptr_atomic.h>", kPrivate, "<memory>", kPublic },
   { "<bits/shared_ptr_base.h>", kPrivate, "<memory>", kPublic },
   { "<bits/shared_ptr.h>", kPrivate, "<memory>", kPublic },
@@ -737,6 +917,7 @@ const IncludeMapEntry libstdcpp_include_map[] = {
   { "<bits/sstream.tcc>", kPrivate, "<sstream>", kPublic },
   { "<bits/std_function.h>", kPrivate, "<functional>", kPublic },
   { "<bits/std_mutex.h>", kPrivate, "<mutex>", kPublic },
+  { "<bits/std_thread.h>", kPrivate, "<thread>", kPublic },
   { "<bits/stl_algobase.h>", kPrivate, "<algorithm>", kPublic },
   { "<bits/stl_algo.h>", kPrivate, "<algorithm>", kPublic },
   { "<bits/stl_bvector.h>", kPrivate, "<vector>", kPublic },
@@ -766,11 +947,13 @@ const IncludeMapEntry libstdcpp_include_map[] = {
   { "<bits/stream_iterator.h>", kPrivate, "<iterator>", kPublic },
   { "<bits/stringfwd.h>", kPrivate, "<string>", kPublic },
   { "<bits/string_view.tcc>", kPrivate, "<string_view>", kPublic },
+  { "<bits/this_thread_sleep.h>", kPrivate, "<thread>", kPublic },
   { "<bits/uniform_int_dist.h>", kPrivate, "<random>", kPublic },
   { "<bits/unique_lock.h>", kPrivate, "<mutex>", kPublic },
   { "<bits/unique_ptr.h>", kPrivate, "<memory>", kPublic },
   { "<bits/unordered_map.h>", kPrivate, "<unordered_map>", kPublic },
   { "<bits/unordered_set.h>", kPrivate, "<unordered_set>", kPublic },
+  { "<bits/uses_allocator_args.h>", kPrivate, "<memory>", kPublic },
   { "<bits/utility.h>", kPrivate, "<utility>", kPublic },
   { "<bits/valarray_after.h>", kPrivate, "<valarray>", kPublic },
   { "<bits/valarray_array.h>", kPrivate, "<valarray>", kPublic },
@@ -858,10 +1041,9 @@ const IncludeMapEntry libstdcpp_include_map[] = {
   { "<tr1/unordered_map.h>", kPrivate, "<tr1/unordered_map>", kPublic },
   { "<tr1/unordered_set.h>", kPrivate, "<tr1/unordered_set>", kPublic },
   { "<tr2/dynamic_bitset.tcc>", kPrivate, "<tr2/dynamic_bitset>", kPublic },
-  // cd /usr/include/x86_64-linux-gnu/c++/10 && grep -r headername | perl -nle 'm/^([^:]+).*@headername\{([^,]*)\}/ && print qq@  { "<$1>", kPrivate, "<$2>", kPublic },@' | sort -u
+  // ( cd /usr/include/c++/12/x86_64-suse-linux && grep -r headername | perl -nle 'm/^([^:]+).*@headername\{([^,]*)\}/ && print qq@  { "<$1>", kPrivate, "<$2>", kPublic },@' | sort -u )
   { "<bits/basic_file.h>", kPrivate, "<ios>", kPublic },
   { "<bits/c++allocator.h>", kPrivate, "<memory>", kPublic },
-  { "<bits/c++config.h>", kPrivate, "<iosfwd>", kPublic },
   { "<bits/c++config.h>", kPrivate, "<version>", kPublic },
   { "<bits/c++io.h>", kPrivate, "<ios>", kPublic },
   { "<bits/c++locale.h>", kPrivate, "<locale>", kPublic },
@@ -875,68 +1057,40 @@ const IncludeMapEntry libstdcpp_include_map[] = {
   { "<bits/os_defines.h>", kPrivate, "<iosfwd>", kPublic },
   { "<bits/time_members.h>", kPrivate, "<locale>", kPublic },
   { "<ext/opt_random.h>", kPrivate, "<ext/random>", kPublic },
-  // ( cd /usr/crosstool/v12/gcc-4.3.1-glibc-2.3.6-grte/x86_64-unknown-linux-gnu/x86_64-unknown-linux-gnu/include/c++/4.3.1 && grep '^ *# *include' {ext/,tr1/,}* | perl -nle 'm/^([^:]+).*<([^>]+)>/ && print qq@    { "<$2>", kPrivate, "<$1>", kPublic },@' | grep -e bits/ -e tr1_impl/ | sort -u)
+  // ( cd /usr/include/c++/12 && grep '^ *# *include' {ext/,tr1/,}* | perl -nle 'm/^([^:]+).*<([^>]+)>/ && print qq@  { "<$2>", kPrivate, "<$1>", kPublic },@' | grep -e bits/ -e tr1_impl/ | sort -u)
   // I removed a lot of 'meaningless' dependencies -- for instance,
   // <functional> #includes <bits/stringfwd.h>, but if someone is
   // using strings, <functional> isn't enough to satisfy iwyu.
   // We may need to add other dirs in future versions of gcc.
-  { "<bits/atomic_word.h>", kPrivate, "<ext/atomicity.h>", kPublic },
+  // We remove headers on the left-hand side that have a @headername comment.
+  { "<bits/atomic_futex.h>", kPrivate, "<future>", kPublic },
+  { "<bits/atomic_word.h>", kPrivate, "<ext/atomicity.h>", kPrivate },
   { "<bits/basic_file.h>", kPrivate, "<fstream>", kPublic },
-  { "<bits/boost_sp_shared_count.h>", kPrivate, "<memory>", kPublic },
-  { "<bits/c++io.h>", kPrivate, "<ext/stdio_sync_filebuf.h>", kPublic },
-  { "<bits/c++config.h>", kPrivate, "<cstddef>", kPublic },
-  { "<bits/cmath.tcc>", kPrivate, "<cmath>", kPublic },
-  { "<bits/codecvt.h>", kPrivate, "<fstream>", kPublic },
+  { "<bits/basic_ios.h>", kPrivate, "<ios>", kPublic },
+  { "<bits/c++io.h>", kPrivate, "<ext/stdio_sync_filebuf.h>", kPrivate },
+  { "<bits/cxxabi_init_exception.h>", kPrivate, "<cxxabi.h>", kPublic },
   { "<bits/cxxabi_tweaks.h>", kPrivate, "<cxxabi.h>", kPublic },
-  { "<bits/functional_hash.h>", kPrivate, "<unordered_map>", kPublic },
-  { "<bits/hashtable.h>", kPrivate, "<unordered_map>", kPublic },
-  { "<bits/hashtable.h>", kPrivate, "<unordered_set>", kPublic },
-  { "<bits/ios_base.h>", kPrivate, "<iostream>", kPublic },
-  { "<bits/ios_base.h>", kPrivate, "<iomanip>", kPublic },
-  { "<bits/postypes.h>", kPrivate, "<iostream>", kPublic },
-  { "<bits/stl_pair.h>", kPrivate, "<tr1/utility>", kPublic },
-  { "<bits/stl_tree.h>", kPrivate, "<map>", kPublic },
-  { "<bits/stl_tree.h>", kPrivate, "<set>", kPublic },
-  { "<tr1_impl/array>", kPrivate, "<array>", kPublic },
-  { "<tr1_impl/array>", kPrivate, "<tr1/array>", kPublic },
-  { "<tr1_impl/boost_shared_ptr.h>", kPrivate, "<memory>", kPublic },
-  { "<tr1_impl/boost_shared_ptr.h>", kPrivate, "<tr1/memory>", kPublic },
-  { "<tr1_impl/boost_sp_counted_base.h>", kPrivate, "<memory>", kPublic },
-  { "<tr1_impl/boost_sp_counted_base.h>", kPrivate, "<tr1/memory>", kPublic },
-  { "<tr1_impl/cctype>", kPrivate, "<cctype>", kPublic },
-  { "<tr1_impl/cctype>", kPrivate, "<tr1/cctype>", kPublic },
-  { "<tr1_impl/cfenv>", kPrivate, "<cfenv>", kPublic },
-  { "<tr1_impl/cfenv>", kPrivate, "<tr1/cfenv>", kPublic },
-  { "<tr1_impl/cinttypes>", kPrivate, "<cinttypes>", kPublic },
-  { "<tr1_impl/cinttypes>", kPrivate, "<tr1/cinttypes>", kPublic },
-  { "<tr1_impl/cmath>", kPrivate, "<cmath>", kPublic },
-  { "<tr1_impl/cmath>", kPrivate, "<tr1/cmath>", kPublic },
-  { "<tr1_impl/complex>", kPrivate, "<complex>", kPublic },
-  { "<tr1_impl/complex>", kPrivate, "<tr1/complex>", kPublic },
-  { "<tr1_impl/cstdint>", kPrivate, "<cstdint>", kPublic },
-  { "<tr1_impl/cstdint>", kPrivate, "<tr1/cstdint>", kPublic },
-  { "<tr1_impl/cstdio>", kPrivate, "<cstdio>", kPublic },
-  { "<tr1_impl/cstdio>", kPrivate, "<tr1/cstdio>", kPublic },
-  { "<tr1_impl/cstdlib>", kPrivate, "<cstdlib>", kPublic },
-  { "<tr1_impl/cstdlib>", kPrivate, "<tr1/cstdlib>", kPublic },
-  { "<tr1_impl/cwchar>", kPrivate, "<cwchar>", kPublic },
-  { "<tr1_impl/cwchar>", kPrivate, "<tr1/cwchar>", kPublic },
-  { "<tr1_impl/cwctype>", kPrivate, "<cwctype>", kPublic },
-  { "<tr1_impl/cwctype>", kPrivate, "<tr1/cwctype>", kPublic },
-  { "<tr1_impl/functional>", kPrivate, "<functional>", kPublic },
-  { "<tr1_impl/functional>", kPrivate, "<tr1/functional>", kPublic },
-  { "<tr1_impl/random>", kPrivate, "<random>", kPublic },
-  { "<tr1_impl/random>", kPrivate, "<tr1/random>", kPublic },
-  { "<tr1_impl/regex>", kPrivate, "<regex>", kPublic },
-  { "<tr1_impl/regex>", kPrivate, "<tr1/regex>", kPublic },
-  { "<tr1_impl/type_traits>", kPrivate, "<tr1/type_traits>", kPublic },
-  { "<tr1_impl/type_traits>", kPrivate, "<type_traits>", kPublic },
-  { "<tr1_impl/unordered_map>", kPrivate, "<tr1/unordered_map>", kPublic },
-  { "<tr1_impl/unordered_map>", kPrivate, "<unordered_map>", kPublic },
-  { "<tr1_impl/unordered_set>", kPrivate, "<tr1/unordered_set>", kPublic },
-  { "<tr1_impl/unordered_set>", kPrivate, "<unordered_set>", kPublic },
-  { "<tr1_impl/utility>", kPrivate, "<tr1/utility>", kPublic },
-  { "<tr1_impl/utility>", kPrivate, "<utility>", kPublic },
+  { "<bits/enable_special_members.h>", kPrivate, "<optional>", kPublic },
+  { "<bits/enable_special_members.h>", kPrivate, "<variant>", kPublic },
+  { "<bits/erase_if.h>", kPrivate, "<map>", kPublic },
+  { "<bits/erase_if.h>", kPrivate, "<set>", kPublic },
+  { "<bits/erase_if.h>", kPrivate, "<unordered_map>", kPublic },
+  { "<bits/erase_if.h>", kPrivate, "<unordered_set>", kPublic },
+  { "<bits/error_constants.h>", kPrivate, "<charconv>", kPublic },
+  { "<bits/error_constants.h>", kPrivate, "<system_error>", kPublic },
+  { "<bits/exception.h>", kPrivate, "<exception>", kPublic },
+  { "<bits/exception.h>", kPrivate, "<expected>", kPublic },
+  { "<bits/exception.h>", kPrivate, "<new>", kPublic },
+  { "<bits/exception.h>", kPrivate, "<typeinfo>", kPublic },
+  { "<bits/gthr.h>", kPrivate, "<ext/atomicity.h>", kPrivate },
+  { "<bits/gthr.h>", kPrivate, "<ext/concurrence.h>", kPrivate },
+  { "<bits/gthr.h>", kPrivate, "<ext/rope>", kPublic },
+  { "<bits/opt_random.h>", kPrivate, "<random>", kPublic },
+  { "<bits/uses_allocator.h>", kPrivate, "<future>", kPublic },
+  { "<bits/uses_allocator.h>", kPrivate, "<memory>", kPublic },
+  { "<bits/uses_allocator.h>", kPrivate, "<memory_resource>", kPublic },
+  { "<bits/uses_allocator.h>", kPrivate, "<scoped_allocator>", kPublic },
+  { "<bits/uses_allocator.h>", kPrivate, "<tuple>", kPublic },
   // Hash and hashtable-based containers.
   { "<tr1_impl/functional_hash.h>", kPrivate, "<tr1/functional>", kPublic },
   { "<tr1_impl/functional_hash.h>", kPrivate, "<tr1/unordered_map>", kPublic },
@@ -948,21 +1102,31 @@ const IncludeMapEntry libstdcpp_include_map[] = {
   { "<tr1/hashtable.h>", kPrivate, "<tr1/unordered_map>", kPublic },
   { "<tr1/hashtable.h>", kPrivate, "<tr1/unordered_set>", kPublic },
   // All .tcc files are gcc internal-include files.  We get them from
-  // ( cd /usr/crosstool/v12/gcc-4.3.1-glibc-2.3.6-grte/x86_64-unknown-linux-gnu/x86_64-unknown-linux-gnu/include/c++/4.3.1 && grep -R '^ *# *include.*tcc' * | perl -nle 'm/^([^:]+).*[<"]([^>"]+)[>"]/ && print qq@    { "<$2>", kPrivate, "<$1>", kPublic },@' | sort )
+  // ( cd /usr/include/c++/12 && grep -R '^ *# *include.*tcc' * | perl -nle 'm/^([^:]+).*[<"]([^>"]+)[>"]/ && print qq@  { "<$2>", kPrivate, "<$1>", kPublic },@' | sort )
   // I had to manually edit some of the entries to say the map-to is private.
-  { "<bits/cmath.tcc>", kPrivate, "<cmath>", kPublic },
-  { "<tr1_impl/random.tcc>", kPrivate, "<tr1_impl/random>", kPrivate },
+  // We remove headers on the left-hand side that have a @headername comment.
+  { "<tr2/bool_set.tcc>", kPrivate, "<tr2/bool_set>", kPublic },
   // Some bits->bits #includes: A few files in bits re-export
   // symbols from other files in bits.
-  // ( cd /usr/crosstool/v12/gcc-4.3.1-glibc-2.3.6-grte/x86_64-unknown-linux-gnu/x86_64-unknown-linux-gnu/include/c++/4.3.1 && grep '^ *# *include.*bits/' bits/* | perl -nle 'm/^([^:]+).*<([^>]+)>/ && print qq@  { "<$2>", kPrivate, "<$1>", kPrivate },@' | grep bits/ | sort -u)
+  // ( cd /usr/include/c++/12 && grep '^ *# *include.*bits/' bits/* | perl -nle 'm/^([^:]+).*<([^>]+)>/ && print qq@  { "<$2>", kPrivate, "<$1>", kPrivate },@' | grep bits/ | sort -u)
   // and carefully picked reasonable-looking results (algorithm
   // *uses* pair but doesn't *re-export* pair, for instance).
-  { "<bits/c++allocator.h>", kPrivate, "<bits/allocator.h>", kPrivate },
+  // We remove most headers on the left-hand side that have a @headername comment.
+  { "<bits/c++locale.h>", kPrivate, "<bits/localefwd.h>", kPrivate },
   { "<bits/ctype_base.h>", kPrivate, "<bits/locale_facets.h>", kPrivate },
   { "<bits/ctype_inline.h>", kPrivate, "<bits/locale_facets.h>", kPrivate },
+  { "<bits/cxxabi_init_exception.h>", kPrivate, "<bits/exception_ptr.h>", kPrivate },
+  { "<bits/enable_special_members.h>", kPrivate, "<bits/hashtable.h>", kPrivate },
+  { "<bits/gthr.h>", kPrivate, "<bits/atomic_wait.h>", kPrivate },
+  { "<bits/gthr.h>", kPrivate, "<bits/std_mutex.h>", kPrivate },
+  { "<bits/gthr.h>", kPrivate, "<bits/std_thread.h>", kPrivate },
   { "<bits/messages_members.h>", kPrivate,
     "<bits/locale_facets_nonio.h>", kPrivate },
   { "<bits/stl_move.h>", kPrivate, "<bits/stl_algobase.h>", kPrivate },
+  { "<bits/stl_heap.h>", kPrivate, "<bits/stl_algo.h>", kPrivate },
+  { "<bits/time_members.h>", kPrivate, "<bits/locale_facets_nonio.h>", kPrivate },
+  { "<bits/uses_allocator.h>", kPrivate, "<bits/stl_queue.h>", kPrivate },
+  { "<bits/uses_allocator.h>", kPrivate, "<bits/stl_stack.h>", kPrivate },
   // I don't think we want to be having people move to 'backward/'
   // yet.  (These hold deprecated STL classes that we still use
   // actively.)  These are the ones that turned up in an analysis of
@@ -979,14 +1143,18 @@ const IncludeMapEntry libstdcpp_include_map[] = {
   { "<hash_fun.h>", kPrivate, "<hash_set>", kPublic },
   { "<hashtable.h>", kPrivate, "<hash_map>", kPublic },
   { "<hashtable.h>", kPrivate, "<hash_set>", kPublic },
-  // (This one should perhaps be found automatically somehow.)
+  // (These should perhaps be found automatically somehow.)
+  { "<ext/alloc_traits.h>", kPrivate, "<memory>", kPublic },
+  { "<ext/alloc_traits.h>", kPrivate, "<string>", kPublic },
+  { "<ext/alloc_traits.h>", kPrivate, "<vector>", kPublic },
+  { "<ext/alloc_traits.h>", kPrivate, "<map>", kPublic },
+  { "<ext/alloc_traits.h>", kPrivate, "<set>", kPublic },
   { "<ext/sso_string_base.h>", kPrivate, "<string>", kPublic },
   // The location of exception_defines.h varies by GCC version.  It should
   // never be included directly.
   { "<exception_defines.h>", kPrivate, "<exception>", kPublic },
 
   // post libstdc++-10 stuff which is not automatically caught by commands above
-  { "<bits/exception.h>", kPrivate, "<exception>", kPublic },
   { "<pstl/execution_defs.h>", kPrivate, "<execution>", kPublic },
   { "<pstl/glue_algorithm_impl.h>", kPrivate, "<execution>", kPublic },
   { "<pstl/glue_execution_defs.h>", kPrivate, "<execution>", kPublic },