19 files changed, 5956 insertions, 349 deletions

diff --git a/contrib/llvm-project/clang/lib/Tooling/CompilationDatabase.cpp b/contrib/llvm-project/clang/lib/Tooling/CompilationDatabase.cpp
index 1e19e68633d2..fdf6015508d9 100644
--- a/contrib/llvm-project/clang/lib/Tooling/CompilationDatabase.cpp
+++ b/contrib/llvm-project/clang/lib/Tooling/CompilationDatabase.cpp
@@ -37,11 +37,11 @@
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorOr.h"
-#include "llvm/Support/Host.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/TargetParser/Host.h"
 #include <algorithm>
 #include <cassert>
 #include <cstring>
diff --git a/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp b/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp
index 97b41fc68917..31404855e3b1 100644
--- a/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp
+++ b/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp
@@ -181,7 +181,11 @@ static bool shouldCacheStatFailures(StringRef Filename) {
   StringRef Ext = llvm::sys::path::extension(Filename);
   if (Ext.empty())
     return false; // This may be the module cache directory.
-  // Only cache stat failures on source files.
+  // Only cache stat failures on files that are not expected to change during
+  // the build.
+  StringRef FName = llvm::sys::path::filename(Filename);
+  if (FName == "module.modulemap" || FName == "module.map")
+    return true;
   return shouldScanForDirectivesBasedOnExtension(Filename);
 }
 
@@ -258,6 +262,9 @@ DependencyScanningWorkerFilesystem::status(const Twine &Path) {
   SmallString<256> OwnedFilename;
   StringRef Filename = Path.toStringRef(OwnedFilename);
 
+  if (Filename.endswith(".pcm"))
+    return getUnderlyingFS().status(Path);
+
   llvm::ErrorOr<EntryRef> Result = getOrCreateFileSystemEntry(Filename);
   if (!Result)
     return Result.getError();
@@ -315,6 +322,9 @@ DependencyScanningWorkerFilesystem::openFileForRead(const Twine &Path) {
   SmallString<256> OwnedFilename;
   StringRef Filename = Path.toStringRef(OwnedFilename);
 
+  if (Filename.endswith(".pcm"))
+    return getUnderlyingFS().openFileForRead(Path);
+
   llvm::ErrorOr<EntryRef> Result = getOrCreateFileSystemEntry(Filename);
   if (!Result)
     return Result.getError();
diff --git a/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/DependencyScanningTool.cpp b/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/DependencyScanningTool.cpp
index ae1662237e87..6641518b572b 100644
--- a/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/DependencyScanningTool.cpp
+++ b/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/DependencyScanningTool.cpp
@@ -14,27 +14,6 @@ using namespace clang;
 using namespace tooling;
 using namespace dependencies;
 
-static std::vector<std::string>
-makeTUCommandLineWithoutPaths(ArrayRef<std::string> OriginalCommandLine) {
-  std::vector<std::string> Args = OriginalCommandLine;
-
-  Args.push_back("-fno-implicit-modules");
-  Args.push_back("-fno-implicit-module-maps");
-
-  // These arguments are unused in explicit compiles.
-  llvm::erase_if(Args, [](StringRef Arg) {
-    if (Arg.consume_front("-fmodules-")) {
-      return Arg.startswith("cache-path=") ||
-             Arg.startswith("prune-interval=") ||
-             Arg.startswith("prune-after=") ||
-             Arg == "validate-once-per-build-session";
-    }
-    return Arg.startswith("-fbuild-session-file=");
-  });
-
-  return Args;
-}
-
 DependencyScanningTool::DependencyScanningTool(
     DependencyScanningService &Service,
     llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS)
@@ -67,11 +46,6 @@ public:
 
   void handleContextHash(std::string Hash) override {}
 
-  std::string lookupModuleOutput(const ModuleID &ID,
-                                 ModuleOutputKind Kind) override {
-    llvm::report_fatal_error("unexpected call to lookupModuleOutput");
-  }
-
   void printDependencies(std::string &S) {
     assert(Opts && "Handled dependency output options.");
 
@@ -101,11 +75,11 @@ protected:
 } // anonymous namespace
 
 llvm::Expected<std::string> DependencyScanningTool::getDependencyFile(
-    const std::vector<std::string> &CommandLine, StringRef CWD,
-    std::optional<StringRef> ModuleName) {
+    const std::vector<std::string> &CommandLine, StringRef CWD) {
   MakeDependencyPrinterConsumer Consumer;
+  CallbackActionController Controller(nullptr);
   auto Result =
-      Worker.computeDependencies(CWD, CommandLine, Consumer, ModuleName);
+      Worker.computeDependencies(CWD, CommandLine, Consumer, Controller);
   if (Result)
     return std::move(Result);
   std::string Output;
@@ -114,8 +88,8 @@ llvm::Expected<std::string> DependencyScanningTool::getDependencyFile(
 }
 
 llvm::Expected<P1689Rule> DependencyScanningTool::getP1689ModuleDependencyFile(
-    const CompileCommand &Command, StringRef CWD,
-    std::string &MakeformatOutput, std::string &MakeformatOutputPath) {
+    const CompileCommand &Command, StringRef CWD, std::string &MakeformatOutput,
+    std::string &MakeformatOutputPath) {
   class P1689ModuleDependencyPrinterConsumer
       : public MakeDependencyPrinterConsumer {
   public:
@@ -145,9 +119,20 @@ llvm::Expected<P1689Rule> DependencyScanningTool::getP1689ModuleDependencyFile(
     P1689Rule &Rule;
   };
 
+  class P1689ActionController : public DependencyActionController {
+  public:
+    // The lookupModuleOutput is for clang modules. P1689 format don't need it.
+    std::string lookupModuleOutput(const ModuleID &,
+                                   ModuleOutputKind Kind) override {
+      return "";
+    }
+  };
+
   P1689Rule Rule;
   P1689ModuleDependencyPrinterConsumer Consumer(Rule, Command);
-  auto Result = Worker.computeDependencies(CWD, Command.CommandLine, Consumer);
+  P1689ActionController Controller;
+  auto Result = Worker.computeDependencies(CWD, Command.CommandLine, Consumer,
+                                           Controller);
   if (Result)
     return std::move(Result);
 
@@ -157,102 +142,68 @@ llvm::Expected<P1689Rule> DependencyScanningTool::getP1689ModuleDependencyFile(
   return Rule;
 }
 
-llvm::Expected<FullDependenciesResult>
-DependencyScanningTool::getFullDependencies(
+llvm::Expected<TranslationUnitDeps>
+DependencyScanningTool::getTranslationUnitDependencies(
     const std::vector<std::string> &CommandLine, StringRef CWD,
     const llvm::StringSet<> &AlreadySeen,
-    LookupModuleOutputCallback LookupModuleOutput,
-    std::optional<StringRef> ModuleName) {
-  FullDependencyConsumer Consumer(AlreadySeen, LookupModuleOutput,
-                                  Worker.shouldEagerLoadModules());
+    LookupModuleOutputCallback LookupModuleOutput) {
+  FullDependencyConsumer Consumer(AlreadySeen);
+  CallbackActionController Controller(LookupModuleOutput);
   llvm::Error Result =
-      Worker.computeDependencies(CWD, CommandLine, Consumer, ModuleName);
+      Worker.computeDependencies(CWD, CommandLine, Consumer, Controller);
   if (Result)
     return std::move(Result);
-  return Consumer.takeFullDependencies();
+  return Consumer.takeTranslationUnitDeps();
 }
 
-llvm::Expected<FullDependenciesResult>
-DependencyScanningTool::getFullDependenciesLegacyDriverCommand(
-    const std::vector<std::string> &CommandLine, StringRef CWD,
-    const llvm::StringSet<> &AlreadySeen,
-    LookupModuleOutputCallback LookupModuleOutput,
-    std::optional<StringRef> ModuleName) {
-  FullDependencyConsumer Consumer(AlreadySeen, LookupModuleOutput,
-                                  Worker.shouldEagerLoadModules());
-  llvm::Error Result =
-      Worker.computeDependencies(CWD, CommandLine, Consumer, ModuleName);
+llvm::Expected<ModuleDepsGraph> DependencyScanningTool::getModuleDependencies(
+    StringRef ModuleName, const std::vector<std::string> &CommandLine,
+    StringRef CWD, const llvm::StringSet<> &AlreadySeen,
+    LookupModuleOutputCallback LookupModuleOutput) {
+  FullDependencyConsumer Consumer(AlreadySeen);
+  CallbackActionController Controller(LookupModuleOutput);
+  llvm::Error Result = Worker.computeDependencies(CWD, CommandLine, Consumer,
+                                                  Controller, ModuleName);
   if (Result)
     return std::move(Result);
-  return Consumer.getFullDependenciesLegacyDriverCommand(CommandLine);
+  return Consumer.takeModuleGraphDeps();
 }
 
-FullDependenciesResult FullDependencyConsumer::takeFullDependencies() {
-  FullDependenciesResult FDR;
-  FullDependencies &FD = FDR.FullDeps;
+TranslationUnitDeps FullDependencyConsumer::takeTranslationUnitDeps() {
+  TranslationUnitDeps TU;
 
-  FD.ID.ContextHash = std::move(ContextHash);
-  FD.FileDeps = std::move(Dependencies);
-  FD.PrebuiltModuleDeps = std::move(PrebuiltModuleDeps);
-  FD.Commands = std::move(Commands);
+  TU.ID.ContextHash = std::move(ContextHash);
+  TU.FileDeps = std::move(Dependencies);
+  TU.PrebuiltModuleDeps = std::move(PrebuiltModuleDeps);
+  TU.Commands = std::move(Commands);
 
   for (auto &&M : ClangModuleDeps) {
     auto &MD = M.second;
     if (MD.ImportedByMainFile)
-      FD.ClangModuleDeps.push_back(MD.ID);
+      TU.ClangModuleDeps.push_back(MD.ID);
     // TODO: Avoid handleModuleDependency even being called for modules
     //   we've already seen.
     if (AlreadySeen.count(M.first))
       continue;
-    FDR.DiscoveredModules.push_back(std::move(MD));
+    TU.ModuleGraph.push_back(std::move(MD));
   }
 
-  return FDR;
+  return TU;
 }
 
-FullDependenciesResult
-FullDependencyConsumer::getFullDependenciesLegacyDriverCommand(
-    const std::vector<std::string> &OriginalCommandLine) const {
-  FullDependencies FD;
-
-  FD.DriverCommandLine = makeTUCommandLineWithoutPaths(
-      ArrayRef<std::string>(OriginalCommandLine).slice(1));
-
-  FD.ID.ContextHash = std::move(ContextHash);
-
-  FD.FileDeps.assign(Dependencies.begin(), Dependencies.end());
-
-  for (const PrebuiltModuleDep &PMD : PrebuiltModuleDeps)
-    FD.DriverCommandLine.push_back("-fmodule-file=" + PMD.PCMFile);
+ModuleDepsGraph FullDependencyConsumer::takeModuleGraphDeps() {
+  ModuleDepsGraph ModuleGraph;
 
   for (auto &&M : ClangModuleDeps) {
     auto &MD = M.second;
-    if (MD.ImportedByMainFile) {
-      FD.ClangModuleDeps.push_back(MD.ID);
-      auto PCMPath = LookupModuleOutput(MD.ID, ModuleOutputKind::ModuleFile);
-      if (EagerLoadModules) {
-        FD.DriverCommandLine.push_back("-fmodule-file=" + PCMPath);
-      } else {
-        FD.DriverCommandLine.push_back("-fmodule-map-file=" +
-                                       MD.ClangModuleMapFile);
-        FD.DriverCommandLine.push_back("-fmodule-file=" + MD.ID.ModuleName +
-                                       "=" + PCMPath);
-      }
-    }
-  }
-
-  FD.PrebuiltModuleDeps = std::move(PrebuiltModuleDeps);
-
-  FullDependenciesResult FDR;
-
-  for (auto &&M : ClangModuleDeps) {
     // TODO: Avoid handleModuleDependency even being called for modules
     //   we've already seen.
     if (AlreadySeen.count(M.first))
       continue;
-    FDR.DiscoveredModules.push_back(std::move(M.second));
+    ModuleGraph.push_back(std::move(MD));
   }
 
-  FDR.FullDeps = std::move(FD);
-  return FDR;
+  return ModuleGraph;
 }
+
+CallbackActionController::~CallbackActionController() {}
diff --git a/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp b/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp
index 8eb0328d6322..28206dceadd9 100644
--- a/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp
+++ b/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "clang/Tooling/DependencyScanning/DependencyScanningWorker.h"
+#include "clang/Basic/DiagnosticDriver.h"
 #include "clang/Basic/DiagnosticFrontend.h"
 #include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
 #include "clang/Driver/Compilation.h"
@@ -22,7 +23,9 @@
 #include "clang/Tooling/DependencyScanning/DependencyScanningService.h"
 #include "clang/Tooling/DependencyScanning/ModuleDepCollector.h"
 #include "clang/Tooling/Tooling.h"
-#include "llvm/Support/Host.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/Error.h"
+#include "llvm/TargetParser/Host.h"
 #include <optional>
 
 using namespace clang;
@@ -63,30 +66,19 @@ using PrebuiltModuleFilesT = decltype(HeaderSearchOptions::PrebuiltModuleFiles);
 class PrebuiltModuleListener : public ASTReaderListener {
 public:
   PrebuiltModuleListener(PrebuiltModuleFilesT &PrebuiltModuleFiles,
-                         llvm::StringSet<> &InputFiles, bool VisitInputFiles,
                          llvm::SmallVector<std::string> &NewModuleFiles)
-      : PrebuiltModuleFiles(PrebuiltModuleFiles), InputFiles(InputFiles),
-        VisitInputFiles(VisitInputFiles), NewModuleFiles(NewModuleFiles) {}
+      : PrebuiltModuleFiles(PrebuiltModuleFiles),
+        NewModuleFiles(NewModuleFiles) {}
 
   bool needsImportVisitation() const override { return true; }
-  bool needsInputFileVisitation() override { return VisitInputFiles; }
-  bool needsSystemInputFileVisitation() override { return VisitInputFiles; }
 
   void visitImport(StringRef ModuleName, StringRef Filename) override {
     if (PrebuiltModuleFiles.insert({ModuleName.str(), Filename.str()}).second)
       NewModuleFiles.push_back(Filename.str());
   }
 
-  bool visitInputFile(StringRef Filename, bool isSystem, bool isOverridden,
-                      bool isExplicitModule) override {
-    InputFiles.insert(Filename);
-    return true;
-  }
-
 private:
   PrebuiltModuleFilesT &PrebuiltModuleFiles;
-  llvm::StringSet<> &InputFiles;
-  bool VisitInputFiles;
   llvm::SmallVector<std::string> &NewModuleFiles;
 };
 
@@ -94,13 +86,10 @@ private:
 /// transitively imports and contributing input files.
 static void visitPrebuiltModule(StringRef PrebuiltModuleFilename,
                                 CompilerInstance &CI,
-                                PrebuiltModuleFilesT &ModuleFiles,
-                                llvm::StringSet<> &InputFiles,
-                                bool VisitInputFiles) {
+                                PrebuiltModuleFilesT &ModuleFiles) {
   // List of module files to be processed.
   llvm::SmallVector<std::string> Worklist{PrebuiltModuleFilename.str()};
-  PrebuiltModuleListener Listener(ModuleFiles, InputFiles, VisitInputFiles,
-                                  Worklist);
+  PrebuiltModuleListener Listener(ModuleFiles, Worklist);
 
   while (!Worklist.empty())
     ASTReader::readASTFileControlBlock(
@@ -146,13 +135,14 @@ class DependencyScanningAction : public tooling::ToolAction {
 public:
   DependencyScanningAction(
       StringRef WorkingDirectory, DependencyConsumer &Consumer,
+      DependencyActionController &Controller,
       llvm::IntrusiveRefCntPtr<DependencyScanningWorkerFilesystem> DepFS,
       ScanningOutputFormat Format, bool OptimizeArgs, bool EagerLoadModules,
       bool DisableFree, std::optional<StringRef> ModuleName = std::nullopt)
       : WorkingDirectory(WorkingDirectory), Consumer(Consumer),
-        DepFS(std::move(DepFS)), Format(Format), OptimizeArgs(OptimizeArgs),
-        EagerLoadModules(EagerLoadModules), DisableFree(DisableFree),
-        ModuleName(ModuleName) {}
+        Controller(Controller), DepFS(std::move(DepFS)), Format(Format),
+        OptimizeArgs(OptimizeArgs), EagerLoadModules(EagerLoadModules),
+        DisableFree(DisableFree), ModuleName(ModuleName) {}
 
   bool runInvocation(std::shared_ptr<CompilerInvocation> Invocation,
                      FileManager *FileMgr,
@@ -191,6 +181,7 @@ public:
     ScanInstance.getFrontendOpts().GenerateGlobalModuleIndex = false;
     ScanInstance.getFrontendOpts().UseGlobalModuleIndex = false;
     ScanInstance.getFrontendOpts().ModulesShareFileManager = false;
+    ScanInstance.getHeaderSearchOpts().ModuleFormat = "raw";
 
     ScanInstance.setFileManager(FileMgr);
     // Support for virtual file system overlays.
@@ -200,15 +191,13 @@ public:
 
     ScanInstance.createSourceManager(*FileMgr);
 
-    llvm::StringSet<> PrebuiltModulesInputFiles;
     // Store the list of prebuilt module files into header search options. This
     // will prevent the implicit build to create duplicate modules and will
     // force reuse of the existing prebuilt module files instead.
     if (!ScanInstance.getPreprocessorOpts().ImplicitPCHInclude.empty())
       visitPrebuiltModule(
           ScanInstance.getPreprocessorOpts().ImplicitPCHInclude, ScanInstance,
-          ScanInstance.getHeaderSearchOpts().PrebuiltModuleFiles,
-          PrebuiltModulesInputFiles, /*VisitInputFiles=*/DepFS != nullptr);
+          ScanInstance.getHeaderSearchOpts().PrebuiltModuleFiles);
 
     // Use the dependency scanning optimized file system if requested to do so.
     if (DepFS) {
@@ -250,8 +239,8 @@ public:
     case ScanningOutputFormat::P1689:
     case ScanningOutputFormat::Full:
       MDC = std::make_shared<ModuleDepCollector>(
-          std::move(Opts), ScanInstance, Consumer, OriginalInvocation,
-          OptimizeArgs, EagerLoadModules,
+          std::move(Opts), ScanInstance, Consumer, Controller,
+          OriginalInvocation, OptimizeArgs, EagerLoadModules,
           Format == ScanningOutputFormat::P1689);
       ScanInstance.addDependencyCollector(MDC);
       break;
@@ -264,6 +253,9 @@ public:
     // context hashing.
     ScanInstance.getHeaderSearchOpts().ModulesStrictContextHash = true;
 
+    // Avoid some checks and module map parsing when loading PCM files.
+    ScanInstance.getPreprocessorOpts().ModulesCheckRelocated = false;
+
     std::unique_ptr<FrontendAction> Action;
 
     if (ModuleName)
@@ -300,6 +292,7 @@ private:
 private:
   StringRef WorkingDirectory;
   DependencyConsumer &Consumer;
+  DependencyActionController &Controller;
   llvm::IntrusiveRefCntPtr<DependencyScanningWorkerFilesystem> DepFS;
   ScanningOutputFormat Format;
   bool OptimizeArgs;
@@ -320,12 +313,11 @@ DependencyScanningWorker::DependencyScanningWorker(
     : Format(Service.getFormat()), OptimizeArgs(Service.canOptimizeArgs()),
       EagerLoadModules(Service.shouldEagerLoadModules()) {
   PCHContainerOps = std::make_shared<PCHContainerOperations>();
+  // We need to read object files from PCH built outside the scanner.
   PCHContainerOps->registerReader(
       std::make_unique<ObjectFilePCHContainerReader>());
-  // We don't need to write object files, but the current PCH implementation
-  // requires the writer to be registered as well.
-  PCHContainerOps->registerWriter(
-      std::make_unique<ObjectFilePCHContainerWriter>());
+  // The scanner itself writes only raw ast files.
+  PCHContainerOps->registerWriter(std::make_unique<RawPCHContainerWriter>());
 
   switch (Service.getMode()) {
   case ScanningMode::DependencyDirectivesScan:
@@ -342,7 +334,8 @@ DependencyScanningWorker::DependencyScanningWorker(
 
 llvm::Error DependencyScanningWorker::computeDependencies(
     StringRef WorkingDirectory, const std::vector<std::string> &CommandLine,
-    DependencyConsumer &Consumer, std::optional<StringRef> ModuleName) {
+    DependencyConsumer &Consumer, DependencyActionController &Controller,
+    std::optional<StringRef> ModuleName) {
   std::vector<const char *> CLI;
   for (const std::string &Arg : CommandLine)
     CLI.push_back(Arg.c_str());
@@ -355,24 +348,37 @@ llvm::Error DependencyScanningWorker::computeDependencies(
   llvm::raw_string_ostream DiagnosticsOS(DiagnosticOutput);
   TextDiagnosticPrinter DiagPrinter(DiagnosticsOS, DiagOpts.release());
 
-  if (computeDependencies(WorkingDirectory, CommandLine, Consumer, DiagPrinter,
-                          ModuleName))
+  if (computeDependencies(WorkingDirectory, CommandLine, Consumer, Controller,
+                          DiagPrinter, ModuleName))
     return llvm::Error::success();
   return llvm::make_error<llvm::StringError>(DiagnosticsOS.str(),
                                              llvm::inconvertibleErrorCode());
 }
 
 static bool forEachDriverJob(
-    ArrayRef<std::string> Args, DiagnosticsEngine &Diags, FileManager &FM,
+    ArrayRef<std::string> ArgStrs, DiagnosticsEngine &Diags, FileManager &FM,
     llvm::function_ref<bool(const driver::Command &Cmd)> Callback) {
+  SmallVector<const char *, 256> Argv;
+  Argv.reserve(ArgStrs.size());
+  for (const std::string &Arg : ArgStrs)
+    Argv.push_back(Arg.c_str());
+
+  llvm::vfs::FileSystem *FS = &FM.getVirtualFileSystem();
+
   std::unique_ptr<driver::Driver> Driver = std::make_unique<driver::Driver>(
-      Args[0], llvm::sys::getDefaultTargetTriple(), Diags,
-      "clang LLVM compiler", &FM.getVirtualFileSystem());
+      Argv[0], llvm::sys::getDefaultTargetTriple(), Diags,
+      "clang LLVM compiler", FS);
   Driver->setTitle("clang_based_tool");
 
-  std::vector<const char *> Argv;
-  for (const std::string &Arg : Args)
-    Argv.push_back(Arg.c_str());
+  llvm::BumpPtrAllocator Alloc;
+  bool CLMode = driver::IsClangCL(
+      driver::getDriverMode(Argv[0], ArrayRef(Argv).slice(1)));
+
+  if (llvm::Error E = driver::expandResponseFiles(Argv, CLMode, Alloc, FS)) {
+    Diags.Report(diag::err_drv_expand_response_file)
+        << llvm::toString(std::move(E));
+    return false;
+  }
 
   const std::unique_ptr<driver::Compilation> Compilation(
       Driver->BuildCompilation(llvm::ArrayRef(Argv)));
@@ -388,37 +394,47 @@ static bool forEachDriverJob(
 
 bool DependencyScanningWorker::computeDependencies(
     StringRef WorkingDirectory, const std::vector<std::string> &CommandLine,
-    DependencyConsumer &Consumer, DiagnosticConsumer &DC,
-    std::optional<StringRef> ModuleName) {
+    DependencyConsumer &Consumer, DependencyActionController &Controller,
+    DiagnosticConsumer &DC, std::optional<StringRef> ModuleName) {
   // Reset what might have been modified in the previous worker invocation.
   BaseFS->setCurrentWorkingDirectory(WorkingDirectory);
 
   std::optional<std::vector<std::string>> ModifiedCommandLine;
   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> ModifiedFS;
-  if (ModuleName) {
-    ModifiedCommandLine = CommandLine;
-    ModifiedCommandLine->emplace_back(*ModuleName);
 
+  // If we're scanning based on a module name alone, we don't expect the client
+  // to provide us with an input file. However, the driver really wants to have
+  // one. Let's just make it up to make the driver happy.
+  if (ModuleName) {
     auto OverlayFS =
         llvm::makeIntrusiveRefCnt<llvm::vfs::OverlayFileSystem>(BaseFS);
     auto InMemoryFS =
         llvm::makeIntrusiveRefCnt<llvm::vfs::InMemoryFileSystem>();
     InMemoryFS->setCurrentWorkingDirectory(WorkingDirectory);
-    InMemoryFS->addFile(*ModuleName, 0, llvm::MemoryBuffer::getMemBuffer(""));
     OverlayFS->pushOverlay(InMemoryFS);
     ModifiedFS = OverlayFS;
+
+    SmallString<128> FakeInputPath;
+    // TODO: We should retry the creation if the path already exists.
+    llvm::sys::fs::createUniquePath(*ModuleName + "-%%%%%%%%.input",
+                                    FakeInputPath,
+                                    /*MakeAbsolute=*/false);
+    InMemoryFS->addFile(FakeInputPath, 0, llvm::MemoryBuffer::getMemBuffer(""));
+
+    ModifiedCommandLine = CommandLine;
+    ModifiedCommandLine->emplace_back(FakeInputPath);
   }
 
   const std::vector<std::string> &FinalCommandLine =
       ModifiedCommandLine ? *ModifiedCommandLine : CommandLine;
+  auto &FinalFS = ModifiedFS ? ModifiedFS : BaseFS;
 
   FileSystemOptions FSOpts;
   FSOpts.WorkingDir = WorkingDirectory.str();
-  auto FileMgr = llvm::makeIntrusiveRefCnt<FileManager>(
-      FSOpts, ModifiedFS ? ModifiedFS : BaseFS);
+  auto FileMgr = llvm::makeIntrusiveRefCnt<FileManager>(FSOpts, FinalFS);
 
-  std::vector<const char *> FinalCCommandLine(CommandLine.size(), nullptr);
-  llvm::transform(CommandLine, FinalCCommandLine.begin(),
+  std::vector<const char *> FinalCCommandLine(FinalCommandLine.size(), nullptr);
+  llvm::transform(FinalCommandLine, FinalCCommandLine.begin(),
                   [](const std::string &Str) { return Str.c_str(); });
 
   auto DiagOpts = CreateAndPopulateDiagOpts(FinalCCommandLine);
@@ -435,9 +451,9 @@ bool DependencyScanningWorker::computeDependencies(
   // in-process; preserve the original value, which is
   // always true for a driver invocation.
   bool DisableFree = true;
-  DependencyScanningAction Action(WorkingDirectory, Consumer, DepFS, Format,
-                                  OptimizeArgs, EagerLoadModules, DisableFree,
-                                  ModuleName);
+  DependencyScanningAction Action(WorkingDirectory, Consumer, Controller, DepFS,
+                                  Format, OptimizeArgs, EagerLoadModules,
+                                  DisableFree, ModuleName);
   bool Success = forEachDriverJob(
       FinalCommandLine, *Diags, *FileMgr, [&](const driver::Command &Cmd) {
         if (StringRef(Cmd.getCreator().getName()) != "clang") {
@@ -475,3 +491,5 @@ bool DependencyScanningWorker::computeDependencies(
         << llvm::join(FinalCommandLine, " ");
   return Success && Action.hasScanned();
 }
+
+DependencyActionController::~DependencyActionController() {}
diff --git a/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp b/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp
index d1cbf79a843e..aac24ca724aa 100644
--- a/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp
+++ b/contrib/llvm-project/clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp
@@ -56,16 +56,16 @@ static std::vector<std::string> splitString(std::string S, char Separator) {
 void ModuleDepCollector::addOutputPaths(CompilerInvocation &CI,
                                         ModuleDeps &Deps) {
   CI.getFrontendOpts().OutputFile =
-      Consumer.lookupModuleOutput(Deps.ID, ModuleOutputKind::ModuleFile);
+      Controller.lookupModuleOutput(Deps.ID, ModuleOutputKind::ModuleFile);
   if (!CI.getDiagnosticOpts().DiagnosticSerializationFile.empty())
     CI.getDiagnosticOpts().DiagnosticSerializationFile =
-        Consumer.lookupModuleOutput(
+        Controller.lookupModuleOutput(
             Deps.ID, ModuleOutputKind::DiagnosticSerializationFile);
   if (!CI.getDependencyOutputOpts().OutputFile.empty()) {
-    CI.getDependencyOutputOpts().OutputFile =
-        Consumer.lookupModuleOutput(Deps.ID, ModuleOutputKind::DependencyFile);
+    CI.getDependencyOutputOpts().OutputFile = Controller.lookupModuleOutput(
+        Deps.ID, ModuleOutputKind::DependencyFile);
     CI.getDependencyOutputOpts().Targets =
-        splitString(Consumer.lookupModuleOutput(
+        splitString(Controller.lookupModuleOutput(
                         Deps.ID, ModuleOutputKind::DependencyTargets),
                     '\0');
     if (!CI.getDependencyOutputOpts().OutputFile.empty() &&
@@ -100,6 +100,8 @@ ModuleDepCollector::makeInvocationForModuleBuildWithoutOutputs(
   if (!CI.getLangOpts()->ModulesCodegen) {
     CI.getCodeGenOpts().DebugCompilationDir.clear();
     CI.getCodeGenOpts().CoverageCompilationDir.clear();
+    CI.getCodeGenOpts().CoverageDataFile.clear();
+    CI.getCodeGenOpts().CoverageNotesFile.clear();
   }
 
   // Map output paths that affect behaviour to "-" so their existence is in the
@@ -111,6 +113,9 @@ ModuleDepCollector::makeInvocationForModuleBuildWithoutOutputs(
   CI.getDependencyOutputOpts().Targets.clear();
 
   CI.getFrontendOpts().ProgramAction = frontend::GenerateModule;
+  CI.getFrontendOpts().ARCMTAction = FrontendOptions::ARCMT_None;
+  CI.getFrontendOpts().ObjCMTAction = FrontendOptions::ObjCMT_None;
+  CI.getFrontendOpts().MTMigrateDir.clear();
   CI.getLangOpts()->ModuleName = Deps.ID.ModuleName;
   CI.getFrontendOpts().IsSystemModule = Deps.IsSystem;
 
@@ -202,7 +207,7 @@ void ModuleDepCollector::addModuleFiles(
     CompilerInvocation &CI, ArrayRef<ModuleID> ClangModuleDeps) const {
   for (const ModuleID &MID : ClangModuleDeps) {
     std::string PCMPath =
-        Consumer.lookupModuleOutput(MID, ModuleOutputKind::ModuleFile);
+        Controller.lookupModuleOutput(MID, ModuleOutputKind::ModuleFile);
     if (EagerLoadModules)
       CI.getFrontendOpts().ModuleFiles.push_back(std::move(PCMPath));
     else
@@ -233,7 +238,7 @@ void ModuleDepCollector::applyDiscoveredDependencies(CompilerInvocation &CI) {
                   .getModuleMap()
                   .getModuleMapFileForUniquing(CurrentModule))
         CI.getFrontendOpts().ModuleMapFiles.emplace_back(
-            CurrentModuleMap->getName());
+            CurrentModuleMap->getNameAsRequested());
 
     SmallVector<ModuleID> DirectDeps;
     for (const auto &KV : ModularDeps)
@@ -264,13 +269,12 @@ static std::string getModuleContextHash(const ModuleDeps &MD,
   HashBuilder.add(serialization::VERSION_MAJOR, serialization::VERSION_MINOR);
 
   // Hash the BuildInvocation without any input files.
-  SmallVector<const char *, 32> DummyArgs;
-  CI.generateCC1CommandLine(DummyArgs, [&](const Twine &Arg) {
-    Scratch.clear();
-    StringRef Str = Arg.toStringRef(Scratch);
-    HashBuilder.add(Str);
-    return "<unused>";
-  });
+  SmallVector<const char *, 32> Args;
+  llvm::BumpPtrAllocator Alloc;
+  llvm::StringSaver Saver(Alloc);
+  CI.generateCC1CommandLine(
+      Args, [&](const Twine &Arg) { return Saver.save(Arg).data(); });
+  HashBuilder.addRange(Args);
 
   // Hash the module dependencies. These paths may differ even if the invocation
   // is identical if they depend on the contents of the files in the TU -- for
@@ -299,11 +303,12 @@ void ModuleDepCollector::associateWithContextHash(const CompilerInvocation &CI,
   assert(Inserted && "duplicate module mapping");
 }
 
-void ModuleDepCollectorPP::FileChanged(SourceLocation Loc,
-                                       FileChangeReason Reason,
-                                       SrcMgr::CharacteristicKind FileType,
-                                       FileID PrevFID) {
-  if (Reason != PPCallbacks::EnterFile)
+void ModuleDepCollectorPP::LexedFileChanged(FileID FID,
+                                            LexedFileChangeReason Reason,
+                                            SrcMgr::CharacteristicKind FileType,
+                                            FileID PrevFID,
+                                            SourceLocation Loc) {
+  if (Reason != LexedFileChangeReason::EnterFile)
     return;
 
   // This has to be delayed as the context hash can change at the start of
@@ -318,8 +323,7 @@ void ModuleDepCollectorPP::FileChanged(SourceLocation Loc,
   // Dependency generation really does want to go all the way to the
   // file entry for a source location to find out what is depended on.
   // We do not want #line markers to affect dependency generation!
-  if (std::optional<StringRef> Filename =
-          SM.getNonBuiltinFilenameForID(SM.getFileID(SM.getExpansionLoc(Loc))))
+  if (std::optional<StringRef> Filename = SM.getNonBuiltinFilenameForID(FID))
     MDC.addFileDep(llvm::sys::path::remove_leading_dotslash(*Filename));
 }
 
@@ -496,8 +500,7 @@ static void forEachSubmoduleSorted(const Module *M,
   // Submodule order depends on order of header includes for inferred submodules
   // we don't care about the exact order, so sort so that it's consistent across
   // TUs to improve sharing.
-  SmallVector<const Module *> Submodules(M->submodule_begin(),
-                                         M->submodule_end());
+  SmallVector<const Module *> Submodules(M->submodules());
   llvm::stable_sort(Submodules, [](const Module *A, const Module *B) {
     return A->Name < B->Name;
   });
@@ -575,11 +578,11 @@ void ModuleDepCollectorPP::addAffectingClangModule(
 ModuleDepCollector::ModuleDepCollector(
     std::unique_ptr<DependencyOutputOptions> Opts,
     CompilerInstance &ScanInstance, DependencyConsumer &C,
-    CompilerInvocation OriginalCI, bool OptimizeArgs, bool EagerLoadModules,
-    bool IsStdModuleP1689Format)
-    : ScanInstance(ScanInstance), Consumer(C), Opts(std::move(Opts)),
-      OriginalInvocation(std::move(OriginalCI)), OptimizeArgs(OptimizeArgs),
-      EagerLoadModules(EagerLoadModules),
+    DependencyActionController &Controller, CompilerInvocation OriginalCI,
+    bool OptimizeArgs, bool EagerLoadModules, bool IsStdModuleP1689Format)
+    : ScanInstance(ScanInstance), Consumer(C), Controller(Controller),
+      Opts(std::move(Opts)), OriginalInvocation(std::move(OriginalCI)),
+      OptimizeArgs(OptimizeArgs), EagerLoadModules(EagerLoadModules),
       IsStdModuleP1689Format(IsStdModuleP1689Format) {}
 
 void ModuleDepCollector::attachToPreprocessor(Preprocessor &PP) {
diff --git a/contrib/llvm-project/clang/lib/Tooling/DumpTool/ClangSrcLocDump.cpp b/contrib/llvm-project/clang/lib/Tooling/DumpTool/ClangSrcLocDump.cpp
index e67ffb037095..f48fbb0f3c6a 100644
--- a/contrib/llvm-project/clang/lib/Tooling/DumpTool/ClangSrcLocDump.cpp
+++ b/contrib/llvm-project/clang/lib/Tooling/DumpTool/ClangSrcLocDump.cpp
@@ -18,8 +18,8 @@
 #include "clang/Tooling/Tooling.h"

 #include "llvm/Option/ArgList.h"

 #include "llvm/Support/CommandLine.h"

-#include "llvm/Support/Host.h"

 #include "llvm/Support/JSON.h"

+#include "llvm/TargetParser/Host.h"

 

 #include "ASTSrcLocProcessor.h"

 

diff --git a/contrib/llvm-project/clang/lib/Tooling/ExpandResponseFilesCompilationDatabase.cpp b/contrib/llvm-project/clang/lib/Tooling/ExpandResponseFilesCompilationDatabase.cpp
index 88d20ba3957d..ebf8aa2a7628 100644
--- a/contrib/llvm-project/clang/lib/Tooling/ExpandResponseFilesCompilationDatabase.cpp
+++ b/contrib/llvm-project/clang/lib/Tooling/ExpandResponseFilesCompilationDatabase.cpp
@@ -7,15 +7,16 @@
 //===----------------------------------------------------------------------===//
 
 #include "clang/Tooling/CompilationDatabase.h"
+#include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Triple.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/ErrorOr.h"
-#include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/StringSaver.h"
+#include "llvm/TargetParser/Host.h"
+#include "llvm/TargetParser/Triple.h"
 
 namespace clang {
 namespace tooling {
@@ -48,28 +49,9 @@ public:
 
 private:
   std::vector<CompileCommand> expand(std::vector<CompileCommand> Cmds) const {
-    for (auto &Cmd : Cmds) {
-      bool SeenRSPFile = false;
-      llvm::SmallVector<const char *, 20> Argv;
-      Argv.reserve(Cmd.CommandLine.size());
-      for (auto &Arg : Cmd.CommandLine) {
-        Argv.push_back(Arg.c_str());
-        if (!Arg.empty())
-          SeenRSPFile |= Arg.front() == '@';
-      }
-      if (!SeenRSPFile)
-        continue;
-      llvm::BumpPtrAllocator Alloc;
-      llvm::cl::ExpansionContext ECtx(Alloc, Tokenizer);
-      llvm::Error Err = ECtx.setVFS(FS.get())
-                            .setCurrentDir(Cmd.Directory)
-                            .expandResponseFiles(Argv);
-      if (Err)
-        llvm::errs() << Err;
-      // Don't assign directly, Argv aliases CommandLine.
-      std::vector<std::string> ExpandedArgv(Argv.begin(), Argv.end());
-      Cmd.CommandLine = std::move(ExpandedArgv);
-    }
+    for (auto &Cmd : Cmds)
+      tooling::addExpandedResponseFiles(Cmd.CommandLine, Cmd.Directory,
+                                        Tokenizer, *FS);
     return Cmds;
   }
 
diff --git a/contrib/llvm-project/clang/lib/Tooling/Inclusions/HeaderAnalysis.cpp b/contrib/llvm-project/clang/lib/Tooling/Inclusions/HeaderAnalysis.cpp
index 49d23908d33b..f83e19f10cba 100644
--- a/contrib/llvm-project/clang/lib/Tooling/Inclusions/HeaderAnalysis.cpp
+++ b/contrib/llvm-project/clang/lib/Tooling/Inclusions/HeaderAnalysis.cpp
@@ -67,7 +67,7 @@ llvm::StringRef getFileContents(const FileEntry *FE, const SourceManager &SM) {
 } // namespace
 
 bool isSelfContainedHeader(const FileEntry *FE, const SourceManager &SM,
-                           HeaderSearch &HeaderInfo) {
+                           const HeaderSearch &HeaderInfo) {
   assert(FE);
   if (!HeaderInfo.isFileMultipleIncludeGuarded(FE) &&
       !HeaderInfo.hasFileBeenImported(FE) &&
diff --git a/contrib/llvm-project/clang/lib/Tooling/Inclusions/HeaderIncludes.cpp b/contrib/llvm-project/clang/lib/Tooling/Inclusions/HeaderIncludes.cpp
index 172eff1bf6ab..15a2024c4788 100644
--- a/contrib/llvm-project/clang/lib/Tooling/Inclusions/HeaderIncludes.cpp
+++ b/contrib/llvm-project/clang/lib/Tooling/Inclusions/HeaderIncludes.cpp
@@ -253,7 +253,7 @@ bool IncludeCategoryManager::isMainHeader(StringRef IncludeName) const {
   //  1) foo.h => bar.cc
   //  2) foo.proto.h => foo.cc
   StringRef Matching;
-  if (MatchingFileStem.startswith_insensitive(HeaderStem))
+  if (MatchingFileStem.starts_with_insensitive(HeaderStem))
     Matching = MatchingFileStem; // example 1), 2)
   else if (FileStem.equals_insensitive(HeaderStem))
     Matching = FileStem; // example 3)
@@ -276,6 +276,7 @@ HeaderIncludes::HeaderIncludes(StringRef FileName, StringRef Code,
       MaxInsertOffset(MinInsertOffset +
                       getMaxHeaderInsertionOffset(
                           FileName, Code.drop_front(MinInsertOffset), Style)),
+      MainIncludeFound(false),
       Categories(Style, FileName) {
   // Add 0 for main header and INT_MAX for headers that are not in any
   // category.
@@ -335,7 +336,9 @@ void HeaderIncludes::addExistingInclude(Include IncludeToAdd,
   // Only record the offset of current #include if we can insert after it.
   if (CurInclude.R.getOffset() <= MaxInsertOffset) {
     int Priority = Categories.getIncludePriority(
-        CurInclude.Name, /*CheckMainHeader=*/FirstIncludeOffset < 0);
+        CurInclude.Name, /*CheckMainHeader=*/!MainIncludeFound);
+    if (Priority == 0)
+      MainIncludeFound = true;
     CategoryEndOffsets[Priority] = NextLineOffset;
     IncludesByPriority[Priority].push_back(&CurInclude);
     if (FirstIncludeOffset < 0)
@@ -362,7 +365,7 @@ HeaderIncludes::insert(llvm::StringRef IncludeName, bool IsAngled,
       std::string(llvm::formatv(IsAngled ? "<{0}>" : "\"{0}\"", IncludeName));
   StringRef QuotedName = Quoted;
   int Priority = Categories.getIncludePriority(
-      QuotedName, /*CheckMainHeader=*/FirstIncludeOffset < 0);
+      QuotedName, /*CheckMainHeader=*/!MainIncludeFound);
   auto CatOffset = CategoryEndOffsets.find(Priority);
   assert(CatOffset != CategoryEndOffsets.end());
   unsigned InsertOffset = CatOffset->second; // Fall back offset
diff --git a/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/CSymbolMap.inc b/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/CSymbolMap.inc
new file mode 100644
index 000000000000..463ce921f067
--- /dev/null
+++ b/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/CSymbolMap.inc
@@ -0,0 +1,945 @@
+//===-- gen_std.py generated file -------------------------------*- C++ -*-===//
+//
+// Used to build a lookup table (qualified names => include headers) for C
+// Standard Library symbols.
+//
+// This file was generated automatically by
+// clang/tools/include-mapping/gen_std.py, DO NOT EDIT!
+//
+// Generated from cppreference offline HTML book (modified on 2018-10-28).
+//===----------------------------------------------------------------------===//
+
+SYMBOL(ATOMIC_BOOL_LOCK_FREE, None, <stdatomic.h>)
+SYMBOL(ATOMIC_CHAR16_T_LOCK_FREE, None, <stdatomic.h>)
+SYMBOL(ATOMIC_CHAR32_T_LOCK_FREE, None, <stdatomic.h>)
+SYMBOL(ATOMIC_CHAR_LOCK_FREE, None, <stdatomic.h>)
+SYMBOL(ATOMIC_FLAG_INIT, None, <stdatomic.h>)
+SYMBOL(ATOMIC_INT_LOCK_FREE, None, <stdatomic.h>)
+SYMBOL(ATOMIC_LLONG_LOCK_FREE, None, <stdatomic.h>)
+SYMBOL(ATOMIC_LONG_LOGK_FREE, None, <stdatomic.h>)
+SYMBOL(ATOMIC_POINTER_LOCK_FREE, None, <stdatomic.h>)
+SYMBOL(ATOMIC_SHORT_LOCK_FREE, None, <stdatomic.h>)
+SYMBOL(ATOMIC_VAR_INIT, None, <stdatomic.h>)
+SYMBOL(ATOMIC_WCHAR_T_LOCK_FREE, None, <stdatomic.h>)
+SYMBOL(BUFSIZ, None, <stdio.h>)
+SYMBOL(CHAR_BIT, None, <limits.h>)
+SYMBOL(CHAR_MAX, None, <limits.h>)
+SYMBOL(CHAR_MIN, None, <limits.h>)
+SYMBOL(CLOCKS_PER_SEC, None, <time.h>)
+SYMBOL(CMPLX, None, <complex.h>)
+SYMBOL(CMPLXF, None, <complex.h>)
+SYMBOL(CMPLXL, None, <complex.h>)
+SYMBOL(DBL_DECIMAL_DIG, None, <float.h>)
+SYMBOL(DBL_DIG, None, <float.h>)
+SYMBOL(DBL_EPSILON, None, <float.h>)
+SYMBOL(DBL_HAS_SUBNORM, None, <float.h>)
+SYMBOL(DBL_MANT_DIG, None, <float.h>)
+SYMBOL(DBL_MAX, None, <float.h>)
+SYMBOL(DBL_MAX_10_EXP, None, <float.h>)
+SYMBOL(DBL_MAX_EXP, None, <float.h>)
+SYMBOL(DBL_MIN, None, <float.h>)
+SYMBOL(DBL_MIN_10_EXP, None, <float.h>)
+SYMBOL(DBL_MIN_EXP, None, <float.h>)
+SYMBOL(DBL_TRUE_MIN, None, <float.h>)
+SYMBOL(DECIMAL_DIG, None, <float.h>)
+SYMBOL(EDOM, None, <errno.h>)
+SYMBOL(EILSEQ, None, <errno.h>)
+SYMBOL(EOF, None, <stdio.h>)
+SYMBOL(ERANGE, None, <errno.h>)
+SYMBOL(EXIT_FAILURE, None, <stdlib.h>)
+SYMBOL(EXIT_SUCCESS, None, <stdlib.h>)
+SYMBOL(FE_ALL_EXCEPT, None, <fenv.h>)
+SYMBOL(FE_DFL_ENV, None, <fenv.h>)
+SYMBOL(FE_DIVBYZERO, None, <fenv.h>)
+SYMBOL(FE_DOWNWARD, None, <fenv.h>)
+SYMBOL(FE_INEXACT, None, <fenv.h>)
+SYMBOL(FE_INVALID, None, <fenv.h>)
+SYMBOL(FE_OVERFLOW, None, <fenv.h>)
+SYMBOL(FE_TONEAREST, None, <fenv.h>)
+SYMBOL(FE_TOWARDZERO, None, <fenv.h>)
+SYMBOL(FE_UNDERFLOW, None, <fenv.h>)
+SYMBOL(FE_UPWARD, None, <fenv.h>)
+SYMBOL(FILE, None, <stdio.h>)
+SYMBOL(FILENAME_MAX, None, <stdio.h>)
+SYMBOL(FLT_DECIMAL_DIG, None, <float.h>)
+SYMBOL(FLT_DIG, None, <float.h>)
+SYMBOL(FLT_EPSILON, None, <float.h>)
+SYMBOL(FLT_EVAL_METHOD, None, <float.h>)
+SYMBOL(FLT_HAS_SUBNORM, None, <float.h>)
+SYMBOL(FLT_MANT_DIG, None, <float.h>)
+SYMBOL(FLT_MAX, None, <float.h>)
+SYMBOL(FLT_MAX_10_EXP, None, <float.h>)
+SYMBOL(FLT_MAX_EXP, None, <float.h>)
+SYMBOL(FLT_MIN, None, <float.h>)
+SYMBOL(FLT_MIN_10_EXP, None, <float.h>)
+SYMBOL(FLT_MIN_EXP, None, <float.h>)
+SYMBOL(FLT_RADIX, None, <float.h>)
+SYMBOL(FLT_ROUNDS, None, <float.h>)
+SYMBOL(FLT_TRUE_MIN, None, <float.h>)
+SYMBOL(FOPEN_MAX, None, <stdio.h>)
+SYMBOL(FP_INFINITE, None, <math.h>)
+SYMBOL(FP_NAN, None, <math.h>)
+SYMBOL(FP_NORNAL, None, <math.h>)
+SYMBOL(FP_SUBNORMAL, None, <math.h>)
+SYMBOL(FP_ZERO, None, <math.h>)
+SYMBOL(HUGE_VAL, None, <math.h>)
+SYMBOL(HUGE_VALF, None, <math.h>)
+SYMBOL(HUGE_VALL, None, <math.h>)
+SYMBOL(I, None, <complex.h>)
+SYMBOL(INFINITY, None, <math.h>)
+SYMBOL(INT16_MAX, None, <stdint.h>)
+SYMBOL(INT16_MIN, None, <stdint.h>)
+SYMBOL(INT32_MAX, None, <stdint.h>)
+SYMBOL(INT32_MIN, None, <stdint.h>)
+SYMBOL(INT64_MAX, None, <stdint.h>)
+SYMBOL(INT64_MIN, None, <stdint.h>)
+SYMBOL(INT8_MAX, None, <stdint.h>)
+SYMBOL(INT8_MIN, None, <stdint.h>)
+SYMBOL(INTMAX_MAX, None, <stdint.h>)
+SYMBOL(INTMAX_MIN, None, <stdint.h>)
+SYMBOL(INTPTR_MAX, None, <stdint.h>)
+SYMBOL(INTPTR_MIN, None, <stdint.h>)
+SYMBOL(INT_FAST16_MAX, None, <stdint.h>)
+SYMBOL(INT_FAST16_MIN, None, <stdint.h>)
+SYMBOL(INT_FAST32_MAX, None, <stdint.h>)
+SYMBOL(INT_FAST32_MIN, None, <stdint.h>)
+SYMBOL(INT_FAST64_MAX, None, <stdint.h>)
+SYMBOL(INT_FAST64_MIN, None, <stdint.h>)
+SYMBOL(INT_FAST8_MAX, None, <stdint.h>)
+SYMBOL(INT_FAST8_MIN, None, <stdint.h>)
+SYMBOL(INT_LEAST16_MAX, None, <stdint.h>)
+SYMBOL(INT_LEAST16_MIN, None, <stdint.h>)
+SYMBOL(INT_LEAST32_MAX, None, <stdint.h>)
+SYMBOL(INT_LEAST32_MIN, None, <stdint.h>)
+SYMBOL(INT_LEAST64_MAX, None, <stdint.h>)
+SYMBOL(INT_LEAST64_MIN, None, <stdint.h>)
+SYMBOL(INT_LEAST8_MAX, None, <stdint.h>)
+SYMBOL(INT_LEAST8_MIN, None, <stdint.h>)
+SYMBOL(INT_MAX, None, <limits.h>)
+SYMBOL(INT_MIN, None, <limits.h>)
+SYMBOL(LC_ALL, None, <locale.h>)
+SYMBOL(LC_COLLATE, None, <locale.h>)
+SYMBOL(LC_CTYPE, None, <locale.h>)
+SYMBOL(LC_MONETARY, None, <locale.h>)
+SYMBOL(LC_NUMERIC, None, <locale.h>)
+SYMBOL(LC_TIME, None, <locale.h>)
+SYMBOL(LDBL_DECIMAL_DIG, None, <float.h>)
+SYMBOL(LDBL_DIG, None, <float.h>)
+SYMBOL(LDBL_EPSILON, None, <float.h>)
+SYMBOL(LDBL_HAS_SUBNORM, None, <float.h>)
+SYMBOL(LDBL_MANT_DIG, None, <float.h>)
+SYMBOL(LDBL_MAX, None, <float.h>)
+SYMBOL(LDBL_MAX_10_EXP, None, <float.h>)
+SYMBOL(LDBL_MAX_EXP, None, <float.h>)
+SYMBOL(LDBL_MIN, None, <float.h>)
+SYMBOL(LDBL_MIN_10_EXP, None, <float.h>)
+SYMBOL(LDBL_MIN_EXP, None, <float.h>)
+SYMBOL(LDBL_TRUE_MIN, None, <float.h>)
+SYMBOL(LLONG_MAX, None, <limits.h>)
+SYMBOL(LLONG_MIN, None, <limits.h>)
+SYMBOL(LONG_MAX, None, <limits.h>)
+SYMBOL(LONG_MIN, None, <limits.h>)
+SYMBOL(L_tmpnam, None, <stdio.h>)
+SYMBOL(L_tmpnam_s, None, <stdio.h>)
+SYMBOL(MATH_ERREXCEPT, None, <math.h>)
+SYMBOL(MATH_ERRNO, None, <math.h>)
+SYMBOL(MB_CUR_MAX, None, <stdlib.h>)
+SYMBOL(MB_LEN_MAX, None, <limits.h>)
+SYMBOL(NAN, None, <math.h>)
+SYMBOL(ONCE_FLAG_INIT, None, <threads.h>)
+SYMBOL(PTRDIFF_MAX, None, <stdint.h>)
+SYMBOL(PTRDIFF_MIN, None, <stdint.h>)
+SYMBOL(RAND_MAX, None, <stdlib.h>)
+SYMBOL(RSIZE_MAX, None, <stdint.h>)
+SYMBOL(SCHAR_MAX, None, <limits.h>)
+SYMBOL(SCHAR_MIN, None, <limits.h>)
+SYMBOL(SEEK_CUR, None, <stdio.h>)
+SYMBOL(SEEK_END, None, <stdio.h>)
+SYMBOL(SEEK_SET, None, <stdio.h>)
+SYMBOL(SHRT_MAX, None, <limits.h>)
+SYMBOL(SHRT_MIN, None, <limits.h>)
+SYMBOL(SIGABRT, None, <signal.h>)
+SYMBOL(SIGFPE, None, <signal.h>)
+SYMBOL(SIGILL, None, <signal.h>)
+SYMBOL(SIGINT, None, <signal.h>)
+SYMBOL(SIGSEGV, None, <signal.h>)
+SYMBOL(SIGTERM, None, <signal.h>)
+SYMBOL(SIG_ATOMIC_MAX, None, <stdint.h>)
+SYMBOL(SIG_ATOMIC_MIN, None, <stdint.h>)
+SYMBOL(SIG_DFL, None, <signal.h>)
+SYMBOL(SIG_ERR, None, <signal.h>)
+SYMBOL(SIG_IGN, None, <signal.h>)
+SYMBOL(SIZE_MAX, None, <stdint.h>)
+SYMBOL(TIME_UTC, None, <time.h>)
+SYMBOL(TMP_MAX, None, <stdio.h>)
+SYMBOL(TMP_MAX_S, None, <stdio.h>)
+SYMBOL(TSS_DTOR_ITERATIONS, None, <threads.h>)
+SYMBOL(UCHAR_MAX, None, <limits.h>)
+SYMBOL(UINT16_MAX, None, <stdint.h>)
+SYMBOL(UINT32_MAX, None, <stdint.h>)
+SYMBOL(UINT64_MAX, None, <stdint.h>)
+SYMBOL(UINT8_MAX, None, <stdint.h>)
+SYMBOL(UINTMAX_MAX, None, <stdint.h>)
+SYMBOL(UINTPTR_MAX, None, <stdint.h>)
+SYMBOL(UINT_FAST16_MAX, None, <stdint.h>)
+SYMBOL(UINT_FAST32_MAX, None, <stdint.h>)
+SYMBOL(UINT_FAST64_MAX, None, <stdint.h>)
+SYMBOL(UINT_FAST8_MAX, None, <stdint.h>)
+SYMBOL(UINT_LEAST16_MAX, None, <stdint.h>)
+SYMBOL(UINT_LEAST32_MAX, None, <stdint.h>)
+SYMBOL(UINT_LEAST64_MAX, None, <stdint.h>)
+SYMBOL(UINT_LEAST8_MAX, None, <stdint.h>)
+SYMBOL(UINT_MAX, None, <limits.h>)
+SYMBOL(ULLONG_MAX, None, <limits.h>)
+SYMBOL(ULONG_MAX, None, <limits.h>)
+SYMBOL(USHRT_MAX, None, <limits.h>)
+SYMBOL(WCHAR_MAX, None, <wchar.h>)
+SYMBOL(WCHAR_MIN, None, <wchar.h>)
+SYMBOL(WEOF, None, <wchar.h>)
+SYMBOL(WINT_MAX, None, <stdint.h>)
+SYMBOL(WINT_MIN, None, <stdint.h>)
+SYMBOL(_Complex_I, None, <complex.h>)
+SYMBOL(_IOFBF, None, <stdio.h>)
+SYMBOL(_IOLBF, None, <stdio.h>)
+SYMBOL(_IONBF, None, <stdio.h>)
+SYMBOL(_Imaginary_I, None, <complex.h>)
+SYMBOL(__alignas_is_defined, None, <stdalign.h>)
+SYMBOL(__alignof_is_defined, None, <stdalign.h>)
+SYMBOL(abort_handler_s, None, <stdlib.h>)
+SYMBOL(abs, None, <stdlib.h>)
+SYMBOL(acos, None, <math.h>)
+SYMBOL(acosf, None, <math.h>)
+SYMBOL(acosh, None, <math.h>)
+SYMBOL(acoshf, None, <math.h>)
+SYMBOL(acoshl, None, <math.h>)
+SYMBOL(acosl, None, <math.h>)
+SYMBOL(alignas, None, <stdalign.h>)
+SYMBOL(aligned_alloc, None, <stdlib.h>)
+SYMBOL(alignof, None, <stdalign.h>)
+SYMBOL(and, None, <iso646.h>)
+SYMBOL(and_eq, None, <iso646.h>)
+SYMBOL(asctime, None, <time.h>)
+SYMBOL(asctime_s, None, <time.h>)
+SYMBOL(asin, None, <math.h>)
+SYMBOL(asinf, None, <math.h>)
+SYMBOL(asinh, None, <math.h>)
+SYMBOL(asinhf, None, <math.h>)
+SYMBOL(asinhl, None, <math.h>)
+SYMBOL(asinl, None, <math.h>)
+SYMBOL(assert, None, <assert.h>)
+SYMBOL(at_quick_exit, None, <stdlib.h>)
+SYMBOL(atan, None, <math.h>)
+SYMBOL(atan2, None, <math.h>)
+SYMBOL(atan2f, None, <math.h>)
+SYMBOL(atan2l, None, <math.h>)
+SYMBOL(atanf, None, <math.h>)
+SYMBOL(atanh, None, <math.h>)
+SYMBOL(atanhf, None, <math.h>)
+SYMBOL(atanhl, None, <math.h>)
+SYMBOL(atanl, None, <math.h>)
+SYMBOL(atexit, None, <stdlib.h>)
+SYMBOL(atof, None, <stdlib.h>)
+SYMBOL(atoi, None, <stdlib.h>)
+SYMBOL(atol, None, <stdlib.h>)
+SYMBOL(atoll, None, <stdlib.h>)
+SYMBOL(atomic_bool, None, <stdatomic.h>)
+SYMBOL(atomic_char, None, <stdatomic.h>)
+SYMBOL(atomic_char16_t, None, <stdatomic.h>)
+SYMBOL(atomic_char32_t, None, <stdatomic.h>)
+SYMBOL(atomic_compare_exchange_strong, None, <stdatomic.h>)
+SYMBOL(atomic_compare_exchange_strong_explicit, None, <stdatomic.h>)
+SYMBOL(atomic_compare_exchange_weak, None, <stdatomic.h>)
+SYMBOL(atomic_compare_exchange_weak_explicit, None, <stdatomic.h>)
+SYMBOL(atomic_exchange, None, <stdatomic.h>)
+SYMBOL(atomic_exchange_explicit, None, <stdatomic.h>)
+SYMBOL(atomic_fetch_add, None, <stdatomic.h>)
+SYMBOL(atomic_fetch_add_explicit, None, <stdatomic.h>)
+SYMBOL(atomic_fetch_and, None, <stdatomic.h>)
+SYMBOL(atomic_fetch_and_explicit, None, <stdatomic.h>)
+SYMBOL(atomic_fetch_or, None, <stdatomic.h>)
+SYMBOL(atomic_fetch_or_explicit, None, <stdatomic.h>)
+SYMBOL(atomic_fetch_sub, None, <stdatomic.h>)
+SYMBOL(atomic_fetch_sub_explicit, None, <stdatomic.h>)
+SYMBOL(atomic_fetch_xor, None, <stdatomic.h>)
+SYMBOL(atomic_fetch_xor_explicit, None, <stdatomic.h>)
+SYMBOL(atomic_flag, None, <stdatomic.h>)
+SYMBOL(atomic_flag_clear, None, <stdatomic.h>)
+SYMBOL(atomic_flag_clear_explicit, None, <stdatomic.h>)
+SYMBOL(atomic_flag_test_and_set, None, <stdatomic.h>)
+SYMBOL(atomic_flag_test_and_set_explicit, None, <stdatomic.h>)
+SYMBOL(atomic_init, None, <stdatomic.h>)
+SYMBOL(atomic_int, None, <stdatomic.h>)
+SYMBOL(atomic_int_fast16_t, None, <stdatomic.h>)
+SYMBOL(atomic_int_fast32_t, None, <stdatomic.h>)
+SYMBOL(atomic_int_fast64_t, None, <stdatomic.h>)
+SYMBOL(atomic_int_fast8_t, None, <stdatomic.h>)
+SYMBOL(atomic_int_least16_t, None, <stdatomic.h>)
+SYMBOL(atomic_int_least32_t, None, <stdatomic.h>)
+SYMBOL(atomic_int_least64_t, None, <stdatomic.h>)
+SYMBOL(atomic_int_least8_t, None, <stdatomic.h>)
+SYMBOL(atomic_intmax_t, None, <stdatomic.h>)
+SYMBOL(atomic_intptr_t, None, <stdatomic.h>)
+SYMBOL(atomic_is_lock_free, None, <stdatomic.h>)
+SYMBOL(atomic_llong, None, <stdatomic.h>)
+SYMBOL(atomic_load, None, <stdatomic.h>)
+SYMBOL(atomic_load_explicit, None, <stdatomic.h>)
+SYMBOL(atomic_long, None, <stdatomic.h>)
+SYMBOL(atomic_ptrdiff_t, None, <stdatomic.h>)
+SYMBOL(atomic_schar, None, <stdatomic.h>)
+SYMBOL(atomic_short, None, <stdatomic.h>)
+SYMBOL(atomic_signal_fence, None, <stdatomic.h>)
+SYMBOL(atomic_size_t, None, <stdatomic.h>)
+SYMBOL(atomic_store, None, <stdatomic.h>)
+SYMBOL(atomic_store_explicit, None, <stdatomic.h>)
+SYMBOL(atomic_thread_fence, None, <stdatomic.h>)
+SYMBOL(atomic_uchar, None, <stdatomic.h>)
+SYMBOL(atomic_uint, None, <stdatomic.h>)
+SYMBOL(atomic_uint_fast16_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint_fast32_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint_fast64_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint_fast8_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint_least16_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint_least32_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint_least64_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint_least8_t, None, <stdatomic.h>)
+SYMBOL(atomic_uintmax_t, None, <stdatomic.h>)
+SYMBOL(atomic_uintptr_t, None, <stdatomic.h>)
+SYMBOL(atomic_ullong, None, <stdatomic.h>)
+SYMBOL(atomic_ulong, None, <stdatomic.h>)
+SYMBOL(atomic_ushort, None, <stdatomic.h>)
+SYMBOL(atomic_wchar_t, None, <stdatomic.h>)
+SYMBOL(bitand, None, <iso646.h>)
+SYMBOL(bitor, None, <iso646.h>)
+SYMBOL(bsearch, None, <stdlib.h>)
+SYMBOL(bsearch_s, None, <stdlib.h>)
+SYMBOL(btowc, None, <wchar.h>)
+SYMBOL(c16rtomb, None, <uchar.h>)
+SYMBOL(c32rtomb, None, <uchar.h>)
+SYMBOL(cabs, None, <complex.h>)
+SYMBOL(cabsf, None, <complex.h>)
+SYMBOL(cabsl, None, <complex.h>)
+SYMBOL(cacos, None, <complex.h>)
+SYMBOL(cacosf, None, <complex.h>)
+SYMBOL(cacosh, None, <complex.h>)
+SYMBOL(cacoshf, None, <complex.h>)
+SYMBOL(cacoshl, None, <complex.h>)
+SYMBOL(cacosl, None, <complex.h>)
+SYMBOL(call_once, None, <threads.h>)
+SYMBOL(calloc, None, <stdlib.h>)
+SYMBOL(carg, None, <complex.h>)
+SYMBOL(cargf, None, <complex.h>)
+SYMBOL(cargl, None, <complex.h>)
+SYMBOL(casin, None, <complex.h>)
+SYMBOL(casinf, None, <complex.h>)
+SYMBOL(casinh, None, <complex.h>)
+SYMBOL(casinhf, None, <complex.h>)
+SYMBOL(casinhl, None, <complex.h>)
+SYMBOL(casinl, None, <complex.h>)
+SYMBOL(catan, None, <complex.h>)
+SYMBOL(catanf, None, <complex.h>)
+SYMBOL(catanh, None, <complex.h>)
+SYMBOL(catanhf, None, <complex.h>)
+SYMBOL(catanhl, None, <complex.h>)
+SYMBOL(catanl, None, <complex.h>)
+SYMBOL(cbrt, None, <math.h>)
+SYMBOL(cbrtf, None, <math.h>)
+SYMBOL(cbrtl, None, <math.h>)
+SYMBOL(ccos, None, <complex.h>)
+SYMBOL(ccosf, None, <complex.h>)
+SYMBOL(ccosh, None, <complex.h>)
+SYMBOL(ccoshf, None, <complex.h>)
+SYMBOL(ccoshl, None, <complex.h>)
+SYMBOL(ccosl, None, <complex.h>)
+SYMBOL(ceil, None, <math.h>)
+SYMBOL(ceilf, None, <math.h>)
+SYMBOL(ceill, None, <math.h>)
+SYMBOL(cexp, None, <complex.h>)
+SYMBOL(cexpf, None, <complex.h>)
+SYMBOL(cexpl, None, <complex.h>)
+SYMBOL(char16_t, None, <uchar.h>)
+SYMBOL(char32_t, None, <uchar.h>)
+SYMBOL(cimag, None, <complex.h>)
+SYMBOL(cimagf, None, <complex.h>)
+SYMBOL(cimagl, None, <complex.h>)
+SYMBOL(clearerr, None, <stdio.h>)
+SYMBOL(clock, None, <time.h>)
+SYMBOL(clock_t, None, <time.h>)
+SYMBOL(clog, None, <complex.h>)
+SYMBOL(clogf, None, <complex.h>)
+SYMBOL(clogl, None, <complex.h>)
+SYMBOL(cnd_broadcast, None, <threads.h>)
+SYMBOL(cnd_destroy, None, <threads.h>)
+SYMBOL(cnd_init, None, <threads.h>)
+SYMBOL(cnd_signal, None, <threads.h>)
+SYMBOL(cnd_t, None, <threads.h>)
+SYMBOL(cnd_timedwait, None, <threads.h>)
+SYMBOL(cnd_wait, None, <threads.h>)
+SYMBOL(compl, None, <iso646.h>)
+SYMBOL(complex, None, <complex.h>)
+SYMBOL(conj, None, <complex.h>)
+SYMBOL(conjf, None, <complex.h>)
+SYMBOL(conjl, None, <complex.h>)
+SYMBOL(constraint_handler_t, None, <stdlib.h>)
+SYMBOL(copysign, None, <math.h>)
+SYMBOL(copysignf, None, <math.h>)
+SYMBOL(copysignl, None, <math.h>)
+SYMBOL(cos, None, <math.h>)
+SYMBOL(cosf, None, <math.h>)
+SYMBOL(cosh, None, <math.h>)
+SYMBOL(coshf, None, <math.h>)
+SYMBOL(coshl, None, <math.h>)
+SYMBOL(cosl, None, <math.h>)
+SYMBOL(cpow, None, <complex.h>)
+SYMBOL(cpowf, None, <complex.h>)
+SYMBOL(cpowl, None, <complex.h>)
+SYMBOL(cproj, None, <complex.h>)
+SYMBOL(cprojf, None, <complex.h>)
+SYMBOL(cprojl, None, <complex.h>)
+SYMBOL(creal, None, <complex.h>)
+SYMBOL(crealf, None, <complex.h>)
+SYMBOL(creall, None, <complex.h>)
+SYMBOL(csin, None, <complex.h>)
+SYMBOL(csinf, None, <complex.h>)
+SYMBOL(csinh, None, <complex.h>)
+SYMBOL(csinhf, None, <complex.h>)
+SYMBOL(csinhl, None, <complex.h>)
+SYMBOL(csinl, None, <complex.h>)
+SYMBOL(csqrt, None, <complex.h>)
+SYMBOL(csqrtf, None, <complex.h>)
+SYMBOL(csqrtl, None, <complex.h>)
+SYMBOL(ctan, None, <complex.h>)
+SYMBOL(ctanf, None, <complex.h>)
+SYMBOL(ctanh, None, <complex.h>)
+SYMBOL(ctanhf, None, <complex.h>)
+SYMBOL(ctanhl, None, <complex.h>)
+SYMBOL(ctanl, None, <complex.h>)
+SYMBOL(ctime, None, <time.h>)
+SYMBOL(ctime_s, None, <time.h>)
+SYMBOL(difftime, None, <time.h>)
+SYMBOL(double_t, None, <math.h>)
+SYMBOL(erf, None, <math.h>)
+SYMBOL(erfc, None, <math.h>)
+SYMBOL(erfcf, None, <math.h>)
+SYMBOL(erfcl, None, <math.h>)
+SYMBOL(erff, None, <math.h>)
+SYMBOL(erfl, None, <math.h>)
+SYMBOL(errno, None, <errno.h>)
+SYMBOL(exit, None, <stdlib.h>)
+SYMBOL(exp, None, <math.h>)
+SYMBOL(exp2, None, <math.h>)
+SYMBOL(exp2f, None, <math.h>)
+SYMBOL(exp2l, None, <math.h>)
+SYMBOL(expf, None, <math.h>)
+SYMBOL(expl, None, <math.h>)
+SYMBOL(expm1, None, <math.h>)
+SYMBOL(expm1f, None, <math.h>)
+SYMBOL(expm1l, None, <math.h>)
+SYMBOL(fabs, None, <math.h>)
+SYMBOL(fabsf, None, <math.h>)
+SYMBOL(fabsl, None, <math.h>)
+SYMBOL(fclose, None, <stdio.h>)
+SYMBOL(fdim, None, <math.h>)
+SYMBOL(fdimf, None, <math.h>)
+SYMBOL(fdiml, None, <math.h>)
+SYMBOL(feclearexcept, None, <fenv.h>)
+SYMBOL(fegetenv, None, <fenv.h>)
+SYMBOL(fegetexceptflag, None, <fenv.h>)
+SYMBOL(fegetround, None, <fenv.h>)
+SYMBOL(feholdexcept, None, <fenv.h>)
+SYMBOL(fenv_t, None, <fenv.h>)
+SYMBOL(feof, None, <stdio.h>)
+SYMBOL(feraiseexcept, None, <fenv.h>)
+SYMBOL(ferror, None, <stdio.h>)
+SYMBOL(fesetenv, None, <fenv.h>)
+SYMBOL(fesetexceptflag, None, <fenv.h>)
+SYMBOL(fesetround, None, <fenv.h>)
+SYMBOL(fetestexcept, None, <fenv.h>)
+SYMBOL(feupdateenv, None, <fenv.h>)
+SYMBOL(fexcept_t, None, <fenv.h>)
+SYMBOL(fflush, None, <stdio.h>)
+SYMBOL(fgetc, None, <stdio.h>)
+SYMBOL(fgetpos, None, <stdio.h>)
+SYMBOL(fgets, None, <stdio.h>)
+SYMBOL(fgetwc, None, <wchar.h>)
+SYMBOL(fgetws, None, <wchar.h>)
+SYMBOL(float_t, None, <math.h>)
+SYMBOL(floor, None, <math.h>)
+SYMBOL(floorf, None, <math.h>)
+SYMBOL(floorl, None, <math.h>)
+SYMBOL(fma, None, <math.h>)
+SYMBOL(fmaf, None, <math.h>)
+SYMBOL(fmal, None, <math.h>)
+SYMBOL(fmax, None, <math.h>)
+SYMBOL(fmaxf, None, <math.h>)
+SYMBOL(fmaxl, None, <math.h>)
+SYMBOL(fmin, None, <math.h>)
+SYMBOL(fminf, None, <math.h>)
+SYMBOL(fminl, None, <math.h>)
+SYMBOL(fmod, None, <math.h>)
+SYMBOL(fmodf, None, <math.h>)
+SYMBOL(fmodl, None, <math.h>)
+SYMBOL(fopen, None, <stdio.h>)
+SYMBOL(fopen_s, None, <stdio.h>)
+SYMBOL(fpclassify, None, <math.h>)
+SYMBOL(fpos_t, None, <stdio.h>)
+SYMBOL(fprintf, None, <stdio.h>)
+SYMBOL(fprintf_s, None, <stdio.h>)
+SYMBOL(fputc, None, <stdio.h>)
+SYMBOL(fputs, None, <stdio.h>)
+SYMBOL(fputwc, None, <wchar.h>)
+SYMBOL(fputws, None, <wchar.h>)
+SYMBOL(fread, None, <stdio.h>)
+SYMBOL(free, None, <stdlib.h>)
+SYMBOL(freopen, None, <stdio.h>)
+SYMBOL(freopen_s, None, <stdio.h>)
+SYMBOL(frexp, None, <math.h>)
+SYMBOL(frexpf, None, <math.h>)
+SYMBOL(frexpl, None, <math.h>)
+SYMBOL(fscanf, None, <stdio.h>)
+SYMBOL(fscanf_s, None, <stdio.h>)
+SYMBOL(fseek, None, <stdio.h>)
+SYMBOL(fsetpos, None, <stdio.h>)
+SYMBOL(ftell, None, <stdio.h>)
+SYMBOL(fwide, None, <wchar.h>)
+SYMBOL(fwprintf, None, <wchar.h>)
+SYMBOL(fwprintf_s, None, <wchar.h>)
+SYMBOL(fwrite, None, <stdio.h>)
+SYMBOL(fwscanf, None, <wchar.h>)
+SYMBOL(fwscanf_s, None, <wchar.h>)
+SYMBOL(getc, None, <stdio.h>)
+SYMBOL(getchar, None, <stdio.h>)
+SYMBOL(getenv, None, <stdlib.h>)
+SYMBOL(getenv_s, None, <stdlib.h>)
+SYMBOL(gets, None, <stdio.h>)
+SYMBOL(gets_s, None, <stdio.h>)
+SYMBOL(getwc, None, <wchar.h>)
+SYMBOL(getwchar, None, <wchar.h>)
+SYMBOL(gmtime, None, <time.h>)
+SYMBOL(gmtime_s, None, <time.h>)
+SYMBOL(hypot, None, <math.h>)
+SYMBOL(hypotf, None, <math.h>)
+SYMBOL(hypotl, None, <math.h>)
+SYMBOL(ignore_handler_s, None, <stdlib.h>)
+SYMBOL(ilogb, None, <math.h>)
+SYMBOL(ilogbf, None, <math.h>)
+SYMBOL(ilogbl, None, <math.h>)
+SYMBOL(imaginary, None, <complex.h>)
+SYMBOL(imaxabs, None, <inttypes.h>)
+SYMBOL(int16_t, None, <stdint.h>)
+SYMBOL(int32_t, None, <stdint.h>)
+SYMBOL(int64_t, None, <stdint.h>)
+SYMBOL(int8_t, None, <stdint.h>)
+SYMBOL(int_fast16_t, None, <stdint.h>)
+SYMBOL(int_fast32_t, None, <stdint.h>)
+SYMBOL(int_fast64_t, None, <stdint.h>)
+SYMBOL(int_fast8_t, None, <stdint.h>)
+SYMBOL(int_least16_t, None, <stdint.h>)
+SYMBOL(int_least32_t, None, <stdint.h>)
+SYMBOL(int_least64_t, None, <stdint.h>)
+SYMBOL(int_least8_t, None, <stdint.h>)
+SYMBOL(intmax_t, None, <stdint.h>)
+SYMBOL(intptr_t, None, <stdint.h>)
+SYMBOL(isalnum, None, <ctype.h>)
+SYMBOL(isalpha, None, <ctype.h>)
+SYMBOL(isblank, None, <ctype.h>)
+SYMBOL(iscntrl, None, <ctype.h>)
+SYMBOL(isdigit, None, <ctype.h>)
+SYMBOL(isfinite, None, <math.h>)
+SYMBOL(isgraph, None, <ctype.h>)
+SYMBOL(isgreater, None, <math.h>)
+SYMBOL(isgreaterequal, None, <math.h>)
+SYMBOL(isinf, None, <math.h>)
+SYMBOL(isless, None, <math.h>)
+SYMBOL(islessequal, None, <math.h>)
+SYMBOL(islessgreater, None, <math.h>)
+SYMBOL(islower, None, <ctype.h>)
+SYMBOL(isnan, None, <math.h>)
+SYMBOL(isnormal, None, <math.h>)
+SYMBOL(isprint, None, <ctype.h>)
+SYMBOL(ispunct, None, <ctype.h>)
+SYMBOL(isspace, None, <ctype.h>)
+SYMBOL(isunordered, None, <math.h>)
+SYMBOL(isupper, None, <ctype.h>)
+SYMBOL(iswalnum, None, <wctype.h>)
+SYMBOL(iswalpha, None, <wctype.h>)
+SYMBOL(iswblank, None, <wctype.h>)
+SYMBOL(iswcntrl, None, <wctype.h>)
+SYMBOL(iswctype, None, <wctype.h>)
+SYMBOL(iswdigit, None, <wctype.h>)
+SYMBOL(iswgraph, None, <wctype.h>)
+SYMBOL(iswlower, None, <wctype.h>)
+SYMBOL(iswprint, None, <wctype.h>)
+SYMBOL(iswpunct, None, <wctype.h>)
+SYMBOL(iswspace, None, <wctype.h>)
+SYMBOL(iswupper, None, <wctype.h>)
+SYMBOL(iswxdigit, None, <wctype.h>)
+SYMBOL(isxdigit, None, <ctype.h>)
+SYMBOL(jmp_buf, None, <setjmp.h>)
+SYMBOL(kill_dependency, None, <stdatomic.h>)
+SYMBOL(labs, None, <stdlib.h>)
+SYMBOL(lconv, None, <locale.h>)
+SYMBOL(ldexp, None, <math.h>)
+SYMBOL(ldexpf, None, <math.h>)
+SYMBOL(ldexpl, None, <math.h>)
+SYMBOL(lgamma, None, <math.h>)
+SYMBOL(lgammaf, None, <math.h>)
+SYMBOL(lgammal, None, <math.h>)
+SYMBOL(llabs, None, <stdlib.h>)
+SYMBOL(llrint, None, <math.h>)
+SYMBOL(llrintf, None, <math.h>)
+SYMBOL(llrintl, None, <math.h>)
+SYMBOL(llround, None, <math.h>)
+SYMBOL(llroundf, None, <math.h>)
+SYMBOL(llroundl, None, <math.h>)
+SYMBOL(localeconv, None, <locale.h>)
+SYMBOL(localtime, None, <time.h>)
+SYMBOL(localtime_s, None, <time.h>)
+SYMBOL(log, None, <math.h>)
+SYMBOL(log10, None, <math.h>)
+SYMBOL(log10f, None, <math.h>)
+SYMBOL(log10l, None, <math.h>)
+SYMBOL(log1p, None, <math.h>)
+SYMBOL(log1pf, None, <math.h>)
+SYMBOL(log1pl, None, <math.h>)
+SYMBOL(log2, None, <math.h>)
+SYMBOL(log2f, None, <math.h>)
+SYMBOL(log2l, None, <math.h>)
+SYMBOL(logb, None, <math.h>)
+SYMBOL(logbf, None, <math.h>)
+SYMBOL(logbl, None, <math.h>)
+SYMBOL(logf, None, <math.h>)
+SYMBOL(logl, None, <math.h>)
+SYMBOL(longjmp, None, <setjmp.h>)
+SYMBOL(lrint, None, <math.h>)
+SYMBOL(lrintf, None, <math.h>)
+SYMBOL(lrintl, None, <math.h>)
+SYMBOL(lround, None, <math.h>)
+SYMBOL(lroundf, None, <math.h>)
+SYMBOL(lroundl, None, <math.h>)
+SYMBOL(malloc, None, <stdlib.h>)
+SYMBOL(math_errhandling, None, <math.h>)
+SYMBOL(max_align_t, None, <stddef.h>)
+SYMBOL(mblen, None, <stdlib.h>)
+SYMBOL(mbrlen, None, <wchar.h>)
+SYMBOL(mbrtoc16, None, <uchar.h>)
+SYMBOL(mbrtoc32, None, <uchar.h>)
+SYMBOL(mbrtowc, None, <wchar.h>)
+SYMBOL(mbsinit, None, <wchar.h>)
+SYMBOL(mbsrtowcs, None, <wchar.h>)
+SYMBOL(mbsrtowcs_s, None, <wchar.h>)
+SYMBOL(mbstowcs, None, <stdlib.h>)
+SYMBOL(mbstowcs_s, None, <stdlib.h>)
+SYMBOL(mbtowc, None, <stdlib.h>)
+SYMBOL(memchr, None, <string.h>)
+SYMBOL(memcmp, None, <string.h>)
+SYMBOL(memcpy, None, <string.h>)
+SYMBOL(memcpy_s, None, <string.h>)
+SYMBOL(memmove, None, <string.h>)
+SYMBOL(memmove_s, None, <string.h>)
+SYMBOL(memory_order, None, <stdatomic.h>)
+SYMBOL(memory_order_acq_rel, None, <stdatomic.h>)
+SYMBOL(memory_order_acquire, None, <stdatomic.h>)
+SYMBOL(memory_order_consume, None, <stdatomic.h>)
+SYMBOL(memory_order_relaxed, None, <stdatomic.h>)
+SYMBOL(memory_order_release, None, <stdatomic.h>)
+SYMBOL(memory_order_seq_cst, None, <stdatomic.h>)
+SYMBOL(memset, None, <string.h>)
+SYMBOL(memset_s, None, <string.h>)
+SYMBOL(mktime, None, <time.h>)
+SYMBOL(modf, None, <math.h>)
+SYMBOL(modff, None, <math.h>)
+SYMBOL(modfl, None, <math.h>)
+SYMBOL(mtx_destroy, None, <threads.h>)
+SYMBOL(mtx_init, None, <threads.h>)
+SYMBOL(mtx_lock, None, <threads.h>)
+SYMBOL(mtx_plain, None, <threads.h>)
+SYMBOL(mtx_recursive, None, <threads.h>)
+SYMBOL(mtx_t, None, <threads.h>)
+SYMBOL(mtx_timed, None, <threads.h>)
+SYMBOL(mtx_timedlock, None, <threads.h>)
+SYMBOL(mtx_trylock, None, <threads.h>)
+SYMBOL(mtx_unlock, None, <threads.h>)
+SYMBOL(nan, None, <math.h>)
+SYMBOL(nanf, None, <math.h>)
+SYMBOL(nanl, None, <math.h>)
+SYMBOL(nearbyint, None, <math.h>)
+SYMBOL(nearbyintf, None, <math.h>)
+SYMBOL(nearbyintl, None, <math.h>)
+SYMBOL(nextafter, None, <math.h>)
+SYMBOL(nextafterf, None, <math.h>)
+SYMBOL(nextafterl, None, <math.h>)
+SYMBOL(nexttoward, None, <math.h>)
+SYMBOL(nexttowardf, None, <math.h>)
+SYMBOL(nexttowardl, None, <math.h>)
+SYMBOL(noreturn, None, <stdnoreturn.h>)
+SYMBOL(not, None, <iso646.h>)
+SYMBOL(not_eq, None, <iso646.h>)
+SYMBOL(offsetof, None, <stddef.h>)
+SYMBOL(once_flag, None, <threads.h>)
+SYMBOL(or, None, <iso646.h>)
+SYMBOL(or_eq, None, <iso646.h>)
+SYMBOL(perror, None, <stdio.h>)
+SYMBOL(pow, None, <math.h>)
+SYMBOL(powf, None, <math.h>)
+SYMBOL(powl, None, <math.h>)
+SYMBOL(printf, None, <stdio.h>)
+SYMBOL(printf_s, None, <stdio.h>)
+SYMBOL(ptrdiff_t, None, <stddef.h>)
+SYMBOL(putc, None, <stdio.h>)
+SYMBOL(putchar, None, <stdio.h>)
+SYMBOL(puts, None, <stdio.h>)
+SYMBOL(putwc, None, <wchar.h>)
+SYMBOL(putwchar, None, <wchar.h>)
+SYMBOL(qsort, None, <stdlib.h>)
+SYMBOL(qsort_s, None, <stdlib.h>)
+SYMBOL(quick_exit, None, <stdlib.h>)
+SYMBOL(raise, None, <signal.h>)
+SYMBOL(rand, None, <stdlib.h>)
+SYMBOL(realloc, None, <stdlib.h>)
+SYMBOL(remainder, None, <math.h>)
+SYMBOL(remainderf, None, <math.h>)
+SYMBOL(remainderl, None, <math.h>)
+SYMBOL(remove, None, <stdio.h>)
+SYMBOL(remquo, None, <math.h>)
+SYMBOL(remquof, None, <math.h>)
+SYMBOL(remquol, None, <math.h>)
+SYMBOL(rename, None, <stdio.h>)
+SYMBOL(rewind, None, <stdio.h>)
+SYMBOL(rint, None, <math.h>)
+SYMBOL(rintf, None, <math.h>)
+SYMBOL(rintl, None, <math.h>)
+SYMBOL(round, None, <math.h>)
+SYMBOL(roundf, None, <math.h>)
+SYMBOL(roundl, None, <math.h>)
+SYMBOL(rsize_t, None, <stddef.h>)
+SYMBOL(scalbln, None, <math.h>)
+SYMBOL(scalblnf, None, <math.h>)
+SYMBOL(scalblnl, None, <math.h>)
+SYMBOL(scalbn, None, <math.h>)
+SYMBOL(scalbnf, None, <math.h>)
+SYMBOL(scalbnl, None, <math.h>)
+SYMBOL(scanf, None, <stdio.h>)
+SYMBOL(scanf_s, None, <stdio.h>)
+SYMBOL(set_constraint_handler_s, None, <stdlib.h>)
+SYMBOL(setbuf, None, <stdio.h>)
+SYMBOL(setjmp, None, <setjmp.h>)
+SYMBOL(setlocale, None, <locale.h>)
+SYMBOL(setvbuf, None, <stdio.h>)
+SYMBOL(sig_atomic_t, None, <signal.h>)
+SYMBOL(signal, None, <signal.h>)
+SYMBOL(signbit, None, <math.h>)
+SYMBOL(sin, None, <math.h>)
+SYMBOL(sinf, None, <math.h>)
+SYMBOL(sinh, None, <math.h>)
+SYMBOL(sinhf, None, <math.h>)
+SYMBOL(sinhl, None, <math.h>)
+SYMBOL(sinl, None, <math.h>)
+SYMBOL(snprintf, None, <stdio.h>)
+SYMBOL(snprintf_s, None, <stdio.h>)
+SYMBOL(snwprintf_s, None, <wchar.h>)
+SYMBOL(sprintf, None, <stdio.h>)
+SYMBOL(sprintf_s, None, <stdio.h>)
+SYMBOL(sqrt, None, <math.h>)
+SYMBOL(sqrtf, None, <math.h>)
+SYMBOL(sqrtl, None, <math.h>)
+SYMBOL(srand, None, <stdlib.h>)
+SYMBOL(sscanf, None, <stdio.h>)
+SYMBOL(sscanf_s, None, <stdio.h>)
+SYMBOL(static_assert, None, <assert.h>)
+SYMBOL(stderr, None, <stdio.h>)
+SYMBOL(stdin, None, <stdio.h>)
+SYMBOL(stdout, None, <stdio.h>)
+SYMBOL(strcat, None, <string.h>)
+SYMBOL(strcat_s, None, <string.h>)
+SYMBOL(strchr, None, <string.h>)
+SYMBOL(strcmp, None, <string.h>)
+SYMBOL(strcoll, None, <string.h>)
+SYMBOL(strcpy, None, <string.h>)
+SYMBOL(strcpy_s, None, <string.h>)
+SYMBOL(strcspn, None, <string.h>)
+SYMBOL(strerror, None, <string.h>)
+SYMBOL(strerror_s, None, <string.h>)
+SYMBOL(strerrorlen_s, None, <string.h>)
+SYMBOL(strftime, None, <time.h>)
+SYMBOL(strlen, None, <string.h>)
+SYMBOL(strncat, None, <string.h>)
+SYMBOL(strncat_s, None, <string.h>)
+SYMBOL(strncmp, None, <string.h>)
+SYMBOL(strncpy, None, <string.h>)
+SYMBOL(strncpy_s, None, <string.h>)
+SYMBOL(strnlen_s, None, <string.h>)
+SYMBOL(strpbrk, None, <string.h>)
+SYMBOL(strrchr, None, <string.h>)
+SYMBOL(strspn, None, <string.h>)
+SYMBOL(strstr, None, <string.h>)
+SYMBOL(strtod, None, <stdlib.h>)
+SYMBOL(strtof, None, <stdlib.h>)
+SYMBOL(strtoimax, None, <inttypes.h>)
+SYMBOL(strtok, None, <string.h>)
+SYMBOL(strtok_s, None, <string.h>)
+SYMBOL(strtol, None, <stdlib.h>)
+SYMBOL(strtold, None, <stdlib.h>)
+SYMBOL(strtoll, None, <stdlib.h>)
+SYMBOL(strtoul, None, <stdlib.h>)
+SYMBOL(strtoull, None, <stdlib.h>)
+SYMBOL(strtoumax, None, <inttypes.h>)
+SYMBOL(strxfrm, None, <string.h>)
+SYMBOL(swprintf, None, <wchar.h>)
+SYMBOL(swprintf_s, None, <wchar.h>)
+SYMBOL(swscanf, None, <wchar.h>)
+SYMBOL(swscanf_s, None, <wchar.h>)
+SYMBOL(system, None, <stdlib.h>)
+SYMBOL(tan, None, <math.h>)
+SYMBOL(tanf, None, <math.h>)
+SYMBOL(tanh, None, <math.h>)
+SYMBOL(tanhf, None, <math.h>)
+SYMBOL(tanhl, None, <math.h>)
+SYMBOL(tanl, None, <math.h>)
+SYMBOL(tgamma, None, <math.h>)
+SYMBOL(tgammaf, None, <math.h>)
+SYMBOL(tgammal, None, <math.h>)
+SYMBOL(thrd_busy, None, <threads.h>)
+SYMBOL(thrd_create, None, <threads.h>)
+SYMBOL(thrd_current, None, <threads.h>)
+SYMBOL(thrd_detach, None, <threads.h>)
+SYMBOL(thrd_equal, None, <threads.h>)
+SYMBOL(thrd_error, None, <threads.h>)
+SYMBOL(thrd_join, None, <threads.h>)
+SYMBOL(thrd_nomem, None, <threads.h>)
+SYMBOL(thrd_sleep, None, <threads.h>)
+SYMBOL(thrd_start_t, None, <threads.h>)
+SYMBOL(thrd_success, None, <threads.h>)
+SYMBOL(thrd_t, None, <threads.h>)
+SYMBOL(thrd_timedout, None, <threads.h>)
+SYMBOL(thrd_yield, None, <threads.h>)
+SYMBOL(thread_local, None, <threads.h>)
+SYMBOL(time, None, <time.h>)
+SYMBOL(time_t, None, <time.h>)
+SYMBOL(timespec, None, <time.h>)
+SYMBOL(timespec_get, None, <time.h>)
+SYMBOL(tm, None, <time.h>)
+SYMBOL(tmpfile, None, <stdio.h>)
+SYMBOL(tmpfile_s, None, <stdio.h>)
+SYMBOL(tmpnam, None, <stdio.h>)
+SYMBOL(tmpnam_s, None, <stdio.h>)
+SYMBOL(tolower, None, <ctype.h>)
+SYMBOL(toupper, None, <ctype.h>)
+SYMBOL(towctrans, None, <wctype.h>)
+SYMBOL(towlower, None, <wctype.h>)
+SYMBOL(towupper, None, <wctype.h>)
+SYMBOL(trunc, None, <math.h>)
+SYMBOL(truncf, None, <math.h>)
+SYMBOL(truncl, None, <math.h>)
+SYMBOL(tss_create, None, <threads.h>)
+SYMBOL(tss_delete, None, <threads.h>)
+SYMBOL(tss_dtor_t, None, <threads.h>)
+SYMBOL(tss_get, None, <threads.h>)
+SYMBOL(tss_set, None, <threads.h>)
+SYMBOL(tss_t, None, <threads.h>)
+SYMBOL(uint16_t, None, <stdint.h>)
+SYMBOL(uint32_t, None, <stdint.h>)
+SYMBOL(uint64_t, None, <stdint.h>)
+SYMBOL(uint8_t, None, <stdint.h>)
+SYMBOL(uint_fast16_t, None, <stdint.h>)
+SYMBOL(uint_fast32_t, None, <stdint.h>)
+SYMBOL(uint_fast64_t, None, <stdint.h>)
+SYMBOL(uint_fast8_t, None, <stdint.h>)
+SYMBOL(uint_least16_t, None, <stdint.h>)
+SYMBOL(uint_least32_t, None, <stdint.h>)
+SYMBOL(uint_least64_t, None, <stdint.h>)
+SYMBOL(uint_least8_t, None, <stdint.h>)
+SYMBOL(uintmax_t, None, <stdint.h>)
+SYMBOL(uintptr_t, None, <stdint.h>)
+SYMBOL(ungetc, None, <stdio.h>)
+SYMBOL(ungetwc, None, <wchar.h>)
+SYMBOL(va_arg, None, <stdarg.h>)
+SYMBOL(va_copy, None, <stdarg.h>)
+SYMBOL(va_end, None, <stdarg.h>)
+SYMBOL(va_start, None, <stdarg.h>)
+SYMBOL(vfprintf, None, <stdio.h>)
+SYMBOL(vfprintf_s, None, <stdio.h>)
+SYMBOL(vfscanf, None, <stdio.h>)
+SYMBOL(vfscanf_s, None, <stdio.h>)
+SYMBOL(vfwprintf, None, <wchar.h>)
+SYMBOL(vfwprintf_s, None, <wchar.h>)
+SYMBOL(vfwscanf, None, <wchar.h>)
+SYMBOL(vfwscanf_s, None, <wchar.h>)
+SYMBOL(vprintf, None, <stdio.h>)
+SYMBOL(vprintf_s, None, <stdio.h>)
+SYMBOL(vscanf, None, <stdio.h>)
+SYMBOL(vscanf_s, None, <stdio.h>)
+SYMBOL(vsnprintf, None, <stdio.h>)
+SYMBOL(vsnprintf_s, None, <stdio.h>)
+SYMBOL(vsnwprintf_s, None, <wchar.h>)
+SYMBOL(vsprintf, None, <stdio.h>)
+SYMBOL(vsprintf_s, None, <stdio.h>)
+SYMBOL(vsscanf, None, <stdio.h>)
+SYMBOL(vsscanf_s, None, <stdio.h>)
+SYMBOL(vswprintf, None, <wchar.h>)
+SYMBOL(vswprintf_s, None, <wchar.h>)
+SYMBOL(vswscanf, None, <wchar.h>)
+SYMBOL(vswscanf_s, None, <wchar.h>)
+SYMBOL(vwprintf, None, <wchar.h>)
+SYMBOL(vwprintf_s, None, <wchar.h>)
+SYMBOL(vwscanf, None, <wchar.h>)
+SYMBOL(vwscanf_s, None, <wchar.h>)
+SYMBOL(wchar_t, None, <wchar.h>)
+SYMBOL(wcrtomb, None, <wchar.h>)
+SYMBOL(wcrtomb_s, None, <wchar.h>)
+SYMBOL(wcscat, None, <wchar.h>)
+SYMBOL(wcscat_s, None, <wchar.h>)
+SYMBOL(wcschr, None, <wchar.h>)
+SYMBOL(wcscmp, None, <wchar.h>)
+SYMBOL(wcscoll, None, <wchar.h>)
+SYMBOL(wcscpy, None, <wchar.h>)
+SYMBOL(wcscpy_s, None, <wchar.h>)
+SYMBOL(wcscspn, None, <wchar.h>)
+SYMBOL(wcsftime, None, <wchar.h>)
+SYMBOL(wcslen, None, <wchar.h>)
+SYMBOL(wcsncat, None, <wchar.h>)
+SYMBOL(wcsncat_s, None, <wchar.h>)
+SYMBOL(wcsncmp, None, <wchar.h>)
+SYMBOL(wcsncpy, None, <wchar.h>)
+SYMBOL(wcsncpy_s, None, <wchar.h>)
+SYMBOL(wcsnlen_s, None, <wchar.h>)
+SYMBOL(wcspbrk, None, <wchar.h>)
+SYMBOL(wcsrchr, None, <wchar.h>)
+SYMBOL(wcsrtombs, None, <wchar.h>)
+SYMBOL(wcsrtombs_s, None, <wchar.h>)
+SYMBOL(wcsspn, None, <wchar.h>)
+SYMBOL(wcsstr, None, <wchar.h>)
+SYMBOL(wcstod, None, <wchar.h>)
+SYMBOL(wcstof, None, <wchar.h>)
+SYMBOL(wcstoimax, None, <inttypes.h>)
+SYMBOL(wcstok, None, <wchar.h>)
+SYMBOL(wcstok_s, None, <wchar.h>)
+SYMBOL(wcstol, None, <wchar.h>)
+SYMBOL(wcstold, None, <wchar.h>)
+SYMBOL(wcstoll, None, <wchar.h>)
+SYMBOL(wcstombs, None, <stdlib.h>)
+SYMBOL(wcstombs_s, None, <stdlib.h>)
+SYMBOL(wcstoul, None, <wchar.h>)
+SYMBOL(wcstoull, None, <wchar.h>)
+SYMBOL(wcstoumax, None, <inttypes.h>)
+SYMBOL(wcsxfrm, None, <wchar.h>)
+SYMBOL(wctob, None, <wchar.h>)
+SYMBOL(wctomb, None, <stdlib.h>)
+SYMBOL(wctomb_s, None, <stdlib.h>)
+SYMBOL(wctrans, None, <wctype.h>)
+SYMBOL(wctrans_t, None, <wctype.h>)
+SYMBOL(wctype, None, <wctype.h>)
+SYMBOL(wctype_t, None, <wctype.h>)
+SYMBOL(wint_t, None, <wctype.h>)
+SYMBOL(wmemchr, None, <wchar.h>)
+SYMBOL(wmemcmp, None, <wchar.h>)
+SYMBOL(wmemcpy, None, <wchar.h>)
+SYMBOL(wmemcpy_s, None, <wchar.h>)
+SYMBOL(wmemmove, None, <wchar.h>)
+SYMBOL(wmemmove_s, None, <wchar.h>)
+SYMBOL(wmemset, None, <wchar.h>)
+SYMBOL(wprintf, None, <wchar.h>)
+SYMBOL(wprintf_s, None, <wchar.h>)
+SYMBOL(wscanf, None, <wchar.h>)
+SYMBOL(wscanf_s, None, <wchar.h>)
+SYMBOL(xor, None, <iso646.h>)
+SYMBOL(xor_eq, None, <iso646.h>)
diff --git a/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp b/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
index 9e5e421fdebc..cfcb955831ad 100644
--- a/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
+++ b/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
@@ -8,108 +8,230 @@
 
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "clang/AST/Decl.h"
+#include "clang/Basic/LangOptions.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
+#include <optional>
 
 namespace clang {
 namespace tooling {
 namespace stdlib {
 
-static llvm::StringRef *HeaderNames;
-static std::pair<llvm::StringRef, llvm::StringRef> *SymbolNames;
-static unsigned *SymbolHeaderIDs;
-static llvm::DenseMap<llvm::StringRef, unsigned> *HeaderIDs;
-// Maps symbol name -> Symbol::ID, within a namespace.
+namespace {
+// Symbol name -> Symbol::ID, within a namespace.
 using NSSymbolMap = llvm::DenseMap<llvm::StringRef, unsigned>;
-static llvm::DenseMap<llvm::StringRef, NSSymbolMap *> *NamespaceSymbols;
 
-static int initialize() {
-  unsigned SymCount = 0;
-#define SYMBOL(Name, NS, Header) ++SymCount;
-#include "clang/Tooling/Inclusions/CSymbolMap.inc"
-#include "clang/Tooling/Inclusions/StdSymbolMap.inc"
+// A Mapping per language.
+struct SymbolHeaderMapping {
+  llvm::StringRef *HeaderNames = nullptr;
+  // Header name => Header::ID
+  llvm::DenseMap<llvm::StringRef, unsigned> *HeaderIDs;
+
+  unsigned SymbolCount = 0;
+  // Symbol::ID => symbol qualified_name/name/scope
+  struct SymbolName {
+    const char *Data;  // std::vector
+    unsigned ScopeLen; // ~~~~~
+    unsigned NameLen;  //      ~~~~~~
+    StringRef scope() const { return StringRef(Data, ScopeLen); }
+    StringRef name() const { return StringRef(Data + ScopeLen, NameLen); }
+    StringRef qualifiedName() const {
+      return StringRef(Data, ScopeLen + NameLen);
+    }
+  } *SymbolNames = nullptr;
+  // Symbol name -> Symbol::ID, within a namespace.
+  llvm::DenseMap<llvm::StringRef, NSSymbolMap *> *NamespaceSymbols = nullptr;
+  // Symbol::ID => Header::ID
+  llvm::SmallVector<unsigned> *SymbolHeaderIDs = nullptr;
+};
+} // namespace
+static SymbolHeaderMapping
+    *LanguageMappings[static_cast<unsigned>(Lang::LastValue) + 1];
+static const SymbolHeaderMapping *getMappingPerLang(Lang L) {
+  return LanguageMappings[static_cast<unsigned>(L)];
+}
+
+static int countSymbols(Lang Language) {
+  llvm::DenseSet<llvm::StringRef> Set;
+#define SYMBOL(Name, NS, Header) Set.insert(#NS #Name);
+  switch (Language) {
+  case Lang::C:
+#include "CSymbolMap.inc"
+    break;
+  case Lang::CXX:
+#include "StdSpecialSymbolMap.inc"
+#include "StdSymbolMap.inc"
+#include "StdTsSymbolMap.inc"
+    break;
+  }
 #undef SYMBOL
-  SymbolNames = new std::remove_reference_t<decltype(*SymbolNames)>[SymCount];
-  SymbolHeaderIDs =
-      new std::remove_reference_t<decltype(*SymbolHeaderIDs)>[SymCount];
-  NamespaceSymbols = new std::remove_reference_t<decltype(*NamespaceSymbols)>;
-  HeaderIDs = new std::remove_reference_t<decltype(*HeaderIDs)>;
+  return Set.size();
+}
 
+static int initialize(Lang Language) {
+  SymbolHeaderMapping *Mapping = new SymbolHeaderMapping();
+  LanguageMappings[static_cast<unsigned>(Language)] = Mapping;
+
+  unsigned SymCount = countSymbols(Language);
+  Mapping->SymbolCount = SymCount;
+  Mapping->SymbolNames =
+      new std::remove_reference_t<decltype(*Mapping->SymbolNames)>[SymCount];
+  Mapping->SymbolHeaderIDs = new std::remove_reference_t<
+      decltype(*Mapping->SymbolHeaderIDs)>[SymCount];
+  Mapping->NamespaceSymbols =
+      new std::remove_reference_t<decltype(*Mapping->NamespaceSymbols)>;
+  Mapping->HeaderIDs =
+      new std::remove_reference_t<decltype(*Mapping->HeaderIDs)>;
   auto AddNS = [&](llvm::StringRef NS) -> NSSymbolMap & {
-    auto R = NamespaceSymbols->try_emplace(NS, nullptr);
+    auto R = Mapping->NamespaceSymbols->try_emplace(NS, nullptr);
     if (R.second)
       R.first->second = new NSSymbolMap();
     return *R.first->second;
   };
 
   auto AddHeader = [&](llvm::StringRef Header) -> unsigned {
-    return HeaderIDs->try_emplace(Header, HeaderIDs->size()).first->second;
+    return Mapping->HeaderIDs->try_emplace(Header, Mapping->HeaderIDs->size())
+        .first->second;
   };
 
-  auto Add = [&, SymIndex(0)](llvm::StringRef Name, llvm::StringRef NS,
-                              llvm::StringRef HeaderName) mutable {
-    if (NS == "None")
-      NS = "";
-
-    SymbolNames[SymIndex] = {NS, Name};
-    SymbolHeaderIDs[SymIndex] = AddHeader(HeaderName);
+  auto Add = [&, SymIndex(-1)](llvm::StringRef QName, unsigned NSLen,
+                               llvm::StringRef HeaderName) mutable {
+    // Correct "Nonefoo" => foo.
+    // FIXME: get rid of "None" from the generated mapping files.
+    if (QName.take_front(NSLen) == "None") {
+      QName = QName.drop_front(NSLen);
+      NSLen = 0;
+    }
 
-    NSSymbolMap &NSSymbols = AddNS(NS);
-    NSSymbols.try_emplace(Name, SymIndex);
+    if (SymIndex >= 0 &&
+        Mapping->SymbolNames[SymIndex].qualifiedName() == QName) {
+      // Not a new symbol, use the same index.
+      assert(llvm::none_of(llvm::ArrayRef(Mapping->SymbolNames, SymIndex),
+                           [&QName](const SymbolHeaderMapping::SymbolName &S) {
+                             return S.qualifiedName() == QName;
+                           }) &&
+             "The symbol has been added before, make sure entries in the .inc "
+             "file are grouped by symbol name!");
+    } else {
+      // First symbol or new symbol, increment next available index.
+      ++SymIndex;
+    }
+    Mapping->SymbolNames[SymIndex] = {
+        QName.data(), NSLen, static_cast<unsigned int>(QName.size() - NSLen)};
+    if (!HeaderName.empty())
+       Mapping->SymbolHeaderIDs[SymIndex].push_back(AddHeader(HeaderName));
 
-    ++SymIndex;
+    NSSymbolMap &NSSymbols = AddNS(QName.take_front(NSLen));
+    NSSymbols.try_emplace(QName.drop_front(NSLen), SymIndex);
   };
-#define SYMBOL(Name, NS, Header) Add(#Name, #NS, #Header);
-#include "clang/Tooling/Inclusions/CSymbolMap.inc"
-#include "clang/Tooling/Inclusions/StdSymbolMap.inc"
+#define SYMBOL(Name, NS, Header) Add(#NS #Name, strlen(#NS), #Header);
+  switch (Language) {
+  case Lang::C:
+#include "CSymbolMap.inc"
+    break;
+  case Lang::CXX:
+#include "StdSpecialSymbolMap.inc"
+#include "StdSymbolMap.inc"
+#include "StdTsSymbolMap.inc"
+    break;
+  }
 #undef SYMBOL
 
-  HeaderNames = new llvm::StringRef[HeaderIDs->size()];
-  for (const auto &E : *HeaderIDs)
-    HeaderNames[E.second] = E.first;
+  Mapping->HeaderNames = new llvm::StringRef[Mapping->HeaderIDs->size()];
+  for (const auto &E : *Mapping->HeaderIDs)
+    Mapping->HeaderNames[E.second] = E.first;
 
   return 0;
 }
 
 static void ensureInitialized() {
-  static int Dummy = initialize();
+  static int Dummy = []() {
+    for (unsigned L = 0; L <= static_cast<unsigned>(Lang::LastValue); ++L)
+      initialize(static_cast<Lang>(L));
+    return 0;
+  }();
   (void)Dummy;
 }
 
-std::optional<Header> Header::named(llvm::StringRef Name) {
+std::vector<Header> Header::all(Lang L) {
   ensureInitialized();
-  auto It = HeaderIDs->find(Name);
-  if (It == HeaderIDs->end())
+  std::vector<Header> Result;
+  const auto *Mapping = getMappingPerLang(L);
+  Result.reserve(Mapping->HeaderIDs->size());
+  for (unsigned I = 0, E = Mapping->HeaderIDs->size(); I < E; ++I)
+    Result.push_back(Header(I, L));
+  return Result;
+}
+std::optional<Header> Header::named(llvm::StringRef Name, Lang L) {
+  ensureInitialized();
+  const auto *Mapping = getMappingPerLang(L);
+  auto It = Mapping->HeaderIDs->find(Name);
+  if (It == Mapping->HeaderIDs->end())
     return std::nullopt;
-  return Header(It->second);
+  return Header(It->second, L);
+}
+llvm::StringRef Header::name() const {
+  return getMappingPerLang(Language)->HeaderNames[ID];
 }
-llvm::StringRef Header::name() const { return HeaderNames[ID]; }
-llvm::StringRef Symbol::scope() const { return SymbolNames[ID].first; }
-llvm::StringRef Symbol::name() const { return SymbolNames[ID].second; }
-std::optional<Symbol> Symbol::named(llvm::StringRef Scope,
-                                     llvm::StringRef Name) {
+
+std::vector<Symbol> Symbol::all(Lang L) {
+  ensureInitialized();
+  std::vector<Symbol> Result;
+  const auto *Mapping = getMappingPerLang(L);
+  Result.reserve(Mapping->SymbolCount);
+  for (unsigned I = 0, E = Mapping->SymbolCount; I < E; ++I)
+    Result.push_back(Symbol(I, L));
+  return Result;
+}
+llvm::StringRef Symbol::scope() const {
+  return getMappingPerLang(Language)->SymbolNames[ID].scope();
+}
+llvm::StringRef Symbol::name() const {
+  return getMappingPerLang(Language)->SymbolNames[ID].name();
+}
+llvm::StringRef Symbol::qualifiedName() const {
+  return getMappingPerLang(Language)->SymbolNames[ID].qualifiedName();
+}
+std::optional<Symbol> Symbol::named(llvm::StringRef Scope, llvm::StringRef Name,
+                                    Lang L) {
   ensureInitialized();
-  if (NSSymbolMap *NSSymbols = NamespaceSymbols->lookup(Scope)) {
+
+  if (NSSymbolMap *NSSymbols =
+          getMappingPerLang(L)->NamespaceSymbols->lookup(Scope)) {
     auto It = NSSymbols->find(Name);
     if (It != NSSymbols->end())
-      return Symbol(It->second);
+      return Symbol(It->second, L);
   }
   return std::nullopt;
 }
-Header Symbol::header() const { return Header(SymbolHeaderIDs[ID]); }
+std::optional<Header> Symbol::header() const {
+  const auto& Headers = getMappingPerLang(Language)->SymbolHeaderIDs[ID];
+  if (Headers.empty())
+    return std::nullopt;
+  return Header(Headers.front(), Language);
+}
 llvm::SmallVector<Header> Symbol::headers() const {
-  return {header()}; // FIXME: multiple in case of ambiguity
+  llvm::SmallVector<Header> Results;
+  for (auto HeaderID : getMappingPerLang(Language)->SymbolHeaderIDs[ID])
+    Results.emplace_back(Header(HeaderID, Language));
+  return Results;
 }
 
 Recognizer::Recognizer() { ensureInitialized(); }
 
-NSSymbolMap *Recognizer::namespaceSymbols(const NamespaceDecl *D) {
-  auto It = NamespaceCache.find(D);
+NSSymbolMap *Recognizer::namespaceSymbols(const DeclContext *DC, Lang L) {
+  if (DC->isTranslationUnit()) // global scope.
+    return getMappingPerLang(L)->NamespaceSymbols->lookup("");
+
+  auto It = NamespaceCache.find(DC);
   if (It != NamespaceCache.end())
     return It->second;
-
+  const NamespaceDecl *D = llvm::cast<NamespaceDecl>(DC);
   NSSymbolMap *Result = [&]() -> NSSymbolMap * {
-    if (D && D->isAnonymousNamespace())
+    if (D->isAnonymousNamespace())
       return nullptr;
     // Print the namespace and its parents ommitting inline scopes.
     std::string Scope;
@@ -117,24 +239,35 @@ NSSymbolMap *Recognizer::namespaceSymbols(const NamespaceDecl *D) {
          ND = llvm::dyn_cast_or_null<NamespaceDecl>(ND->getParent()))
       if (!ND->isInlineNamespace() && !ND->isAnonymousNamespace())
         Scope = ND->getName().str() + "::" + Scope;
-    return NamespaceSymbols->lookup(Scope);
+    return getMappingPerLang(L)->NamespaceSymbols->lookup(Scope);
   }();
   NamespaceCache.try_emplace(D, Result);
   return Result;
 }
 
 std::optional<Symbol> Recognizer::operator()(const Decl *D) {
+  Lang L;
+  if (D->getLangOpts().CPlusPlus) {
+    L = Lang::CXX;
+  } else if (D->getLangOpts().C11) {
+    L = Lang::C;
+  } else {
+    return std::nullopt; // not a supported language.
+  }
+
   // If D is std::vector::iterator, `vector` is the outer symbol to look up.
   // We keep all the candidate DCs as some may turn out to be anon enums.
   // Do this resolution lazily as we may turn out not to have a std namespace.
   llvm::SmallVector<const DeclContext *> IntermediateDecl;
   const DeclContext *DC = D->getDeclContext();
-  while (DC && !DC->isNamespace()) {
+  if (!DC) // The passed D is a TranslationUnitDecl!
+    return std::nullopt;
+  while (!DC->isNamespace() && !DC->isTranslationUnit()) {
     if (NamedDecl::classofKind(DC->getDeclKind()))
       IntermediateDecl.push_back(DC);
     DC = DC->getParent();
   }
-  NSSymbolMap *Symbols = namespaceSymbols(cast_or_null<NamespaceDecl>(DC));
+  NSSymbolMap *Symbols = namespaceSymbols(DC, L);
   if (!Symbols)
     return std::nullopt;
 
@@ -157,7 +290,7 @@ std::optional<Symbol> Recognizer::operator()(const Decl *D) {
   auto It = Symbols->find(Name);
   if (It == Symbols->end())
     return std::nullopt;
-  return Symbol(It->second);
+  return Symbol(It->second, L);
 }
 
 } // namespace stdlib
diff --git a/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/StdSpecialSymbolMap.inc b/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/StdSpecialSymbolMap.inc
new file mode 100644
index 000000000000..ae620a0b9958
--- /dev/null
+++ b/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/StdSpecialSymbolMap.inc
@@ -0,0 +1,722 @@
+//===-- StdSpecialSymbolMap.inc ---------------------------------*- C++ -*-===//
+//
+// This is a hand-curated list for C++ symbols that cannot be parsed/extracted
+// via the include-mapping tool (gen_std.py).
+//
+//===----------------------------------------------------------------------===//
+
+// Symbols that can be provided by any of the headers, ordered by the header
+// preference.
+// cppreference mentions the <locale> header is an alternative for these symbols,
+// but they are not per the standard.
+SYMBOL(consume_header, std::, <codecvt>)
+SYMBOL(generate_header, std::, <codecvt>)
+SYMBOL(little_endian, std::, <codecvt>)
+
+SYMBOL(mbstate_t, std::, <cwchar>)
+SYMBOL(mbstate_t, std::, <cuchar>)
+SYMBOL(size_t, std::, <cstddef>)
+SYMBOL(size_t, std::, <cstdlib>)
+SYMBOL(size_t, std::, <cstring>)
+SYMBOL(size_t, std::, <cwchar>)
+SYMBOL(size_t, std::, <cuchar>)
+SYMBOL(size_t, std::, <ctime>)
+SYMBOL(size_t, std::, <cstdio>)
+SYMBOL(size_t, None, <cstddef>)
+SYMBOL(size_t, None, <cstdlib>)
+SYMBOL(size_t, None, <cstring>)
+SYMBOL(size_t, None, <cwchar>)
+SYMBOL(size_t, None, <cuchar>)
+SYMBOL(size_t, None, <ctime>)
+SYMBOL(size_t, None, <cstdio>)
+SYMBOL(size_t, None, <stddef.h>)
+SYMBOL(size_t, None, <stdlib.h>)
+SYMBOL(size_t, None, <string.h>)
+SYMBOL(size_t, None, <wchar.h>)
+SYMBOL(size_t, None, <uchar.h>)
+SYMBOL(size_t, None, <time.h>)
+SYMBOL(size_t, None, <stdio.h>)
+SYMBOL(unwrap_ref_decay, std::, <type_traits>)
+SYMBOL(unwrap_ref_decay, std::, <functional>)
+SYMBOL(unwrap_reference, std::, <type_traits>)
+SYMBOL(unwrap_reference, std::, <functional>)
+SYMBOL(unwrap_ref_decay_t, std::, <type_traits>)
+SYMBOL(unwrap_ref_decay_t, std::, <functional>)
+SYMBOL(wint_t, std::, <cwctype>)
+SYMBOL(wint_t, std::, <cwchar>)
+SYMBOL(swap, std::, <utility>)
+SYMBOL(swap, std::, <algorithm>) // until C++11
+// C++ [string.view.synop 23.3.2]: The function templates defined in
+// [utility.swap] ... are available when <string_­view> is included.
+SYMBOL(swap, std::, <string_view>) // since C++17
+// C++ [tuple.helper 22.4.7]: In addition to being available via inclusion of
+// the <tuple> header, ... any of the headers <array>, <ranges>, or <utility>
+// are included.
+SYMBOL(tuple_size, std::, <tuple>)
+SYMBOL(tuple_size, std::, <array>)
+SYMBOL(tuple_size, std::, <ranges>)
+SYMBOL(tuple_size, std::, <utility>)
+SYMBOL(tuple_element, std::, <tuple>)
+SYMBOL(tuple_element, std::, <array>)
+SYMBOL(tuple_element, std::, <ranges>)
+SYMBOL(tuple_element, std::, <utility>)
+// C++ [iterator.range 25.7]: In addition to being available via inclusion of
+// the <iterator> header, the function templates in [iterator.range] are
+// available when any of the following headers are included: <array>, <deque>,
+// <forward_­list>, ... and <vector>.
+SYMBOL(begin, std::, <iterator>)
+SYMBOL(begin, std::, <array>)
+SYMBOL(begin, std::, <deque>)
+SYMBOL(begin, std::, <forward_list>)
+SYMBOL(begin, std::, <list>)
+SYMBOL(begin, std::, <map>)
+SYMBOL(begin, std::, <regex>)
+SYMBOL(begin, std::, <set>)
+SYMBOL(begin, std::, <span>)
+SYMBOL(begin, std::, <string>)
+SYMBOL(begin, std::, <string_view>)
+SYMBOL(begin, std::, <unordered_map>)
+SYMBOL(begin, std::, <unordered_set>)
+SYMBOL(begin, std::, <vector>)
+SYMBOL(cbegin, std::, <iterator>)
+SYMBOL(cbegin, std::, <array>)
+SYMBOL(cbegin, std::, <deque>)
+SYMBOL(cbegin, std::, <forward_list>)
+SYMBOL(cbegin, std::, <list>)
+SYMBOL(cbegin, std::, <map>)
+SYMBOL(cbegin, std::, <regex>)
+SYMBOL(cbegin, std::, <set>)
+SYMBOL(cbegin, std::, <span>)
+SYMBOL(cbegin, std::, <string>)
+SYMBOL(cbegin, std::, <string_view>)
+SYMBOL(cbegin, std::, <unordered_map>)
+SYMBOL(cbegin, std::, <unordered_set>)
+SYMBOL(cbegin, std::, <vector>)
+SYMBOL(cend, std::, <iterator>)
+SYMBOL(cend, std::, <array>)
+SYMBOL(cend, std::, <deque>)
+SYMBOL(cend, std::, <forward_list>)
+SYMBOL(cend, std::, <list>)
+SYMBOL(cend, std::, <map>)
+SYMBOL(cend, std::, <regex>)
+SYMBOL(cend, std::, <set>)
+SYMBOL(cend, std::, <span>)
+SYMBOL(cend, std::, <string>)
+SYMBOL(cend, std::, <string_view>)
+SYMBOL(cend, std::, <unordered_map>)
+SYMBOL(cend, std::, <unordered_set>)
+SYMBOL(cend, std::, <vector>)
+SYMBOL(crbegin, std::, <iterator>)
+SYMBOL(crbegin, std::, <array>)
+SYMBOL(crbegin, std::, <deque>)
+SYMBOL(crbegin, std::, <forward_list>)
+SYMBOL(crbegin, std::, <list>)
+SYMBOL(crbegin, std::, <map>)
+SYMBOL(crbegin, std::, <regex>)
+SYMBOL(crbegin, std::, <set>)
+SYMBOL(crbegin, std::, <span>)
+SYMBOL(crbegin, std::, <string>)
+SYMBOL(crbegin, std::, <string_view>)
+SYMBOL(crbegin, std::, <unordered_map>)
+SYMBOL(crbegin, std::, <unordered_set>)
+SYMBOL(crbegin, std::, <vector>)
+SYMBOL(crend, std::, <iterator>)
+SYMBOL(crend, std::, <array>)
+SYMBOL(crend, std::, <deque>)
+SYMBOL(crend, std::, <forward_list>)
+SYMBOL(crend, std::, <list>)
+SYMBOL(crend, std::, <map>)
+SYMBOL(crend, std::, <regex>)
+SYMBOL(crend, std::, <set>)
+SYMBOL(crend, std::, <span>)
+SYMBOL(crend, std::, <string>)
+SYMBOL(crend, std::, <string_view>)
+SYMBOL(crend, std::, <unordered_map>)
+SYMBOL(crend, std::, <unordered_set>)
+SYMBOL(crend, std::, <vector>)
+SYMBOL(data, std::, <iterator>)
+SYMBOL(data, std::, <array>)
+SYMBOL(data, std::, <deque>)
+SYMBOL(data, std::, <forward_list>)
+SYMBOL(data, std::, <list>)
+SYMBOL(data, std::, <map>)
+SYMBOL(data, std::, <regex>)
+SYMBOL(data, std::, <set>)
+SYMBOL(data, std::, <span>)
+SYMBOL(data, std::, <string>)
+SYMBOL(data, std::, <string_view>)
+SYMBOL(data, std::, <unordered_map>)
+SYMBOL(data, std::, <unordered_set>)
+SYMBOL(data, std::, <vector>)
+SYMBOL(empty, std::, <iterator>)
+SYMBOL(empty, std::, <array>)
+SYMBOL(empty, std::, <deque>)
+SYMBOL(empty, std::, <forward_list>)
+SYMBOL(empty, std::, <list>)
+SYMBOL(empty, std::, <map>)
+SYMBOL(empty, std::, <regex>)
+SYMBOL(empty, std::, <set>)
+SYMBOL(empty, std::, <span>)
+SYMBOL(empty, std::, <string>)
+SYMBOL(empty, std::, <string_view>)
+SYMBOL(empty, std::, <unordered_map>)
+SYMBOL(empty, std::, <unordered_set>)
+SYMBOL(empty, std::, <vector>)
+SYMBOL(end, std::, <iterator>)
+SYMBOL(end, std::, <array>)
+SYMBOL(end, std::, <deque>)
+SYMBOL(end, std::, <forward_list>)
+SYMBOL(end, std::, <list>)
+SYMBOL(end, std::, <map>)
+SYMBOL(end, std::, <regex>)
+SYMBOL(end, std::, <set>)
+SYMBOL(end, std::, <span>)
+SYMBOL(end, std::, <string>)
+SYMBOL(end, std::, <string_view>)
+SYMBOL(end, std::, <unordered_map>)
+SYMBOL(end, std::, <unordered_set>)
+SYMBOL(end, std::, <vector>)
+SYMBOL(rbegin, std::, <iterator>)
+SYMBOL(rbegin, std::, <array>)
+SYMBOL(rbegin, std::, <deque>)
+SYMBOL(rbegin, std::, <forward_list>)
+SYMBOL(rbegin, std::, <list>)
+SYMBOL(rbegin, std::, <map>)
+SYMBOL(rbegin, std::, <regex>)
+SYMBOL(rbegin, std::, <set>)
+SYMBOL(rbegin, std::, <span>)
+SYMBOL(rbegin, std::, <string>)
+SYMBOL(rbegin, std::, <string_view>)
+SYMBOL(rbegin, std::, <unordered_map>)
+SYMBOL(rbegin, std::, <unordered_set>)
+SYMBOL(rbegin, std::, <vector>)
+SYMBOL(rend, std::, <iterator>)
+SYMBOL(rend, std::, <array>)
+SYMBOL(rend, std::, <deque>)
+SYMBOL(rend, std::, <forward_list>)
+SYMBOL(rend, std::, <list>)
+SYMBOL(rend, std::, <map>)
+SYMBOL(rend, std::, <regex>)
+SYMBOL(rend, std::, <set>)
+SYMBOL(rend, std::, <span>)
+SYMBOL(rend, std::, <string>)
+SYMBOL(rend, std::, <string_view>)
+SYMBOL(rend, std::, <unordered_map>)
+SYMBOL(rend, std::, <unordered_set>)
+SYMBOL(rend, std::, <vector>)
+SYMBOL(size, std::, <iterator>)
+SYMBOL(size, std::, <array>)
+SYMBOL(size, std::, <deque>)
+SYMBOL(size, std::, <forward_list>)
+SYMBOL(size, std::, <list>)
+SYMBOL(size, std::, <map>)
+SYMBOL(size, std::, <regex>)
+SYMBOL(size, std::, <set>)
+SYMBOL(size, std::, <span>)
+SYMBOL(size, std::, <string>)
+SYMBOL(size, std::, <string_view>)
+SYMBOL(size, std::, <unordered_map>)
+SYMBOL(size, std::, <unordered_set>)
+SYMBOL(size, std::, <vector>)
+SYMBOL(ssize, std::, <iterator>)
+SYMBOL(ssize, std::, <array>)
+SYMBOL(ssize, std::, <deque>)
+SYMBOL(ssize, std::, <forward_list>)
+SYMBOL(ssize, std::, <list>)
+SYMBOL(ssize, std::, <map>)
+SYMBOL(ssize, std::, <regex>)
+SYMBOL(ssize, std::, <set>)
+SYMBOL(ssize, std::, <span>)
+SYMBOL(ssize, std::, <string>)
+SYMBOL(ssize, std::, <string_view>)
+SYMBOL(ssize, std::, <unordered_map>)
+SYMBOL(ssize, std::, <unordered_set>)
+SYMBOL(ssize, std::, <vector>)
+
+// Add headers for generic integer-type abs.
+// Ignore other variants (std::complex, std::valarray, std::intmax_t)
+SYMBOL(abs, std::, <cstdlib>)
+SYMBOL(abs, std::, <cmath>)
+SYMBOL(abs, None, <cstdlib>)
+SYMBOL(abs, None, <stdlib.h>)
+SYMBOL(abs, None, <cmath>)
+SYMBOL(abs, None, <math.h>)
+
+// Only add headers for the generic atomic template.
+// Ignore variants (std::weak_ptr, std::shared_ptr).
+SYMBOL(atomic, std::, <atomic>)
+// atomic_* family symbols. <stdatomic.h> is for C compatibility.
+SYMBOL(atomic_bool, std::, <atomic>)
+SYMBOL(atomic_bool, None, <stdatomic.h>)
+SYMBOL(atomic_char, std::, <atomic>)
+SYMBOL(atomic_char, None, <stdatomic.h>)
+SYMBOL(atomic_char16_t, std::, <atomic>)
+SYMBOL(atomic_char16_t, None, <stdatomic.h>)
+SYMBOL(atomic_char32_t, std::, <atomic>)
+SYMBOL(atomic_char32_t, None, <stdatomic.h>)
+SYMBOL(atomic_char8_t, std::, <atomic>)
+SYMBOL(atomic_char8_t, None, <stdatomic.h>)
+SYMBOL(atomic_int, std::, <atomic>)
+SYMBOL(atomic_int, None, <stdatomic.h>)
+SYMBOL(atomic_int16_t, std::, <atomic>)
+SYMBOL(atomic_int16_t, None, <stdatomic.h>)
+SYMBOL(atomic_int32_t, std::, <atomic>)
+SYMBOL(atomic_int32_t, None, <stdatomic.h>)
+SYMBOL(atomic_int64_t, std::, <atomic>)
+SYMBOL(atomic_int64_t, None, <stdatomic.h>)
+SYMBOL(atomic_int8_t, std::, <atomic>)
+SYMBOL(atomic_int8_t, None, <stdatomic.h>)
+SYMBOL(atomic_int_fast16_t, std::, <atomic>)
+SYMBOL(atomic_int_fast16_t, None, <stdatomic.h>)
+SYMBOL(atomic_int_fast32_t, std::, <atomic>)
+SYMBOL(atomic_int_fast32_t, None, <stdatomic.h>)
+SYMBOL(atomic_int_fast64_t, std::, <atomic>)
+SYMBOL(atomic_int_fast64_t, None, <stdatomic.h>)
+SYMBOL(atomic_int_fast8_t, std::, <atomic>)
+SYMBOL(atomic_int_fast8_t, None, <stdatomic.h>)
+SYMBOL(atomic_int_least16_t, std::, <atomic>)
+SYMBOL(atomic_int_least16_t, None, <stdatomic.h>)
+SYMBOL(atomic_int_least32_t, std::, <atomic>)
+SYMBOL(atomic_int_least32_t, None, <stdatomic.h>)
+SYMBOL(atomic_int_least64_t, std::, <atomic>)
+SYMBOL(atomic_int_least64_t, None, <stdatomic.h>)
+SYMBOL(atomic_int_least8_t, std::, <atomic>)
+SYMBOL(atomic_int_least8_t, None, <stdatomic.h>)
+SYMBOL(atomic_intmax_t, std::, <atomic>)
+SYMBOL(atomic_intmax_t, None, <stdatomic.h>)
+SYMBOL(atomic_intptr_t, std::, <atomic>)
+SYMBOL(atomic_intptr_t, None, <stdatomic.h>)
+SYMBOL(atomic_llong, std::, <atomic>)
+SYMBOL(atomic_llong, None, <stdatomic.h>)
+SYMBOL(atomic_long, std::, <atomic>)
+SYMBOL(atomic_long, None, <stdatomic.h>)
+SYMBOL(atomic_ptrdiff_t, std::, <atomic>)
+SYMBOL(atomic_ptrdiff_t, None, <stdatomic.h>)
+SYMBOL(atomic_schar, std::, <atomic>)
+SYMBOL(atomic_schar, None, <stdatomic.h>)
+SYMBOL(atomic_short, std::, <atomic>)
+SYMBOL(atomic_short, None, <stdatomic.h>)
+SYMBOL(atomic_signed_lock_free, std::, <atomic>)
+SYMBOL(atomic_signed_lock_free, None, <stdatomic.h>)
+SYMBOL(atomic_size_t, std::, <atomic>)
+SYMBOL(atomic_size_t, None, <stdatomic.h>)
+SYMBOL(atomic_uchar, std::, <atomic>)
+SYMBOL(atomic_uchar, None, <stdatomic.h>)
+SYMBOL(atomic_uint, std::, <atomic>)
+SYMBOL(atomic_uint, None, <stdatomic.h>)
+SYMBOL(atomic_uint16_t, std::, <atomic>)
+SYMBOL(atomic_uint16_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint32_t, std::, <atomic>)
+SYMBOL(atomic_uint32_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint64_t, std::, <atomic>)
+SYMBOL(atomic_uint64_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint8_t, std::, <atomic>)
+SYMBOL(atomic_uint8_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint_fast16_t, std::, <atomic>)
+SYMBOL(atomic_uint_fast16_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint_fast32_t, std::, <atomic>)
+SYMBOL(atomic_uint_fast32_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint_fast64_t, std::, <atomic>)
+SYMBOL(atomic_uint_fast64_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint_fast8_t, std::, <atomic>)
+SYMBOL(atomic_uint_fast8_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint_least16_t, std::, <atomic>)
+SYMBOL(atomic_uint_least16_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint_least32_t, std::, <atomic>)
+SYMBOL(atomic_uint_least32_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint_least64_t, std::, <atomic>)
+SYMBOL(atomic_uint_least64_t, None, <stdatomic.h>)
+SYMBOL(atomic_uint_least8_t, std::, <atomic>)
+SYMBOL(atomic_uint_least8_t, None, <stdatomic.h>)
+SYMBOL(atomic_uintmax_t, std::, <atomic>)
+SYMBOL(atomic_uintmax_t, None, <stdatomic.h>)
+SYMBOL(atomic_uintptr_t, std::, <atomic>)
+SYMBOL(atomic_uintptr_t, None, <stdatomic.h>)
+SYMBOL(atomic_ullong, std::, <atomic>)
+SYMBOL(atomic_ullong, None, <stdatomic.h>)
+SYMBOL(atomic_ulong, std::, <atomic>)
+SYMBOL(atomic_ulong, None, <stdatomic.h>)
+SYMBOL(atomic_unsigned_lock_free, std::, <atomic>)
+SYMBOL(atomic_unsigned_lock_free, None, <stdatomic.h>)
+SYMBOL(atomic_ushort, std::, <atomic>)
+SYMBOL(atomic_ushort, None, <stdatomic.h>)
+SYMBOL(atomic_wchar_t, std::, <atomic>)
+SYMBOL(atomic_wchar_t, None, <stdatomic.h>)
+
+// std::get has a few variants for different types (tuple, array, pair etc)
+// which is tricky to disambiguate without type information.
+// Don't set any header for it, as it comes with the type header.
+SYMBOL(get, std::, /*no headers*/)
+// Similarly make_error_{code,condition} also have different overloads (errc,
+// io_errc, future_errc) and each of them are provided by relevant headers
+// providing the type.
+SYMBOL(make_error_code, std::, /*no headers*/)
+SYMBOL(make_error_condition, std::, /*no headers*/)
+
+// cppreference symbol index page was missing these symbols.
+// Remove them when the cppreference offline archive catches up.
+SYMBOL(index_sequence, std::, <utility>)
+SYMBOL(index_sequence_for, std::, <utility>)
+SYMBOL(make_index_sequence, std::, <utility>)
+SYMBOL(make_integer_sequence, std::, <utility>)
+
+// The std::placeholder symbols (_1, ..., _N) are listed in the cppreference
+// placeholder.html, but the index only contains a single entry with "_1, _2, ..., _N"
+// text, which are not handled by the script.
+// N is an implementation-defined number (10 for libc++; 29 for libstdc++).
+SYMBOL(_1, std::placeholders::, <functional>)
+SYMBOL(_2, std::placeholders::, <functional>)
+SYMBOL(_3, std::placeholders::, <functional>)
+SYMBOL(_4, std::placeholders::, <functional>)
+SYMBOL(_5, std::placeholders::, <functional>)
+SYMBOL(_6, std::placeholders::, <functional>)
+SYMBOL(_7, std::placeholders::, <functional>)
+SYMBOL(_8, std::placeholders::, <functional>)
+SYMBOL(_9, std::placeholders::, <functional>)
+SYMBOL(_10, std::placeholders::, <functional>)
+SYMBOL(_11, std::placeholders::, <functional>)
+SYMBOL(_12, std::placeholders::, <functional>)
+SYMBOL(_13, std::placeholders::, <functional>)
+SYMBOL(_14, std::placeholders::, <functional>)
+SYMBOL(_15, std::placeholders::, <functional>)
+SYMBOL(_16, std::placeholders::, <functional>)
+SYMBOL(_17, std::placeholders::, <functional>)
+SYMBOL(_18, std::placeholders::, <functional>)
+SYMBOL(_19, std::placeholders::, <functional>)
+SYMBOL(_20, std::placeholders::, <functional>)
+SYMBOL(_21, std::placeholders::, <functional>)
+SYMBOL(_22, std::placeholders::, <functional>)
+SYMBOL(_23, std::placeholders::, <functional>)
+SYMBOL(_24, std::placeholders::, <functional>)
+SYMBOL(_25, std::placeholders::, <functional>)
+SYMBOL(_26, std::placeholders::, <functional>)
+SYMBOL(_27, std::placeholders::, <functional>)
+SYMBOL(_28, std::placeholders::, <functional>)
+SYMBOL(_29, std::placeholders::, <functional>)
+
+// Macros
+SYMBOL(NULL, None, <cstddef>)
+SYMBOL(NULL, None, <stddef.h>)
+SYMBOL(NULL, None, <cstdlib>)
+SYMBOL(NULL, None, <stdlib.h>)
+SYMBOL(NULL, None, <cstring>)
+SYMBOL(NULL, None, <string.h>)
+SYMBOL(NULL, None, <cwchar>)
+SYMBOL(NULL, None, <wchar.h>)
+SYMBOL(NULL, None, <ctime>)
+SYMBOL(NULL, None, <time.h>)
+SYMBOL(NULL, None, <clocale>)
+SYMBOL(NULL, None, <locale.h>)
+SYMBOL(NULL, None, <cstdio>)
+SYMBOL(NULL, None, <stdio.h>)
+
+// Theres are macros that not spelled out in page linked from the index.
+// Extracted from https://en.cppreference.com/w/cpp/header/cinttypes
+SYMBOL(PRId8, None, <cinttypes>)
+SYMBOL(PRId8, None, <inttypes.h>)
+SYMBOL(PRId16, None, <cinttypes>)
+SYMBOL(PRId16, None, <inttypes.h>)
+SYMBOL(PRId32, None, <cinttypes>)
+SYMBOL(PRId32, None, <inttypes.h>)
+SYMBOL(PRId64, None, <cinttypes>)
+SYMBOL(PRId64, None, <inttypes.h>)
+SYMBOL(PRIdLEAST8, None, <cinttypes>)
+SYMBOL(PRIdLEAST8, None, <inttypes.h>)
+SYMBOL(PRIdLEAST16, None, <cinttypes>)
+SYMBOL(PRIdLEAST16, None, <inttypes.h>)
+SYMBOL(PRIdLEAST32, None, <cinttypes>)
+SYMBOL(PRIdLEAST32, None, <inttypes.h>)
+SYMBOL(PRIdLEAST64, None, <cinttypes>)
+SYMBOL(PRIdLEAST64, None, <inttypes.h>)
+SYMBOL(PRIdFAST8, None, <cinttypes>)
+SYMBOL(PRIdFAST8, None, <inttypes.h>)
+SYMBOL(PRIdFAST16, None, <cinttypes>)
+SYMBOL(PRIdFAST16, None, <inttypes.h>)
+SYMBOL(PRIdFAST32, None, <cinttypes>)
+SYMBOL(PRIdFAST32, None, <inttypes.h>)
+SYMBOL(PRIdFAST64, None, <cinttypes>)
+SYMBOL(PRIdFAST64, None, <inttypes.h>)
+SYMBOL(PRIdMAX, None, <cinttypes>)
+SYMBOL(PRIdMAX, None, <inttypes.h>)
+SYMBOL(PRIdPTR, None, <cinttypes>)
+SYMBOL(PRIdPTR, None, <inttypes.h>)
+SYMBOL(PRIi8, None, <cinttypes>)
+SYMBOL(PRIi8, None, <inttypes.h>)
+SYMBOL(PRIi16, None, <cinttypes>)
+SYMBOL(PRIi16, None, <inttypes.h>)
+SYMBOL(PRIi32, None, <cinttypes>)
+SYMBOL(PRIi32, None, <inttypes.h>)
+SYMBOL(PRIi64, None, <cinttypes>)
+SYMBOL(PRIi64, None, <inttypes.h>)
+SYMBOL(PRIiLEAST8, None, <cinttypes>)
+SYMBOL(PRIiLEAST8, None, <inttypes.h>)
+SYMBOL(PRIiLEAST16, None, <cinttypes>)
+SYMBOL(PRIiLEAST16, None, <inttypes.h>)
+SYMBOL(PRIiLEAST32, None, <cinttypes>)
+SYMBOL(PRIiLEAST32, None, <inttypes.h>)
+SYMBOL(PRIiLEAST64, None, <cinttypes>)
+SYMBOL(PRIiLEAST64, None, <inttypes.h>)
+SYMBOL(PRIiFAST8, None, <cinttypes>)
+SYMBOL(PRIiFAST8, None, <inttypes.h>)
+SYMBOL(PRIiFAST16, None, <cinttypes>)
+SYMBOL(PRIiFAST16, None, <inttypes.h>)
+SYMBOL(PRIiFAST32, None, <cinttypes>)
+SYMBOL(PRIiFAST32, None, <inttypes.h>)
+SYMBOL(PRIiFAST64, None, <cinttypes>)
+SYMBOL(PRIiFAST64, None, <inttypes.h>)
+SYMBOL(PRIiMAX, None, <cinttypes>)
+SYMBOL(PRIiMAX, None, <inttypes.h>)
+SYMBOL(PRIiPTR, None, <cinttypes>)
+SYMBOL(PRIiPTR, None, <inttypes.h>)
+SYMBOL(PRIu8, None, <cinttypes>)
+SYMBOL(PRIu8, None, <inttypes.h>)
+SYMBOL(PRIu16, None, <cinttypes>)
+SYMBOL(PRIu16, None, <inttypes.h>)
+SYMBOL(PRIu32, None, <cinttypes>)
+SYMBOL(PRIu32, None, <inttypes.h>)
+SYMBOL(PRIu64, None, <cinttypes>)
+SYMBOL(PRIu64, None, <inttypes.h>)
+SYMBOL(PRIuLEAST8, None, <cinttypes>)
+SYMBOL(PRIuLEAST8, None, <inttypes.h>)
+SYMBOL(PRIuLEAST16, None, <cinttypes>)
+SYMBOL(PRIuLEAST16, None, <inttypes.h>)
+SYMBOL(PRIuLEAST32, None, <cinttypes>)
+SYMBOL(PRIuLEAST32, None, <inttypes.h>)
+SYMBOL(PRIuLEAST64, None, <cinttypes>)
+SYMBOL(PRIuLEAST64, None, <inttypes.h>)
+SYMBOL(PRIuFAST8, None, <cinttypes>)
+SYMBOL(PRIuFAST8, None, <inttypes.h>)
+SYMBOL(PRIuFAST16, None, <cinttypes>)
+SYMBOL(PRIuFAST16, None, <inttypes.h>)
+SYMBOL(PRIuFAST32, None, <cinttypes>)
+SYMBOL(PRIuFAST32, None, <inttypes.h>)
+SYMBOL(PRIuFAST64, None, <cinttypes>)
+SYMBOL(PRIuFAST64, None, <inttypes.h>)
+SYMBOL(PRIuMAX, None, <cinttypes>)
+SYMBOL(PRIuMAX, None, <inttypes.h>)
+SYMBOL(PRIuPTR, None, <cinttypes>)
+SYMBOL(PRIuPTR, None, <inttypes.h>)
+SYMBOL(PRIo8, None, <cinttypes>)
+SYMBOL(PRIo8, None, <inttypes.h>)
+SYMBOL(PRIo16, None, <cinttypes>)
+SYMBOL(PRIo16, None, <inttypes.h>)
+SYMBOL(PRIo32, None, <cinttypes>)
+SYMBOL(PRIo32, None, <inttypes.h>)
+SYMBOL(PRIo64, None, <cinttypes>)
+SYMBOL(PRIo64, None, <inttypes.h>)
+SYMBOL(PRIoLEAST8, None, <cinttypes>)
+SYMBOL(PRIoLEAST8, None, <inttypes.h>)
+SYMBOL(PRIoLEAST16, None, <cinttypes>)
+SYMBOL(PRIoLEAST16, None, <inttypes.h>)
+SYMBOL(PRIoLEAST32, None, <cinttypes>)
+SYMBOL(PRIoLEAST32, None, <inttypes.h>)
+SYMBOL(PRIoLEAST64, None, <cinttypes>)
+SYMBOL(PRIoLEAST64, None, <inttypes.h>)
+SYMBOL(PRIoFAST8, None, <cinttypes>)
+SYMBOL(PRIoFAST8, None, <inttypes.h>)
+SYMBOL(PRIoFAST16, None, <cinttypes>)
+SYMBOL(PRIoFAST16, None, <inttypes.h>)
+SYMBOL(PRIoFAST32, None, <cinttypes>)
+SYMBOL(PRIoFAST32, None, <inttypes.h>)
+SYMBOL(PRIoFAST64, None, <cinttypes>)
+SYMBOL(PRIoFAST64, None, <inttypes.h>)
+SYMBOL(PRIoMAX, None, <cinttypes>)
+SYMBOL(PRIoMAX, None, <inttypes.h>)
+SYMBOL(PRIoPTR, None, <cinttypes>)
+SYMBOL(PRIoPTR, None, <inttypes.h>)
+SYMBOL(PRIx8, None, <cinttypes>)
+SYMBOL(PRIx8, None, <inttypes.h>)
+SYMBOL(PRIx16, None, <cinttypes>)
+SYMBOL(PRIx16, None, <inttypes.h>)
+SYMBOL(PRIx32, None, <cinttypes>)
+SYMBOL(PRIx32, None, <inttypes.h>)
+SYMBOL(PRIx64, None, <cinttypes>)
+SYMBOL(PRIx64, None, <inttypes.h>)
+SYMBOL(PRIxLEAST8, None, <cinttypes>)
+SYMBOL(PRIxLEAST8, None, <inttypes.h>)
+SYMBOL(PRIxLEAST16, None, <cinttypes>)
+SYMBOL(PRIxLEAST16, None, <inttypes.h>)
+SYMBOL(PRIxLEAST32, None, <cinttypes>)
+SYMBOL(PRIxLEAST32, None, <inttypes.h>)
+SYMBOL(PRIxLEAST64, None, <cinttypes>)
+SYMBOL(PRIxLEAST64, None, <inttypes.h>)
+SYMBOL(PRIxFAST8, None, <cinttypes>)
+SYMBOL(PRIxFAST8, None, <inttypes.h>)
+SYMBOL(PRIxFAST16, None, <cinttypes>)
+SYMBOL(PRIxFAST16, None, <inttypes.h>)
+SYMBOL(PRIxFAST32, None, <cinttypes>)
+SYMBOL(PRIxFAST32, None, <inttypes.h>)
+SYMBOL(PRIxFAST64, None, <cinttypes>)
+SYMBOL(PRIxFAST64, None, <inttypes.h>)
+SYMBOL(PRIxMAX, None, <cinttypes>)
+SYMBOL(PRIxMAX, None, <inttypes.h>)
+SYMBOL(PRIxPTR, None, <cinttypes>)
+SYMBOL(PRIxPTR, None, <inttypes.h>)
+SYMBOL(PRIX8, None, <cinttypes>)
+SYMBOL(PRIX8, None, <inttypes.h>)
+SYMBOL(PRIX16, None, <cinttypes>)
+SYMBOL(PRIX16, None, <inttypes.h>)
+SYMBOL(PRIX32, None, <cinttypes>)
+SYMBOL(PRIX32, None, <inttypes.h>)
+SYMBOL(PRIX64, None, <cinttypes>)
+SYMBOL(PRIX64, None, <inttypes.h>)
+SYMBOL(PRIXLEAST8, None, <cinttypes>)
+SYMBOL(PRIXLEAST8, None, <inttypes.h>)
+SYMBOL(PRIXLEAST16, None, <cinttypes>)
+SYMBOL(PRIXLEAST16, None, <inttypes.h>)
+SYMBOL(PRIXLEAST32, None, <cinttypes>)
+SYMBOL(PRIXLEAST32, None, <inttypes.h>)
+SYMBOL(PRIXLEAST64, None, <cinttypes>)
+SYMBOL(PRIXLEAST64, None, <inttypes.h>)
+SYMBOL(PRIXFAST8, None, <cinttypes>)
+SYMBOL(PRIXFAST8, None, <inttypes.h>)
+SYMBOL(PRIXFAST16, None, <cinttypes>)
+SYMBOL(PRIXFAST16, None, <inttypes.h>)
+SYMBOL(PRIXFAST32, None, <cinttypes>)
+SYMBOL(PRIXFAST32, None, <inttypes.h>)
+SYMBOL(PRIXFAST64, None, <cinttypes>)
+SYMBOL(PRIXFAST64, None, <inttypes.h>)
+SYMBOL(PRIXMAX, None, <cinttypes>)
+SYMBOL(PRIXMAX, None, <inttypes.h>)
+SYMBOL(PRIXPTR, None, <cinttypes>)
+SYMBOL(PRIXPTR, None, <inttypes.h>)
+SYMBOL(SCNd8, None, <cinttypes>)
+SYMBOL(SCNd8, None, <inttypes.h>)
+SYMBOL(SCNd16, None, <cinttypes>)
+SYMBOL(SCNd16, None, <inttypes.h>)
+SYMBOL(SCNd32, None, <cinttypes>)
+SYMBOL(SCNd32, None, <inttypes.h>)
+SYMBOL(SCNd64, None, <cinttypes>)
+SYMBOL(SCNd64, None, <inttypes.h>)
+SYMBOL(SCNdLEAST8, None, <cinttypes>)
+SYMBOL(SCNdLEAST8, None, <inttypes.h>)
+SYMBOL(SCNdLEAST16, None, <cinttypes>)
+SYMBOL(SCNdLEAST16, None, <inttypes.h>)
+SYMBOL(SCNdLEAST32, None, <cinttypes>)
+SYMBOL(SCNdLEAST32, None, <inttypes.h>)
+SYMBOL(SCNdLEAST64, None, <cinttypes>)
+SYMBOL(SCNdLEAST64, None, <inttypes.h>)
+SYMBOL(SCNdFAST8, None, <cinttypes>)
+SYMBOL(SCNdFAST8, None, <inttypes.h>)
+SYMBOL(SCNdFAST16, None, <cinttypes>)
+SYMBOL(SCNdFAST16, None, <inttypes.h>)
+SYMBOL(SCNdFAST32, None, <cinttypes>)
+SYMBOL(SCNdFAST32, None, <inttypes.h>)
+SYMBOL(SCNdFAST64, None, <cinttypes>)
+SYMBOL(SCNdFAST64, None, <inttypes.h>)
+SYMBOL(SCNdMAX, None, <cinttypes>)
+SYMBOL(SCNdMAX, None, <inttypes.h>)
+SYMBOL(SCNdPTR, None, <cinttypes>)
+SYMBOL(SCNdPTR, None, <inttypes.h>)
+SYMBOL(SCNi8, None, <cinttypes>)
+SYMBOL(SCNi8, None, <inttypes.h>)
+SYMBOL(SCNi16, None, <cinttypes>)
+SYMBOL(SCNi16, None, <inttypes.h>)
+SYMBOL(SCNi32, None, <cinttypes>)
+SYMBOL(SCNi32, None, <inttypes.h>)
+SYMBOL(SCNi64, None, <cinttypes>)
+SYMBOL(SCNi64, None, <inttypes.h>)
+SYMBOL(SCNiLEAST8, None, <cinttypes>)
+SYMBOL(SCNiLEAST8, None, <inttypes.h>)
+SYMBOL(SCNiLEAST16, None, <cinttypes>)
+SYMBOL(SCNiLEAST16, None, <inttypes.h>)
+SYMBOL(SCNiLEAST32, None, <cinttypes>)
+SYMBOL(SCNiLEAST32, None, <inttypes.h>)
+SYMBOL(SCNiLEAST64, None, <cinttypes>)
+SYMBOL(SCNiLEAST64, None, <inttypes.h>)
+SYMBOL(SCNiFAST8, None, <cinttypes>)
+SYMBOL(SCNiFAST8, None, <inttypes.h>)
+SYMBOL(SCNiFAST16, None, <cinttypes>)
+SYMBOL(SCNiFAST16, None, <inttypes.h>)
+SYMBOL(SCNiFAST32, None, <cinttypes>)
+SYMBOL(SCNiFAST32, None, <inttypes.h>)
+SYMBOL(SCNiFAST64, None, <cinttypes>)
+SYMBOL(SCNiFAST64, None, <inttypes.h>)
+SYMBOL(SCNiMAX, None, <cinttypes>)
+SYMBOL(SCNiMAX, None, <inttypes.h>)
+SYMBOL(SCNiPTR, None, <cinttypes>)
+SYMBOL(SCNiPTR, None, <inttypes.h>)
+SYMBOL(SCNu8, None, <cinttypes>)
+SYMBOL(SCNu8, None, <inttypes.h>)
+SYMBOL(SCNu16, None, <cinttypes>)
+SYMBOL(SCNu16, None, <inttypes.h>)
+SYMBOL(SCNu32, None, <cinttypes>)
+SYMBOL(SCNu32, None, <inttypes.h>)
+SYMBOL(SCNu64, None, <cinttypes>)
+SYMBOL(SCNu64, None, <inttypes.h>)
+SYMBOL(SCNuLEAST8, None, <cinttypes>)
+SYMBOL(SCNuLEAST8, None, <inttypes.h>)
+SYMBOL(SCNuLEAST16, None, <cinttypes>)
+SYMBOL(SCNuLEAST16, None, <inttypes.h>)
+SYMBOL(SCNuLEAST32, None, <cinttypes>)
+SYMBOL(SCNuLEAST32, None, <inttypes.h>)
+SYMBOL(SCNuLEAST64, None, <cinttypes>)
+SYMBOL(SCNuLEAST64, None, <inttypes.h>)
+SYMBOL(SCNuFAST8, None, <cinttypes>)
+SYMBOL(SCNuFAST8, None, <inttypes.h>)
+SYMBOL(SCNuFAST16, None, <cinttypes>)
+SYMBOL(SCNuFAST16, None, <inttypes.h>)
+SYMBOL(SCNuFAST32, None, <cinttypes>)
+SYMBOL(SCNuFAST32, None, <inttypes.h>)
+SYMBOL(SCNuFAST64, None, <cinttypes>)
+SYMBOL(SCNuFAST64, None, <inttypes.h>)
+SYMBOL(SCNuMAX, None, <cinttypes>)
+SYMBOL(SCNuMAX, None, <inttypes.h>)
+SYMBOL(SCNuPTR, None, <cinttypes>)
+SYMBOL(SCNuPTR, None, <inttypes.h>)
+SYMBOL(SCNo8, None, <cinttypes>)
+SYMBOL(SCNo8, None, <inttypes.h>)
+SYMBOL(SCNo16, None, <cinttypes>)
+SYMBOL(SCNo16, None, <inttypes.h>)
+SYMBOL(SCNo32, None, <cinttypes>)
+SYMBOL(SCNo32, None, <inttypes.h>)
+SYMBOL(SCNo64, None, <cinttypes>)
+SYMBOL(SCNo64, None, <inttypes.h>)
+SYMBOL(SCNoLEAST8, None, <cinttypes>)
+SYMBOL(SCNoLEAST8, None, <inttypes.h>)
+SYMBOL(SCNoLEAST16, None, <cinttypes>)
+SYMBOL(SCNoLEAST16, None, <inttypes.h>)
+SYMBOL(SCNoLEAST32, None, <cinttypes>)
+SYMBOL(SCNoLEAST32, None, <inttypes.h>)
+SYMBOL(SCNoLEAST64, None, <cinttypes>)
+SYMBOL(SCNoLEAST64, None, <inttypes.h>)
+SYMBOL(SCNoFAST8, None, <cinttypes>)
+SYMBOL(SCNoFAST8, None, <inttypes.h>)
+SYMBOL(SCNoFAST16, None, <cinttypes>)
+SYMBOL(SCNoFAST16, None, <inttypes.h>)
+SYMBOL(SCNoFAST32, None, <cinttypes>)
+SYMBOL(SCNoFAST32, None, <inttypes.h>)
+SYMBOL(SCNoFAST64, None, <cinttypes>)
+SYMBOL(SCNoFAST64, None, <inttypes.h>)
+SYMBOL(SCNoMAX, None, <cinttypes>)
+SYMBOL(SCNoMAX, None, <inttypes.h>)
+SYMBOL(SCNoPTR, None, <cinttypes>)
+SYMBOL(SCNoPTR, None, <inttypes.h>)
+SYMBOL(SCNx8, None, <cinttypes>)
+SYMBOL(SCNx8, None, <inttypes.h>)
+SYMBOL(SCNx16, None, <cinttypes>)
+SYMBOL(SCNx16, None, <inttypes.h>)
+SYMBOL(SCNx32, None, <cinttypes>)
+SYMBOL(SCNx32, None, <inttypes.h>)
+SYMBOL(SCNx64, None, <cinttypes>)
+SYMBOL(SCNx64, None, <inttypes.h>)
+SYMBOL(SCNxLEAST8, None, <cinttypes>)
+SYMBOL(SCNxLEAST8, None, <inttypes.h>)
+SYMBOL(SCNxLEAST16, None, <cinttypes>)
+SYMBOL(SCNxLEAST16, None, <inttypes.h>)
+SYMBOL(SCNxLEAST32, None, <cinttypes>)
+SYMBOL(SCNxLEAST32, None, <inttypes.h>)
+SYMBOL(SCNxLEAST64, None, <cinttypes>)
+SYMBOL(SCNxLEAST64, None, <inttypes.h>)
+SYMBOL(SCNxFAST8, None, <cinttypes>)
+SYMBOL(SCNxFAST8, None, <inttypes.h>)
+SYMBOL(SCNxFAST16, None, <cinttypes>)
+SYMBOL(SCNxFAST16, None, <inttypes.h>)
+SYMBOL(SCNxFAST32, None, <cinttypes>)
+SYMBOL(SCNxFAST32, None, <inttypes.h>)
+SYMBOL(SCNxFAST64, None, <cinttypes>)
+SYMBOL(SCNxFAST64, None, <inttypes.h>)
+SYMBOL(SCNxMAX, None, <cinttypes>)
+SYMBOL(SCNxMAX, None, <inttypes.h>)
+SYMBOL(SCNxPTR, None, <cinttypes>)
+SYMBOL(SCNxPTR, None, <inttypes.h>)
diff --git a/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc b/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc
new file mode 100644
index 000000000000..a08ec11e77a4
--- /dev/null
+++ b/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc
@@ -0,0 +1,3819 @@
+//===-- gen_std.py generated file -------------------------------*- C++ -*-===//
+//
+// Used to build a lookup table (qualified names => include headers) for CPP
+// Standard Library symbols.
+//
+// This file was generated automatically by
+// clang/tools/include-mapping/gen_std.py, DO NOT EDIT!
+//
+// Generated from cppreference offline HTML book (modified on 2022-07-30).
+//===----------------------------------------------------------------------===//
+
+SYMBOL(ATOMIC_BOOL_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_CHAR16_T_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_CHAR32_T_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_CHAR8_T_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_CHAR_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_FLAG_INIT, None, <atomic>)
+SYMBOL(ATOMIC_INT_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_LLONG_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_LONG_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_POINTER_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_SHORT_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_VAR_INIT, None, <atomic>)
+SYMBOL(ATOMIC_WCHAR_T_LOCK_FREE, None, <atomic>)
+SYMBOL(BUFSIZ, None, <cstdio>)
+SYMBOL(BUFSIZ, None, <stdio.h>)
+SYMBOL(CHAR_BIT, None, <climits>)
+SYMBOL(CHAR_BIT, None, <limits.h>)
+SYMBOL(CHAR_MAX, None, <climits>)
+SYMBOL(CHAR_MAX, None, <limits.h>)
+SYMBOL(CHAR_MIN, None, <climits>)
+SYMBOL(CHAR_MIN, None, <limits.h>)
+SYMBOL(CLOCKS_PER_SEC, None, <ctime>)
+SYMBOL(CLOCKS_PER_SEC, None, <time.h>)
+SYMBOL(DBL_DECIMAL_DIG, None, <cfloat>)
+SYMBOL(DBL_DECIMAL_DIG, None, <float.h>)
+SYMBOL(DBL_DIG, None, <cfloat>)
+SYMBOL(DBL_DIG, None, <float.h>)
+SYMBOL(DBL_EPSILON, None, <cfloat>)
+SYMBOL(DBL_EPSILON, None, <float.h>)
+SYMBOL(DBL_HAS_SUBNORM, None, <cfloat>)
+SYMBOL(DBL_HAS_SUBNORM, None, <float.h>)
+SYMBOL(DBL_MANT_DIG, None, <cfloat>)
+SYMBOL(DBL_MANT_DIG, None, <float.h>)
+SYMBOL(DBL_MAX, None, <cfloat>)
+SYMBOL(DBL_MAX, None, <float.h>)
+SYMBOL(DBL_MAX_10_EXP, None, <cfloat>)
+SYMBOL(DBL_MAX_10_EXP, None, <float.h>)
+SYMBOL(DBL_MAX_EXP, None, <cfloat>)
+SYMBOL(DBL_MAX_EXP, None, <float.h>)
+SYMBOL(DBL_MIN, None, <cfloat>)
+SYMBOL(DBL_MIN, None, <float.h>)
+SYMBOL(DBL_MIN_10_EXP, None, <cfloat>)
+SYMBOL(DBL_MIN_10_EXP, None, <float.h>)
+SYMBOL(DBL_MIN_EXP, None, <cfloat>)
+SYMBOL(DBL_MIN_EXP, None, <float.h>)
+SYMBOL(DBL_TRUE_MIN, None, <cfloat>)
+SYMBOL(DBL_TRUE_MIN, None, <float.h>)
+SYMBOL(DECIMAL_DIG, None, <cfloat>)
+SYMBOL(DECIMAL_DIG, None, <float.h>)
+SYMBOL(E2BIG, None, <cerrno>)
+SYMBOL(E2BIG, None, <errno.h>)
+SYMBOL(EACCES, None, <cerrno>)
+SYMBOL(EACCES, None, <errno.h>)
+SYMBOL(EADDRINUSE, None, <cerrno>)
+SYMBOL(EADDRINUSE, None, <errno.h>)
+SYMBOL(EADDRNOTAVAIL, None, <cerrno>)
+SYMBOL(EADDRNOTAVAIL, None, <errno.h>)
+SYMBOL(EAFNOSUPPORT, None, <cerrno>)
+SYMBOL(EAFNOSUPPORT, None, <errno.h>)
+SYMBOL(EAGAIN, None, <cerrno>)
+SYMBOL(EAGAIN, None, <errno.h>)
+SYMBOL(EALREADY, None, <cerrno>)
+SYMBOL(EALREADY, None, <errno.h>)
+SYMBOL(EBADF, None, <cerrno>)
+SYMBOL(EBADF, None, <errno.h>)
+SYMBOL(EBADMSG, None, <cerrno>)
+SYMBOL(EBADMSG, None, <errno.h>)
+SYMBOL(EBUSY, None, <cerrno>)
+SYMBOL(EBUSY, None, <errno.h>)
+SYMBOL(ECANCELED, None, <cerrno>)
+SYMBOL(ECANCELED, None, <errno.h>)
+SYMBOL(ECHILD, None, <cerrno>)
+SYMBOL(ECHILD, None, <errno.h>)
+SYMBOL(ECONNABORTED, None, <cerrno>)
+SYMBOL(ECONNABORTED, None, <errno.h>)
+SYMBOL(ECONNREFUSED, None, <cerrno>)
+SYMBOL(ECONNREFUSED, None, <errno.h>)
+SYMBOL(ECONNRESET, None, <cerrno>)
+SYMBOL(ECONNRESET, None, <errno.h>)
+SYMBOL(EDEADLK, None, <cerrno>)
+SYMBOL(EDEADLK, None, <errno.h>)
+SYMBOL(EDESTADDRREQ, None, <cerrno>)
+SYMBOL(EDESTADDRREQ, None, <errno.h>)
+SYMBOL(EDOM, None, <cerrno>)
+SYMBOL(EDOM, None, <errno.h>)
+SYMBOL(EEXIST, None, <cerrno>)
+SYMBOL(EEXIST, None, <errno.h>)
+SYMBOL(EFAULT, None, <cerrno>)
+SYMBOL(EFAULT, None, <errno.h>)
+SYMBOL(EFBIG, None, <cerrno>)
+SYMBOL(EFBIG, None, <errno.h>)
+SYMBOL(EHOSTUNREACH, None, <cerrno>)
+SYMBOL(EHOSTUNREACH, None, <errno.h>)
+SYMBOL(EIDRM, None, <cerrno>)
+SYMBOL(EIDRM, None, <errno.h>)
+SYMBOL(EILSEQ, None, <cerrno>)
+SYMBOL(EILSEQ, None, <errno.h>)
+SYMBOL(EINPROGRESS, None, <cerrno>)
+SYMBOL(EINPROGRESS, None, <errno.h>)
+SYMBOL(EINTR, None, <cerrno>)
+SYMBOL(EINTR, None, <errno.h>)
+SYMBOL(EINVAL, None, <cerrno>)
+SYMBOL(EINVAL, None, <errno.h>)
+SYMBOL(EIO, None, <cerrno>)
+SYMBOL(EIO, None, <errno.h>)
+SYMBOL(EISCONN, None, <cerrno>)
+SYMBOL(EISCONN, None, <errno.h>)
+SYMBOL(EISDIR, None, <cerrno>)
+SYMBOL(EISDIR, None, <errno.h>)
+SYMBOL(ELOOP, None, <cerrno>)
+SYMBOL(ELOOP, None, <errno.h>)
+SYMBOL(EMFILE, None, <cerrno>)
+SYMBOL(EMFILE, None, <errno.h>)
+SYMBOL(EMLINK, None, <cerrno>)
+SYMBOL(EMLINK, None, <errno.h>)
+SYMBOL(EMSGSIZE, None, <cerrno>)
+SYMBOL(EMSGSIZE, None, <errno.h>)
+SYMBOL(ENAMETOOLONG, None, <cerrno>)
+SYMBOL(ENAMETOOLONG, None, <errno.h>)
+SYMBOL(ENETDOWN, None, <cerrno>)
+SYMBOL(ENETDOWN, None, <errno.h>)
+SYMBOL(ENETRESET, None, <cerrno>)
+SYMBOL(ENETRESET, None, <errno.h>)
+SYMBOL(ENETUNREACH, None, <cerrno>)
+SYMBOL(ENETUNREACH, None, <errno.h>)
+SYMBOL(ENFILE, None, <cerrno>)
+SYMBOL(ENFILE, None, <errno.h>)
+SYMBOL(ENOBUFS, None, <cerrno>)
+SYMBOL(ENOBUFS, None, <errno.h>)
+SYMBOL(ENODATA, None, <cerrno>)
+SYMBOL(ENODATA, None, <errno.h>)
+SYMBOL(ENODEV, None, <cerrno>)
+SYMBOL(ENODEV, None, <errno.h>)
+SYMBOL(ENOENT, None, <cerrno>)
+SYMBOL(ENOENT, None, <errno.h>)
+SYMBOL(ENOEXEC, None, <cerrno>)
+SYMBOL(ENOEXEC, None, <errno.h>)
+SYMBOL(ENOLCK, None, <cerrno>)
+SYMBOL(ENOLCK, None, <errno.h>)
+SYMBOL(ENOLINK, None, <cerrno>)
+SYMBOL(ENOLINK, None, <errno.h>)
+SYMBOL(ENOMEM, None, <cerrno>)
+SYMBOL(ENOMEM, None, <errno.h>)
+SYMBOL(ENOMSG, None, <cerrno>)
+SYMBOL(ENOMSG, None, <errno.h>)
+SYMBOL(ENOPROTOOPT, None, <cerrno>)
+SYMBOL(ENOPROTOOPT, None, <errno.h>)
+SYMBOL(ENOSPC, None, <cerrno>)
+SYMBOL(ENOSPC, None, <errno.h>)
+SYMBOL(ENOSR, None, <cerrno>)
+SYMBOL(ENOSR, None, <errno.h>)
+SYMBOL(ENOSTR, None, <cerrno>)
+SYMBOL(ENOSTR, None, <errno.h>)
+SYMBOL(ENOSYS, None, <cerrno>)
+SYMBOL(ENOSYS, None, <errno.h>)
+SYMBOL(ENOTCONN, None, <cerrno>)
+SYMBOL(ENOTCONN, None, <errno.h>)
+SYMBOL(ENOTDIR, None, <cerrno>)
+SYMBOL(ENOTDIR, None, <errno.h>)
+SYMBOL(ENOTEMPTY, None, <cerrno>)
+SYMBOL(ENOTEMPTY, None, <errno.h>)
+SYMBOL(ENOTRECOVERABLE, None, <cerrno>)
+SYMBOL(ENOTRECOVERABLE, None, <errno.h>)
+SYMBOL(ENOTSOCK, None, <cerrno>)
+SYMBOL(ENOTSOCK, None, <errno.h>)
+SYMBOL(ENOTSUP, None, <cerrno>)
+SYMBOL(ENOTSUP, None, <errno.h>)
+SYMBOL(ENOTTY, None, <cerrno>)
+SYMBOL(ENOTTY, None, <errno.h>)
+SYMBOL(ENXIO, None, <cerrno>)
+SYMBOL(ENXIO, None, <errno.h>)
+SYMBOL(EOF, None, <cstdio>)
+SYMBOL(EOF, None, <stdio.h>)
+SYMBOL(EOPNOTSUPP, None, <cerrno>)
+SYMBOL(EOPNOTSUPP, None, <errno.h>)
+SYMBOL(EOVERFLOW, None, <cerrno>)
+SYMBOL(EOVERFLOW, None, <errno.h>)
+SYMBOL(EOWNERDEAD, None, <cerrno>)
+SYMBOL(EOWNERDEAD, None, <errno.h>)
+SYMBOL(EPERM, None, <cerrno>)
+SYMBOL(EPERM, None, <errno.h>)
+SYMBOL(EPIPE, None, <cerrno>)
+SYMBOL(EPIPE, None, <errno.h>)
+SYMBOL(EPROTO, None, <cerrno>)
+SYMBOL(EPROTO, None, <errno.h>)
+SYMBOL(EPROTONOSUPPORT, None, <cerrno>)
+SYMBOL(EPROTONOSUPPORT, None, <errno.h>)
+SYMBOL(EPROTOTYPE, None, <cerrno>)
+SYMBOL(EPROTOTYPE, None, <errno.h>)
+SYMBOL(ERANGE, None, <cerrno>)
+SYMBOL(ERANGE, None, <errno.h>)
+SYMBOL(EROFS, None, <cerrno>)
+SYMBOL(EROFS, None, <errno.h>)
+SYMBOL(ESPIPE, None, <cerrno>)
+SYMBOL(ESPIPE, None, <errno.h>)
+SYMBOL(ESRCH, None, <cerrno>)
+SYMBOL(ESRCH, None, <errno.h>)
+SYMBOL(ETIME, None, <cerrno>)
+SYMBOL(ETIME, None, <errno.h>)
+SYMBOL(ETIMEDOUT, None, <cerrno>)
+SYMBOL(ETIMEDOUT, None, <errno.h>)
+SYMBOL(ETXTBSY, None, <cerrno>)
+SYMBOL(ETXTBSY, None, <errno.h>)
+SYMBOL(EWOULDBLOCK, None, <cerrno>)
+SYMBOL(EWOULDBLOCK, None, <errno.h>)
+SYMBOL(EXDEV, None, <cerrno>)
+SYMBOL(EXDEV, None, <errno.h>)
+SYMBOL(EXIT_FAILURE, None, <cstdlib>)
+SYMBOL(EXIT_FAILURE, None, <stdlib.h>)
+SYMBOL(EXIT_SUCCESS, None, <cstdlib>)
+SYMBOL(EXIT_SUCCESS, None, <stdlib.h>)
+SYMBOL(FE_ALL_EXCEPT, None, <cfenv>)
+SYMBOL(FE_ALL_EXCEPT, None, <fenv.h>)
+SYMBOL(FE_DFL_ENV, None, <cfenv>)
+SYMBOL(FE_DFL_ENV, None, <fenv.h>)
+SYMBOL(FE_DIVBYZERO, None, <cfenv>)
+SYMBOL(FE_DIVBYZERO, None, <fenv.h>)
+SYMBOL(FE_DOWNWARD, None, <cfenv>)
+SYMBOL(FE_DOWNWARD, None, <fenv.h>)
+SYMBOL(FE_INEXACT, None, <cfenv>)
+SYMBOL(FE_INEXACT, None, <fenv.h>)
+SYMBOL(FE_INVALID, None, <cfenv>)
+SYMBOL(FE_INVALID, None, <fenv.h>)
+SYMBOL(FE_OVERFLOW, None, <cfenv>)
+SYMBOL(FE_OVERFLOW, None, <fenv.h>)
+SYMBOL(FE_TONEAREST, None, <cfenv>)
+SYMBOL(FE_TONEAREST, None, <fenv.h>)
+SYMBOL(FE_TOWARDZERO, None, <cfenv>)
+SYMBOL(FE_TOWARDZERO, None, <fenv.h>)
+SYMBOL(FE_UNDERFLOW, None, <cfenv>)
+SYMBOL(FE_UNDERFLOW, None, <fenv.h>)
+SYMBOL(FE_UPWARD, None, <cfenv>)
+SYMBOL(FE_UPWARD, None, <fenv.h>)
+SYMBOL(FILENAME_MAX, None, <cstdio>)
+SYMBOL(FILENAME_MAX, None, <stdio.h>)
+SYMBOL(FLT_DECIMAL_DIG, None, <cfloat>)
+SYMBOL(FLT_DECIMAL_DIG, None, <float.h>)
+SYMBOL(FLT_DIG, None, <cfloat>)
+SYMBOL(FLT_DIG, None, <float.h>)
+SYMBOL(FLT_EPSILON, None, <cfloat>)
+SYMBOL(FLT_EPSILON, None, <float.h>)
+SYMBOL(FLT_EVAL_METHOD, None, <cfloat>)
+SYMBOL(FLT_EVAL_METHOD, None, <float.h>)
+SYMBOL(FLT_HAS_SUBNORM, None, <cfloat>)
+SYMBOL(FLT_HAS_SUBNORM, None, <float.h>)
+SYMBOL(FLT_MANT_DIG, None, <cfloat>)
+SYMBOL(FLT_MANT_DIG, None, <float.h>)
+SYMBOL(FLT_MAX, None, <cfloat>)
+SYMBOL(FLT_MAX, None, <float.h>)
+SYMBOL(FLT_MAX_10_EXP, None, <cfloat>)
+SYMBOL(FLT_MAX_10_EXP, None, <float.h>)
+SYMBOL(FLT_MAX_EXP, None, <cfloat>)
+SYMBOL(FLT_MAX_EXP, None, <float.h>)
+SYMBOL(FLT_MIN, None, <cfloat>)
+SYMBOL(FLT_MIN, None, <float.h>)
+SYMBOL(FLT_MIN_10_EXP, None, <cfloat>)
+SYMBOL(FLT_MIN_10_EXP, None, <float.h>)
+SYMBOL(FLT_MIN_EXP, None, <cfloat>)
+SYMBOL(FLT_MIN_EXP, None, <float.h>)
+SYMBOL(FLT_RADIX, None, <cfloat>)
+SYMBOL(FLT_RADIX, None, <float.h>)
+SYMBOL(FLT_ROUNDS, None, <cfloat>)
+SYMBOL(FLT_ROUNDS, None, <float.h>)
+SYMBOL(FLT_TRUE_MIN, None, <cfloat>)
+SYMBOL(FLT_TRUE_MIN, None, <float.h>)
+SYMBOL(FOPEN_MAX, None, <cstdio>)
+SYMBOL(FOPEN_MAX, None, <stdio.h>)
+SYMBOL(FP_FAST_FMA, None, <cmath>)
+SYMBOL(FP_FAST_FMA, None, <math.h>)
+SYMBOL(FP_FAST_FMAF, None, <cmath>)
+SYMBOL(FP_FAST_FMAF, None, <math.h>)
+SYMBOL(FP_FAST_FMAL, None, <cmath>)
+SYMBOL(FP_FAST_FMAL, None, <math.h>)
+SYMBOL(FP_ILOGB0, None, <cmath>)
+SYMBOL(FP_ILOGB0, None, <math.h>)
+SYMBOL(FP_ILOGBNAN, None, <cmath>)
+SYMBOL(FP_ILOGBNAN, None, <math.h>)
+SYMBOL(FP_INFINITE, None, <cmath>)
+SYMBOL(FP_INFINITE, None, <math.h>)
+SYMBOL(FP_NAN, None, <cmath>)
+SYMBOL(FP_NAN, None, <math.h>)
+SYMBOL(FP_NORMAL, None, <cmath>)
+SYMBOL(FP_NORMAL, None, <math.h>)
+SYMBOL(FP_SUBNORMAL, None, <cmath>)
+SYMBOL(FP_SUBNORMAL, None, <math.h>)
+SYMBOL(FP_ZERO, None, <cmath>)
+SYMBOL(FP_ZERO, None, <math.h>)
+SYMBOL(HUGE_VAL, None, <cmath>)
+SYMBOL(HUGE_VAL, None, <math.h>)
+SYMBOL(HUGE_VALF, None, <cmath>)
+SYMBOL(HUGE_VALF, None, <math.h>)
+SYMBOL(HUGE_VALL, None, <cmath>)
+SYMBOL(HUGE_VALL, None, <math.h>)
+SYMBOL(INFINITY, None, <cmath>)
+SYMBOL(INFINITY, None, <math.h>)
+SYMBOL(INT16_MAX, None, <cstdint>)
+SYMBOL(INT16_MAX, None, <stdint.h>)
+SYMBOL(INT16_MIN, None, <cstdint>)
+SYMBOL(INT16_MIN, None, <stdint.h>)
+SYMBOL(INT32_MAX, None, <cstdint>)
+SYMBOL(INT32_MAX, None, <stdint.h>)
+SYMBOL(INT32_MIN, None, <cstdint>)
+SYMBOL(INT32_MIN, None, <stdint.h>)
+SYMBOL(INT64_MAX, None, <cstdint>)
+SYMBOL(INT64_MAX, None, <stdint.h>)
+SYMBOL(INT64_MIN, None, <cstdint>)
+SYMBOL(INT64_MIN, None, <stdint.h>)
+SYMBOL(INT8_MAX, None, <cstdint>)
+SYMBOL(INT8_MAX, None, <stdint.h>)
+SYMBOL(INT8_MIN, None, <cstdint>)
+SYMBOL(INT8_MIN, None, <stdint.h>)
+SYMBOL(INTMAX_MAX, None, <cstdint>)
+SYMBOL(INTMAX_MAX, None, <stdint.h>)
+SYMBOL(INTMAX_MIN, None, <cstdint>)
+SYMBOL(INTMAX_MIN, None, <stdint.h>)
+SYMBOL(INTPTR_MAX, None, <cstdint>)
+SYMBOL(INTPTR_MAX, None, <stdint.h>)
+SYMBOL(INTPTR_MIN, None, <cstdint>)
+SYMBOL(INTPTR_MIN, None, <stdint.h>)
+SYMBOL(INT_FAST16_MAX, None, <cstdint>)
+SYMBOL(INT_FAST16_MAX, None, <stdint.h>)
+SYMBOL(INT_FAST16_MIN, None, <cstdint>)
+SYMBOL(INT_FAST16_MIN, None, <stdint.h>)
+SYMBOL(INT_FAST32_MAX, None, <cstdint>)
+SYMBOL(INT_FAST32_MAX, None, <stdint.h>)
+SYMBOL(INT_FAST32_MIN, None, <cstdint>)
+SYMBOL(INT_FAST32_MIN, None, <stdint.h>)
+SYMBOL(INT_FAST64_MAX, None, <cstdint>)
+SYMBOL(INT_FAST64_MAX, None, <stdint.h>)
+SYMBOL(INT_FAST64_MIN, None, <cstdint>)
+SYMBOL(INT_FAST64_MIN, None, <stdint.h>)
+SYMBOL(INT_FAST8_MAX, None, <cstdint>)
+SYMBOL(INT_FAST8_MAX, None, <stdint.h>)
+SYMBOL(INT_FAST8_MIN, None, <cstdint>)
+SYMBOL(INT_FAST8_MIN, None, <stdint.h>)
+SYMBOL(INT_LEAST16_MAX, None, <cstdint>)
+SYMBOL(INT_LEAST16_MAX, None, <stdint.h>)
+SYMBOL(INT_LEAST16_MIN, None, <cstdint>)
+SYMBOL(INT_LEAST16_MIN, None, <stdint.h>)
+SYMBOL(INT_LEAST32_MAX, None, <cstdint>)
+SYMBOL(INT_LEAST32_MAX, None, <stdint.h>)
+SYMBOL(INT_LEAST32_MIN, None, <cstdint>)
+SYMBOL(INT_LEAST32_MIN, None, <stdint.h>)
+SYMBOL(INT_LEAST64_MAX, None, <cstdint>)
+SYMBOL(INT_LEAST64_MAX, None, <stdint.h>)
+SYMBOL(INT_LEAST64_MIN, None, <cstdint>)
+SYMBOL(INT_LEAST64_MIN, None, <stdint.h>)
+SYMBOL(INT_LEAST8_MAX, None, <cstdint>)
+SYMBOL(INT_LEAST8_MAX, None, <stdint.h>)
+SYMBOL(INT_LEAST8_MIN, None, <cstdint>)
+SYMBOL(INT_LEAST8_MIN, None, <stdint.h>)
+SYMBOL(INT_MAX, None, <climits>)
+SYMBOL(INT_MAX, None, <limits.h>)
+SYMBOL(INT_MIN, None, <climits>)
+SYMBOL(INT_MIN, None, <limits.h>)
+SYMBOL(LC_ALL, None, <clocale>)
+SYMBOL(LC_ALL, None, <locale.h>)
+SYMBOL(LC_COLLATE, None, <clocale>)
+SYMBOL(LC_COLLATE, None, <locale.h>)
+SYMBOL(LC_CTYPE, None, <clocale>)
+SYMBOL(LC_CTYPE, None, <locale.h>)
+SYMBOL(LC_MONETARY, None, <clocale>)
+SYMBOL(LC_MONETARY, None, <locale.h>)
+SYMBOL(LC_NUMERIC, None, <clocale>)
+SYMBOL(LC_NUMERIC, None, <locale.h>)
+SYMBOL(LC_TIME, None, <clocale>)
+SYMBOL(LC_TIME, None, <locale.h>)
+SYMBOL(LDBL_DECIMAL_DIG, None, <cfloat>)
+SYMBOL(LDBL_DECIMAL_DIG, None, <float.h>)
+SYMBOL(LDBL_DIG, None, <cfloat>)
+SYMBOL(LDBL_DIG, None, <float.h>)
+SYMBOL(LDBL_EPSILON, None, <cfloat>)
+SYMBOL(LDBL_EPSILON, None, <float.h>)
+SYMBOL(LDBL_HAS_SUBNORM, None, <cfloat>)
+SYMBOL(LDBL_HAS_SUBNORM, None, <float.h>)
+SYMBOL(LDBL_MANT_DIG, None, <cfloat>)
+SYMBOL(LDBL_MANT_DIG, None, <float.h>)
+SYMBOL(LDBL_MAX, None, <cfloat>)
+SYMBOL(LDBL_MAX, None, <float.h>)
+SYMBOL(LDBL_MAX_10_EXP, None, <cfloat>)
+SYMBOL(LDBL_MAX_10_EXP, None, <float.h>)
+SYMBOL(LDBL_MAX_EXP, None, <cfloat>)
+SYMBOL(LDBL_MAX_EXP, None, <float.h>)
+SYMBOL(LDBL_MIN, None, <cfloat>)
+SYMBOL(LDBL_MIN, None, <float.h>)
+SYMBOL(LDBL_MIN_10_EXP, None, <cfloat>)
+SYMBOL(LDBL_MIN_10_EXP, None, <float.h>)
+SYMBOL(LDBL_MIN_EXP, None, <cfloat>)
+SYMBOL(LDBL_MIN_EXP, None, <float.h>)
+SYMBOL(LDBL_TRUE_MIN, None, <cfloat>)
+SYMBOL(LDBL_TRUE_MIN, None, <float.h>)
+SYMBOL(LLONG_MAX, None, <climits>)
+SYMBOL(LLONG_MAX, None, <limits.h>)
+SYMBOL(LLONG_MIN, None, <climits>)
+SYMBOL(LLONG_MIN, None, <limits.h>)
+SYMBOL(LONG_MAX, None, <climits>)
+SYMBOL(LONG_MAX, None, <limits.h>)
+SYMBOL(LONG_MIN, None, <climits>)
+SYMBOL(LONG_MIN, None, <limits.h>)
+SYMBOL(L_tmpnam, None, <cstdio>)
+SYMBOL(L_tmpnam, None, <stdio.h>)
+SYMBOL(MATH_ERREXCEPT, None, <cmath>)
+SYMBOL(MATH_ERREXCEPT, None, <math.h>)
+SYMBOL(MATH_ERRNO, None, <cmath>)
+SYMBOL(MATH_ERRNO, None, <math.h>)
+SYMBOL(MB_CUR_MAX, None, <cstdlib>)
+SYMBOL(MB_CUR_MAX, None, <stdlib.h>)
+SYMBOL(MB_LEN_MAX, None, <climits>)
+SYMBOL(MB_LEN_MAX, None, <limits.h>)
+SYMBOL(NAN, None, <cmath>)
+SYMBOL(NAN, None, <math.h>)
+SYMBOL(ONCE_FLAG_INIT, None, <mutex>)
+SYMBOL(PTRDIFF_MAX, None, <cstdint>)
+SYMBOL(PTRDIFF_MAX, None, <stdint.h>)
+SYMBOL(PTRDIFF_MIN, None, <cstdint>)
+SYMBOL(PTRDIFF_MIN, None, <stdint.h>)
+SYMBOL(RAND_MAX, None, <cstdlib>)
+SYMBOL(RAND_MAX, None, <stdlib.h>)
+SYMBOL(SCHAR_MAX, None, <climits>)
+SYMBOL(SCHAR_MAX, None, <limits.h>)
+SYMBOL(SCHAR_MIN, None, <climits>)
+SYMBOL(SCHAR_MIN, None, <limits.h>)
+SYMBOL(SEEK_CUR, None, <cstdio>)
+SYMBOL(SEEK_CUR, None, <stdio.h>)
+SYMBOL(SEEK_END, None, <cstdio>)
+SYMBOL(SEEK_END, None, <stdio.h>)
+SYMBOL(SEEK_SET, None, <cstdio>)
+SYMBOL(SEEK_SET, None, <stdio.h>)
+SYMBOL(SHRT_MAX, None, <climits>)
+SYMBOL(SHRT_MAX, None, <limits.h>)
+SYMBOL(SHRT_MIN, None, <climits>)
+SYMBOL(SHRT_MIN, None, <limits.h>)
+SYMBOL(SIGABRT, None, <csignal>)
+SYMBOL(SIGABRT, None, <signal.h>)
+SYMBOL(SIGFPE, None, <csignal>)
+SYMBOL(SIGFPE, None, <signal.h>)
+SYMBOL(SIGILL, None, <csignal>)
+SYMBOL(SIGILL, None, <signal.h>)
+SYMBOL(SIGINT, None, <csignal>)
+SYMBOL(SIGINT, None, <signal.h>)
+SYMBOL(SIGSEGV, None, <csignal>)
+SYMBOL(SIGSEGV, None, <signal.h>)
+SYMBOL(SIGTERM, None, <csignal>)
+SYMBOL(SIGTERM, None, <signal.h>)
+SYMBOL(SIG_ATOMIC_MAX, None, <cstdint>)
+SYMBOL(SIG_ATOMIC_MAX, None, <stdint.h>)
+SYMBOL(SIG_ATOMIC_MIN, None, <cstdint>)
+SYMBOL(SIG_ATOMIC_MIN, None, <stdint.h>)
+SYMBOL(SIG_DFL, None, <csignal>)
+SYMBOL(SIG_DFL, None, <signal.h>)
+SYMBOL(SIG_ERR, None, <csignal>)
+SYMBOL(SIG_ERR, None, <signal.h>)
+SYMBOL(SIG_IGN, None, <csignal>)
+SYMBOL(SIG_IGN, None, <signal.h>)
+SYMBOL(SIZE_MAX, None, <cstdint>)
+SYMBOL(SIZE_MAX, None, <stdint.h>)
+SYMBOL(TIME_UTC, None, <ctime>)
+SYMBOL(TIME_UTC, None, <time.h>)
+SYMBOL(TMP_MAX, None, <cstdio>)
+SYMBOL(TMP_MAX, None, <stdio.h>)
+SYMBOL(UCHAR_MAX, None, <climits>)
+SYMBOL(UCHAR_MAX, None, <limits.h>)
+SYMBOL(UINT16_MAX, None, <cstdint>)
+SYMBOL(UINT16_MAX, None, <stdint.h>)
+SYMBOL(UINT32_MAX, None, <cstdint>)
+SYMBOL(UINT32_MAX, None, <stdint.h>)
+SYMBOL(UINT64_MAX, None, <cstdint>)
+SYMBOL(UINT64_MAX, None, <stdint.h>)
+SYMBOL(UINT8_MAX, None, <cstdint>)
+SYMBOL(UINT8_MAX, None, <stdint.h>)
+SYMBOL(UINTMAX_MAX, None, <cstdint>)
+SYMBOL(UINTMAX_MAX, None, <stdint.h>)
+SYMBOL(UINTPTR_MAX, None, <cstdint>)
+SYMBOL(UINTPTR_MAX, None, <stdint.h>)
+SYMBOL(UINT_FAST16_MAX, None, <cstdint>)
+SYMBOL(UINT_FAST16_MAX, None, <stdint.h>)
+SYMBOL(UINT_FAST32_MAX, None, <cstdint>)
+SYMBOL(UINT_FAST32_MAX, None, <stdint.h>)
+SYMBOL(UINT_FAST64_MAX, None, <cstdint>)
+SYMBOL(UINT_FAST64_MAX, None, <stdint.h>)
+SYMBOL(UINT_FAST8_MAX, None, <cstdint>)
+SYMBOL(UINT_FAST8_MAX, None, <stdint.h>)
+SYMBOL(UINT_LEAST16_MAX, None, <cstdint>)
+SYMBOL(UINT_LEAST16_MAX, None, <stdint.h>)
+SYMBOL(UINT_LEAST32_MAX, None, <cstdint>)
+SYMBOL(UINT_LEAST32_MAX, None, <stdint.h>)
+SYMBOL(UINT_LEAST64_MAX, None, <cstdint>)
+SYMBOL(UINT_LEAST64_MAX, None, <stdint.h>)
+SYMBOL(UINT_LEAST8_MAX, None, <cstdint>)
+SYMBOL(UINT_LEAST8_MAX, None, <stdint.h>)
+SYMBOL(UINT_MAX, None, <climits>)
+SYMBOL(UINT_MAX, None, <limits.h>)
+SYMBOL(ULLONG_MAX, None, <climits>)
+SYMBOL(ULLONG_MAX, None, <limits.h>)
+SYMBOL(ULONG_MAX, None, <climits>)
+SYMBOL(ULONG_MAX, None, <limits.h>)
+SYMBOL(USHRT_MAX, None, <climits>)
+SYMBOL(USHRT_MAX, None, <limits.h>)
+SYMBOL(WEOF, None, <cwchar>)
+SYMBOL(WEOF, None, <wchar.h>)
+SYMBOL(WINT_MAX, None, <cstdint>)
+SYMBOL(WINT_MAX, None, <stdint.h>)
+SYMBOL(WINT_MIN, None, <cstdint>)
+SYMBOL(WINT_MIN, None, <stdint.h>)
+SYMBOL(_IOFBF, None, <cstdio>)
+SYMBOL(_IOFBF, None, <stdio.h>)
+SYMBOL(_IOLBF, None, <cstdio>)
+SYMBOL(_IOLBF, None, <stdio.h>)
+SYMBOL(_IONBF, None, <cstdio>)
+SYMBOL(_IONBF, None, <stdio.h>)
+SYMBOL(assert, None, <cassert>)
+SYMBOL(assert, None, <assert.h>)
+SYMBOL(errno, None, <cerrno>)
+SYMBOL(errno, None, <errno.h>)
+SYMBOL(math_errhandling, None, <cmath>)
+SYMBOL(math_errhandling, None, <math.h>)
+SYMBOL(offsetof, None, <cstddef>)
+SYMBOL(offsetof, None, <stddef.h>)
+SYMBOL(setjmp, None, <csetjmp>)
+SYMBOL(setjmp, None, <setjmp.h>)
+SYMBOL(stderr, None, <cstdio>)
+SYMBOL(stderr, None, <stdio.h>)
+SYMBOL(stdin, None, <cstdio>)
+SYMBOL(stdin, None, <stdio.h>)
+SYMBOL(stdout, None, <cstdio>)
+SYMBOL(stdout, None, <stdio.h>)
+SYMBOL(va_arg, None, <cstdarg>)
+SYMBOL(va_arg, None, <stdarg.h>)
+SYMBOL(va_copy, None, <cstdarg>)
+SYMBOL(va_copy, None, <stdarg.h>)
+SYMBOL(va_end, None, <cstdarg>)
+SYMBOL(va_end, None, <stdarg.h>)
+SYMBOL(va_start, None, <cstdarg>)
+SYMBOL(va_start, None, <stdarg.h>)
+SYMBOL(FILE, std::, <cstdio>)
+SYMBOL(FILE, None, <cstdio>)
+SYMBOL(FILE, None, <stdio.h>)
+SYMBOL(_Exit, std::, <cstdlib>)
+SYMBOL(_Exit, None, <cstdlib>)
+SYMBOL(_Exit, None, <stdlib.h>)
+SYMBOL(accumulate, std::, <numeric>)
+SYMBOL(acos, std::, <cmath>)
+SYMBOL(acos, None, <cmath>)
+SYMBOL(acos, None, <math.h>)
+SYMBOL(acosf, std::, <cmath>)
+SYMBOL(acosf, None, <cmath>)
+SYMBOL(acosf, None, <math.h>)
+SYMBOL(acosh, std::, <cmath>)
+SYMBOL(acosh, None, <cmath>)
+SYMBOL(acosh, None, <math.h>)
+SYMBOL(acoshf, std::, <cmath>)
+SYMBOL(acoshf, None, <cmath>)
+SYMBOL(acoshf, None, <math.h>)
+SYMBOL(acoshl, std::, <cmath>)
+SYMBOL(acoshl, None, <cmath>)
+SYMBOL(acoshl, None, <math.h>)
+SYMBOL(acosl, std::, <cmath>)
+SYMBOL(acosl, None, <cmath>)
+SYMBOL(acosl, None, <math.h>)
+SYMBOL(add_const, std::, <type_traits>)
+SYMBOL(add_const_t, std::, <type_traits>)
+SYMBOL(add_cv, std::, <type_traits>)
+SYMBOL(add_cv_t, std::, <type_traits>)
+SYMBOL(add_lvalue_reference, std::, <type_traits>)
+SYMBOL(add_lvalue_reference_t, std::, <type_traits>)
+SYMBOL(add_pointer, std::, <type_traits>)
+SYMBOL(add_pointer_t, std::, <type_traits>)
+SYMBOL(add_rvalue_reference, std::, <type_traits>)
+SYMBOL(add_rvalue_reference_t, std::, <type_traits>)
+SYMBOL(add_volatile, std::, <type_traits>)
+SYMBOL(add_volatile_t, std::, <type_traits>)
+SYMBOL(addressof, std::, <memory>)
+SYMBOL(adjacent_difference, std::, <numeric>)
+SYMBOL(adjacent_find, std::, <algorithm>)
+SYMBOL(adopt_lock, std::, <mutex>)
+SYMBOL(adopt_lock_t, std::, <mutex>)
+SYMBOL(advance, std::, <iterator>)
+SYMBOL(align, std::, <memory>)
+SYMBOL(align_val_t, std::, <new>)
+SYMBOL(aligned_alloc, std::, <cstdlib>)
+SYMBOL(aligned_alloc, None, <cstdlib>)
+SYMBOL(aligned_alloc, None, <stdlib.h>)
+SYMBOL(aligned_storage, std::, <type_traits>)
+SYMBOL(aligned_storage_t, std::, <type_traits>)
+SYMBOL(aligned_union, std::, <type_traits>)
+SYMBOL(aligned_union_t, std::, <type_traits>)
+SYMBOL(alignment_of, std::, <type_traits>)
+SYMBOL(alignment_of_v, std::, <type_traits>)
+SYMBOL(all_of, std::, <algorithm>)
+SYMBOL(allocate_at_least, std::, <memory>)
+SYMBOL(allocate_shared, std::, <memory>)
+SYMBOL(allocate_shared_for_overwrite, std::, <memory>)
+SYMBOL(allocation_result, std::, <memory>)
+SYMBOL(allocator, std::, <memory>)
+SYMBOL(allocator_arg, std::, <memory>)
+SYMBOL(allocator_arg_t, std::, <memory>)
+SYMBOL(allocator_traits, std::, <memory>)
+SYMBOL(any, std::, <any>)
+SYMBOL(any_of, std::, <algorithm>)
+SYMBOL(apply, std::, <tuple>)
+SYMBOL(arg, std::, <complex>)
+SYMBOL(array, std::, <array>)
+SYMBOL(as_bytes, std::, <span>)
+SYMBOL(as_const, std::, <utility>)
+SYMBOL(as_writable_bytes, std::, <span>)
+SYMBOL(asctime, std::, <ctime>)
+SYMBOL(asctime, None, <ctime>)
+SYMBOL(asctime, None, <time.h>)
+SYMBOL(asin, std::, <cmath>)
+SYMBOL(asin, None, <cmath>)
+SYMBOL(asin, None, <math.h>)
+SYMBOL(asinf, std::, <cmath>)
+SYMBOL(asinf, None, <cmath>)
+SYMBOL(asinf, None, <math.h>)
+SYMBOL(asinh, std::, <cmath>)
+SYMBOL(asinh, None, <cmath>)
+SYMBOL(asinh, None, <math.h>)
+SYMBOL(asinhf, std::, <cmath>)
+SYMBOL(asinhf, None, <cmath>)
+SYMBOL(asinhf, None, <math.h>)
+SYMBOL(asinhl, std::, <cmath>)
+SYMBOL(asinhl, None, <cmath>)
+SYMBOL(asinhl, None, <math.h>)
+SYMBOL(asinl, std::, <cmath>)
+SYMBOL(asinl, None, <cmath>)
+SYMBOL(asinl, None, <math.h>)
+SYMBOL(assignable_from, std::, <concepts>)
+SYMBOL(assoc_laguerre, std::, <cmath>)
+SYMBOL(assoc_laguerref, std::, <cmath>)
+SYMBOL(assoc_laguerrel, std::, <cmath>)
+SYMBOL(assoc_legendre, std::, <cmath>)
+SYMBOL(assoc_legendref, std::, <cmath>)
+SYMBOL(assoc_legendrel, std::, <cmath>)
+SYMBOL(assume_aligned, std::, <memory>)
+SYMBOL(async, std::, <future>)
+SYMBOL(at_quick_exit, std::, <cstdlib>)
+SYMBOL(at_quick_exit, None, <cstdlib>)
+SYMBOL(at_quick_exit, None, <stdlib.h>)
+SYMBOL(atan, std::, <cmath>)
+SYMBOL(atan, None, <cmath>)
+SYMBOL(atan, None, <math.h>)
+SYMBOL(atan2, std::, <cmath>)
+SYMBOL(atan2, None, <cmath>)
+SYMBOL(atan2, None, <math.h>)
+SYMBOL(atan2f, std::, <cmath>)
+SYMBOL(atan2f, None, <cmath>)
+SYMBOL(atan2f, None, <math.h>)
+SYMBOL(atan2l, std::, <cmath>)
+SYMBOL(atan2l, None, <cmath>)
+SYMBOL(atan2l, None, <math.h>)
+SYMBOL(atanf, std::, <cmath>)
+SYMBOL(atanf, None, <cmath>)
+SYMBOL(atanf, None, <math.h>)
+SYMBOL(atanh, std::, <cmath>)
+SYMBOL(atanh, None, <cmath>)
+SYMBOL(atanh, None, <math.h>)
+SYMBOL(atanhf, std::, <cmath>)
+SYMBOL(atanhf, None, <cmath>)
+SYMBOL(atanhf, None, <math.h>)
+SYMBOL(atanhl, std::, <cmath>)
+SYMBOL(atanhl, None, <cmath>)
+SYMBOL(atanhl, None, <math.h>)
+SYMBOL(atanl, std::, <cmath>)
+SYMBOL(atanl, None, <cmath>)
+SYMBOL(atanl, None, <math.h>)
+SYMBOL(atexit, std::, <cstdlib>)
+SYMBOL(atexit, None, <cstdlib>)
+SYMBOL(atexit, None, <stdlib.h>)
+SYMBOL(atof, std::, <cstdlib>)
+SYMBOL(atof, None, <cstdlib>)
+SYMBOL(atof, None, <stdlib.h>)
+SYMBOL(atoi, std::, <cstdlib>)
+SYMBOL(atoi, None, <cstdlib>)
+SYMBOL(atoi, None, <stdlib.h>)
+SYMBOL(atol, std::, <cstdlib>)
+SYMBOL(atol, None, <cstdlib>)
+SYMBOL(atol, None, <stdlib.h>)
+SYMBOL(atoll, std::, <cstdlib>)
+SYMBOL(atoll, None, <cstdlib>)
+SYMBOL(atoll, None, <stdlib.h>)
+SYMBOL(atomic_compare_exchange_strong, std::, <atomic>)
+SYMBOL(atomic_compare_exchange_strong_explicit, std::, <atomic>)
+SYMBOL(atomic_compare_exchange_weak, std::, <atomic>)
+SYMBOL(atomic_compare_exchange_weak_explicit, std::, <atomic>)
+SYMBOL(atomic_exchange, std::, <atomic>)
+SYMBOL(atomic_exchange_explicit, std::, <atomic>)
+SYMBOL(atomic_fetch_add, std::, <atomic>)
+SYMBOL(atomic_fetch_add_explicit, std::, <atomic>)
+SYMBOL(atomic_fetch_and, std::, <atomic>)
+SYMBOL(atomic_fetch_and_explicit, std::, <atomic>)
+SYMBOL(atomic_fetch_or, std::, <atomic>)
+SYMBOL(atomic_fetch_or_explicit, std::, <atomic>)
+SYMBOL(atomic_fetch_sub, std::, <atomic>)
+SYMBOL(atomic_fetch_sub_explicit, std::, <atomic>)
+SYMBOL(atomic_fetch_xor, std::, <atomic>)
+SYMBOL(atomic_fetch_xor_explicit, std::, <atomic>)
+SYMBOL(atomic_flag, std::, <atomic>)
+SYMBOL(atomic_flag_clear, std::, <atomic>)
+SYMBOL(atomic_flag_clear_explicit, std::, <atomic>)
+SYMBOL(atomic_flag_notify_all, std::, <atomic>)
+SYMBOL(atomic_flag_notify_one, std::, <atomic>)
+SYMBOL(atomic_flag_test, std::, <atomic>)
+SYMBOL(atomic_flag_test_and_set, std::, <atomic>)
+SYMBOL(atomic_flag_test_and_set_explicit, std::, <atomic>)
+SYMBOL(atomic_flag_test_explicit, std::, <atomic>)
+SYMBOL(atomic_flag_wait, std::, <atomic>)
+SYMBOL(atomic_flag_wait_explicit, std::, <atomic>)
+SYMBOL(atomic_init, std::, <atomic>)
+SYMBOL(atomic_is_lock_free, std::, <atomic>)
+SYMBOL(atomic_load, std::, <atomic>)
+SYMBOL(atomic_load_explicit, std::, <atomic>)
+SYMBOL(atomic_notify_all, std::, <atomic>)
+SYMBOL(atomic_notify_one, std::, <atomic>)
+SYMBOL(atomic_ref, std::, <atomic>)
+SYMBOL(atomic_signal_fence, std::, <atomic>)
+SYMBOL(atomic_store, std::, <atomic>)
+SYMBOL(atomic_store_explicit, std::, <atomic>)
+SYMBOL(atomic_thread_fence, std::, <atomic>)
+SYMBOL(atomic_wait, std::, <atomic>)
+SYMBOL(atomic_wait_explicit, std::, <atomic>)
+SYMBOL(atto, std::, <ratio>)
+SYMBOL(auto_ptr, std::, <memory>)
+SYMBOL(back_insert_iterator, std::, <iterator>)
+SYMBOL(back_inserter, std::, <iterator>)
+SYMBOL(bad_alloc, std::, <new>)
+SYMBOL(bad_any_cast, std::, <any>)
+SYMBOL(bad_array_new_length, std::, <new>)
+SYMBOL(bad_cast, std::, <typeinfo>)
+SYMBOL(bad_exception, std::, <exception>)
+SYMBOL(bad_function_call, std::, <functional>)
+SYMBOL(bad_optional_access, std::, <optional>)
+SYMBOL(bad_typeid, std::, <typeinfo>)
+SYMBOL(bad_variant_access, std::, <variant>)
+SYMBOL(bad_weak_ptr, std::, <memory>)
+SYMBOL(barrier, std::, <barrier>)
+SYMBOL(basic_common_reference, std::, <type_traits>)
+SYMBOL(basic_filebuf, std::, <fstream>)
+SYMBOL(basic_filebuf, std::, <iosfwd>)
+SYMBOL(basic_format_arg, std::, <format>)
+SYMBOL(basic_format_args, std::, <format>)
+SYMBOL(basic_format_context, std::, <format>)
+SYMBOL(basic_format_parse_context, std::, <format>)
+SYMBOL(basic_fstream, std::, <fstream>)
+SYMBOL(basic_fstream, std::, <iosfwd>)
+SYMBOL(basic_ifstream, std::, <fstream>)
+SYMBOL(basic_ifstream, std::, <iosfwd>)
+SYMBOL(basic_ios, std::, <ios>)
+SYMBOL(basic_ios, std::, <iostream>)
+SYMBOL(basic_ios, std::, <iosfwd>)
+SYMBOL(basic_iostream, std::, <istream>)
+SYMBOL(basic_iostream, std::, <iostream>)
+SYMBOL(basic_iostream, std::, <iosfwd>)
+SYMBOL(basic_ispanstream, std::, <spanstream>)
+SYMBOL(basic_ispanstream, std::, <iosfwd>)
+SYMBOL(basic_istream, std::, <istream>)
+SYMBOL(basic_istream, std::, <iostream>)
+SYMBOL(basic_istream, std::, <iosfwd>)
+SYMBOL(basic_istringstream, std::, <sstream>)
+SYMBOL(basic_istringstream, std::, <iosfwd>)
+SYMBOL(basic_ofstream, std::, <fstream>)
+SYMBOL(basic_ofstream, std::, <iosfwd>)
+SYMBOL(basic_ospanstream, std::, <spanstream>)
+SYMBOL(basic_ospanstream, std::, <iosfwd>)
+SYMBOL(basic_ostream, std::, <ostream>)
+SYMBOL(basic_ostream, std::, <iostream>)
+SYMBOL(basic_ostream, std::, <iosfwd>)
+SYMBOL(basic_ostringstream, std::, <sstream>)
+SYMBOL(basic_ostringstream, std::, <iosfwd>)
+SYMBOL(basic_osyncstream, std::, <syncstream>)
+SYMBOL(basic_osyncstream, std::, <iosfwd>)
+SYMBOL(basic_regex, std::, <regex>)
+SYMBOL(basic_spanbuf, std::, <spanstream>)
+SYMBOL(basic_spanbuf, std::, <iosfwd>)
+SYMBOL(basic_spanstream, std::, <spanstream>)
+SYMBOL(basic_spanstream, std::, <iosfwd>)
+SYMBOL(basic_stacktrace, std::, <stacktrace>)
+SYMBOL(basic_streambuf, std::, <streambuf>)
+SYMBOL(basic_streambuf, std::, <iostream>)
+SYMBOL(basic_streambuf, std::, <iosfwd>)
+SYMBOL(basic_string, std::, <string>)
+SYMBOL(basic_string_view, std::, <string_view>)
+SYMBOL(basic_stringbuf, std::, <sstream>)
+SYMBOL(basic_stringbuf, std::, <iosfwd>)
+SYMBOL(basic_stringstream, std::, <sstream>)
+SYMBOL(basic_stringstream, std::, <iosfwd>)
+SYMBOL(basic_syncbuf, std::, <syncstream>)
+SYMBOL(basic_syncbuf, std::, <iosfwd>)
+SYMBOL(bernoulli_distribution, std::, <random>)
+SYMBOL(beta, std::, <cmath>)
+SYMBOL(betaf, std::, <cmath>)
+SYMBOL(betal, std::, <cmath>)
+SYMBOL(bidirectional_iterator, std::, <iterator>)
+SYMBOL(bidirectional_iterator_tag, std::, <iterator>)
+SYMBOL(binary_function, std::, <functional>)
+SYMBOL(binary_negate, std::, <functional>)
+SYMBOL(binary_search, std::, <algorithm>)
+SYMBOL(binary_semaphore, std::, <semaphore>)
+SYMBOL(bind, std::, <functional>)
+SYMBOL(bind1st, std::, <functional>)
+SYMBOL(bind2nd, std::, <functional>)
+SYMBOL(bind_back, std::, <functional>)
+SYMBOL(bind_front, std::, <functional>)
+SYMBOL(binder1st, std::, <functional>)
+SYMBOL(binder2nd, std::, <functional>)
+SYMBOL(binomial_distribution, std::, <random>)
+SYMBOL(bit_and, std::, <functional>)
+SYMBOL(bit_cast, std::, <bit>)
+SYMBOL(bit_ceil, std::, <bit>)
+SYMBOL(bit_floor, std::, <bit>)
+SYMBOL(bit_not, std::, <functional>)
+SYMBOL(bit_or, std::, <functional>)
+SYMBOL(bit_width, std::, <bit>)
+SYMBOL(bit_xor, std::, <functional>)
+SYMBOL(bitset, std::, <bitset>)
+SYMBOL(bool_constant, std::, <type_traits>)
+SYMBOL(boolalpha, std::, <ios>)
+SYMBOL(boolalpha, std::, <iostream>)
+SYMBOL(boyer_moore_horspool_searcher, std::, <functional>)
+SYMBOL(boyer_moore_searcher, std::, <functional>)
+SYMBOL(bsearch, std::, <cstdlib>)
+SYMBOL(bsearch, None, <cstdlib>)
+SYMBOL(bsearch, None, <stdlib.h>)
+SYMBOL(btowc, std::, <cwchar>)
+SYMBOL(btowc, None, <cwchar>)
+SYMBOL(btowc, None, <wchar.h>)
+SYMBOL(byte, std::, <cstddef>)
+SYMBOL(byteswap, std::, <bit>)
+SYMBOL(c16rtomb, std::, <cuchar>)
+SYMBOL(c16rtomb, None, <cuchar>)
+SYMBOL(c16rtomb, None, <uchar.h>)
+SYMBOL(c32rtomb, std::, <cuchar>)
+SYMBOL(c32rtomb, None, <cuchar>)
+SYMBOL(c32rtomb, None, <uchar.h>)
+SYMBOL(c8rtomb, std::, <cuchar>)
+SYMBOL(c8rtomb, None, <cuchar>)
+SYMBOL(c8rtomb, None, <uchar.h>)
+SYMBOL(call_once, std::, <mutex>)
+SYMBOL(calloc, std::, <cstdlib>)
+SYMBOL(calloc, None, <cstdlib>)
+SYMBOL(calloc, None, <stdlib.h>)
+SYMBOL(cauchy_distribution, std::, <random>)
+SYMBOL(cbrt, std::, <cmath>)
+SYMBOL(cbrt, None, <cmath>)
+SYMBOL(cbrt, None, <math.h>)
+SYMBOL(cbrtf, std::, <cmath>)
+SYMBOL(cbrtf, None, <cmath>)
+SYMBOL(cbrtf, None, <math.h>)
+SYMBOL(cbrtl, std::, <cmath>)
+SYMBOL(cbrtl, None, <cmath>)
+SYMBOL(cbrtl, None, <math.h>)
+SYMBOL(ceil, std::, <cmath>)
+SYMBOL(ceil, None, <cmath>)
+SYMBOL(ceil, None, <math.h>)
+SYMBOL(ceilf, std::, <cmath>)
+SYMBOL(ceilf, None, <cmath>)
+SYMBOL(ceilf, None, <math.h>)
+SYMBOL(ceill, std::, <cmath>)
+SYMBOL(ceill, None, <cmath>)
+SYMBOL(ceill, None, <math.h>)
+SYMBOL(centi, std::, <ratio>)
+SYMBOL(cerr, std::, <iostream>)
+SYMBOL(char_traits, std::, <string>)
+SYMBOL(chars_format, std::, <charconv>)
+SYMBOL(chi_squared_distribution, std::, <random>)
+SYMBOL(cin, std::, <iostream>)
+SYMBOL(clamp, std::, <algorithm>)
+SYMBOL(clearerr, std::, <cstdio>)
+SYMBOL(clearerr, None, <cstdio>)
+SYMBOL(clearerr, None, <stdio.h>)
+SYMBOL(clock, std::, <ctime>)
+SYMBOL(clock, None, <ctime>)
+SYMBOL(clock, None, <time.h>)
+SYMBOL(clock_t, std::, <ctime>)
+SYMBOL(clock_t, None, <ctime>)
+SYMBOL(clock_t, None, <time.h>)
+SYMBOL(clog, std::, <iostream>)
+SYMBOL(cmatch, std::, <regex>)
+SYMBOL(cmp_equal, std::, <utility>)
+SYMBOL(cmp_greater, std::, <utility>)
+SYMBOL(cmp_greater_equal, std::, <utility>)
+SYMBOL(cmp_less, std::, <utility>)
+SYMBOL(cmp_less_equal, std::, <utility>)
+SYMBOL(cmp_not_equal, std::, <utility>)
+SYMBOL(codecvt, std::, <locale>)
+SYMBOL(codecvt_base, std::, <locale>)
+SYMBOL(codecvt_byname, std::, <locale>)
+SYMBOL(codecvt_mode, std::, <codecvt>)
+SYMBOL(codecvt_utf16, std::, <codecvt>)
+SYMBOL(codecvt_utf8, std::, <codecvt>)
+SYMBOL(codecvt_utf8_utf16, std::, <codecvt>)
+SYMBOL(collate, std::, <locale>)
+SYMBOL(collate_byname, std::, <locale>)
+SYMBOL(common_comparison_category, std::, <compare>)
+SYMBOL(common_comparison_category_t, std::, <compare>)
+SYMBOL(common_iterator, std::, <iterator>)
+SYMBOL(common_reference, std::, <type_traits>)
+SYMBOL(common_reference_t, std::, <type_traits>)
+SYMBOL(common_reference_with, std::, <concepts>)
+SYMBOL(common_type, std::, <type_traits>)
+SYMBOL(common_type_t, std::, <type_traits>)
+SYMBOL(common_with, std::, <concepts>)
+SYMBOL(comp_ellint_1, std::, <cmath>)
+SYMBOL(comp_ellint_1f, std::, <cmath>)
+SYMBOL(comp_ellint_1l, std::, <cmath>)
+SYMBOL(comp_ellint_2, std::, <cmath>)
+SYMBOL(comp_ellint_2f, std::, <cmath>)
+SYMBOL(comp_ellint_2l, std::, <cmath>)
+SYMBOL(comp_ellint_3, std::, <cmath>)
+SYMBOL(comp_ellint_3f, std::, <cmath>)
+SYMBOL(comp_ellint_3l, std::, <cmath>)
+SYMBOL(compare_partial_order_fallback, std::, <compare>)
+SYMBOL(compare_strong_order_fallback, std::, <compare>)
+SYMBOL(compare_three_way_result, std::, <compare>)
+SYMBOL(compare_three_way_result_t, std::, <compare>)
+SYMBOL(compare_weak_order_fallback, std::, <compare>)
+SYMBOL(complex, std::, <complex>)
+SYMBOL(condition_variable, std::, <condition_variable>)
+SYMBOL(condition_variable_any, std::, <condition_variable>)
+SYMBOL(conditional, std::, <type_traits>)
+SYMBOL(conditional_t, std::, <type_traits>)
+SYMBOL(conj, std::, <complex>)
+SYMBOL(conjunction, std::, <type_traits>)
+SYMBOL(conjunction_v, std::, <type_traits>)
+SYMBOL(const_mem_fun1_ref_t, std::, <functional>)
+SYMBOL(const_mem_fun1_t, std::, <functional>)
+SYMBOL(const_mem_fun_ref_t, std::, <functional>)
+SYMBOL(const_mem_fun_t, std::, <functional>)
+SYMBOL(const_pointer_cast, std::, <memory>)
+SYMBOL(construct_at, std::, <memory>)
+SYMBOL(constructible_from, std::, <concepts>)
+SYMBOL(contiguous_iterator, std::, <iterator>)
+SYMBOL(contiguous_iterator_tag, std::, <iterator>)
+SYMBOL(convertible_to, std::, <concepts>)
+SYMBOL(copy, std::, <algorithm>)
+SYMBOL(copy_backward, std::, <algorithm>)
+SYMBOL(copy_constructible, std::, <concepts>)
+SYMBOL(copy_if, std::, <algorithm>)
+SYMBOL(copy_n, std::, <algorithm>)
+SYMBOL(copyable, std::, <concepts>)
+SYMBOL(copysign, std::, <cmath>)
+SYMBOL(copysign, None, <cmath>)
+SYMBOL(copysign, None, <math.h>)
+SYMBOL(copysignf, std::, <cmath>)
+SYMBOL(copysignf, None, <cmath>)
+SYMBOL(copysignf, None, <math.h>)
+SYMBOL(copysignl, std::, <cmath>)
+SYMBOL(copysignl, None, <cmath>)
+SYMBOL(copysignl, None, <math.h>)
+SYMBOL(coroutine_handle, std::, <coroutine>)
+SYMBOL(coroutine_traits, std::, <coroutine>)
+SYMBOL(cos, std::, <cmath>)
+SYMBOL(cos, None, <cmath>)
+SYMBOL(cos, None, <math.h>)
+SYMBOL(cosf, std::, <cmath>)
+SYMBOL(cosf, None, <cmath>)
+SYMBOL(cosf, None, <math.h>)
+SYMBOL(cosh, std::, <cmath>)
+SYMBOL(cosh, None, <cmath>)
+SYMBOL(cosh, None, <math.h>)
+SYMBOL(coshf, std::, <cmath>)
+SYMBOL(coshf, None, <cmath>)
+SYMBOL(coshf, None, <math.h>)
+SYMBOL(coshl, std::, <cmath>)
+SYMBOL(coshl, None, <cmath>)
+SYMBOL(coshl, None, <math.h>)
+SYMBOL(cosl, std::, <cmath>)
+SYMBOL(cosl, None, <cmath>)
+SYMBOL(cosl, None, <math.h>)
+SYMBOL(count, std::, <algorithm>)
+SYMBOL(count_if, std::, <algorithm>)
+SYMBOL(counted_iterator, std::, <iterator>)
+SYMBOL(counting_semaphore, std::, <semaphore>)
+SYMBOL(countl_one, std::, <bit>)
+SYMBOL(countl_zero, std::, <bit>)
+SYMBOL(countr_one, std::, <bit>)
+SYMBOL(countr_zero, std::, <bit>)
+SYMBOL(cout, std::, <iostream>)
+SYMBOL(cref, std::, <functional>)
+SYMBOL(cregex_iterator, std::, <regex>)
+SYMBOL(cregex_token_iterator, std::, <regex>)
+SYMBOL(csub_match, std::, <regex>)
+SYMBOL(ctime, std::, <ctime>)
+SYMBOL(ctime, None, <ctime>)
+SYMBOL(ctime, None, <time.h>)
+SYMBOL(ctype, std::, <locale>)
+SYMBOL(ctype_base, std::, <locale>)
+SYMBOL(ctype_byname, std::, <locale>)
+SYMBOL(current_exception, std::, <exception>)
+SYMBOL(cv_status, std::, <condition_variable>)
+SYMBOL(cyl_bessel_i, std::, <cmath>)
+SYMBOL(cyl_bessel_if, std::, <cmath>)
+SYMBOL(cyl_bessel_il, std::, <cmath>)
+SYMBOL(cyl_bessel_j, std::, <cmath>)
+SYMBOL(cyl_bessel_jf, std::, <cmath>)
+SYMBOL(cyl_bessel_jl, std::, <cmath>)
+SYMBOL(cyl_bessel_k, std::, <cmath>)
+SYMBOL(cyl_bessel_kf, std::, <cmath>)
+SYMBOL(cyl_bessel_kl, std::, <cmath>)
+SYMBOL(cyl_neumann, std::, <cmath>)
+SYMBOL(cyl_neumannf, std::, <cmath>)
+SYMBOL(cyl_neumannl, std::, <cmath>)
+SYMBOL(dec, std::, <ios>)
+SYMBOL(dec, std::, <iostream>)
+SYMBOL(deca, std::, <ratio>)
+SYMBOL(decay, std::, <type_traits>)
+SYMBOL(decay_t, std::, <type_traits>)
+SYMBOL(deci, std::, <ratio>)
+SYMBOL(declare_no_pointers, std::, <memory>)
+SYMBOL(declare_reachable, std::, <memory>)
+SYMBOL(declval, std::, <utility>)
+SYMBOL(default_delete, std::, <memory>)
+SYMBOL(default_initializable, std::, <concepts>)
+SYMBOL(default_random_engine, std::, <random>)
+SYMBOL(default_searcher, std::, <functional>)
+SYMBOL(default_sentinel, std::, <iterator>)
+SYMBOL(default_sentinel_t, std::, <iterator>)
+SYMBOL(defaultfloat, std::, <ios>)
+SYMBOL(defaultfloat, std::, <iostream>)
+SYMBOL(defer_lock, std::, <mutex>)
+SYMBOL(defer_lock_t, std::, <mutex>)
+SYMBOL(denorm_absent, std::, <limits>)
+SYMBOL(denorm_indeterminate, std::, <limits>)
+SYMBOL(denorm_present, std::, <limits>)
+SYMBOL(deque, std::, <deque>)
+SYMBOL(derived_from, std::, <concepts>)
+SYMBOL(destroy, std::, <memory>)
+SYMBOL(destroy_at, std::, <memory>)
+SYMBOL(destroy_n, std::, <memory>)
+SYMBOL(destroying_delete, std::, <new>)
+SYMBOL(destroying_delete_t, std::, <new>)
+SYMBOL(destructible, std::, <concepts>)
+SYMBOL(difftime, std::, <ctime>)
+SYMBOL(difftime, None, <ctime>)
+SYMBOL(difftime, None, <time.h>)
+SYMBOL(disable_sized_sentinel_for, std::, <iterator>)
+SYMBOL(discard_block_engine, std::, <random>)
+SYMBOL(discrete_distribution, std::, <random>)
+SYMBOL(disjunction, std::, <type_traits>)
+SYMBOL(disjunction_v, std::, <type_traits>)
+SYMBOL(distance, std::, <iterator>)
+SYMBOL(div_t, std::, <cstdlib>)
+SYMBOL(div_t, None, <cstdlib>)
+SYMBOL(div_t, None, <stdlib.h>)
+SYMBOL(divides, std::, <functional>)
+SYMBOL(domain_error, std::, <stdexcept>)
+SYMBOL(double_t, std::, <cmath>)
+SYMBOL(double_t, None, <cmath>)
+SYMBOL(double_t, None, <math.h>)
+SYMBOL(dynamic_extent, std::, <span>)
+SYMBOL(dynamic_pointer_cast, std::, <memory>)
+SYMBOL(ellint_1, std::, <cmath>)
+SYMBOL(ellint_1f, std::, <cmath>)
+SYMBOL(ellint_1l, std::, <cmath>)
+SYMBOL(ellint_2, std::, <cmath>)
+SYMBOL(ellint_2f, std::, <cmath>)
+SYMBOL(ellint_2l, std::, <cmath>)
+SYMBOL(ellint_3, std::, <cmath>)
+SYMBOL(ellint_3f, std::, <cmath>)
+SYMBOL(ellint_3l, std::, <cmath>)
+SYMBOL(emit_on_flush, std::, <ostream>)
+SYMBOL(emit_on_flush, std::, <iostream>)
+SYMBOL(enable_if, std::, <type_traits>)
+SYMBOL(enable_if_t, std::, <type_traits>)
+SYMBOL(enable_shared_from_this, std::, <memory>)
+SYMBOL(endian, std::, <bit>)
+SYMBOL(endl, std::, <ostream>)
+SYMBOL(endl, std::, <iostream>)
+SYMBOL(ends, std::, <ostream>)
+SYMBOL(ends, std::, <iostream>)
+SYMBOL(equal, std::, <algorithm>)
+SYMBOL(equal_range, std::, <algorithm>)
+SYMBOL(equal_to, std::, <functional>)
+SYMBOL(equality_comparable, std::, <concepts>)
+SYMBOL(equality_comparable_with, std::, <concepts>)
+SYMBOL(equivalence_relation, std::, <concepts>)
+SYMBOL(erase, std::, <vector>)
+SYMBOL(erase_if, std::, <vector>)
+SYMBOL(erf, std::, <cmath>)
+SYMBOL(erf, None, <cmath>)
+SYMBOL(erf, None, <math.h>)
+SYMBOL(erfc, std::, <cmath>)
+SYMBOL(erfc, None, <cmath>)
+SYMBOL(erfc, None, <math.h>)
+SYMBOL(erfcf, std::, <cmath>)
+SYMBOL(erfcf, None, <cmath>)
+SYMBOL(erfcf, None, <math.h>)
+SYMBOL(erfcl, std::, <cmath>)
+SYMBOL(erfcl, None, <cmath>)
+SYMBOL(erfcl, None, <math.h>)
+SYMBOL(erff, std::, <cmath>)
+SYMBOL(erff, None, <cmath>)
+SYMBOL(erff, None, <math.h>)
+SYMBOL(erfl, std::, <cmath>)
+SYMBOL(erfl, None, <cmath>)
+SYMBOL(erfl, None, <math.h>)
+SYMBOL(errc, std::, <system_error>)
+SYMBOL(error_category, std::, <system_error>)
+SYMBOL(error_code, std::, <system_error>)
+SYMBOL(error_condition, std::, <system_error>)
+SYMBOL(exa, std::, <ratio>)
+SYMBOL(exception, std::, <exception>)
+SYMBOL(exception_ptr, std::, <exception>)
+SYMBOL(exchange, std::, <utility>)
+SYMBOL(exclusive_scan, std::, <numeric>)
+SYMBOL(exit, std::, <cstdlib>)
+SYMBOL(exit, None, <cstdlib>)
+SYMBOL(exit, None, <stdlib.h>)
+SYMBOL(exp, std::, <cmath>)
+SYMBOL(exp, None, <cmath>)
+SYMBOL(exp, None, <math.h>)
+SYMBOL(exp2, std::, <cmath>)
+SYMBOL(exp2, None, <cmath>)
+SYMBOL(exp2, None, <math.h>)
+SYMBOL(exp2f, std::, <cmath>)
+SYMBOL(exp2f, None, <cmath>)
+SYMBOL(exp2f, None, <math.h>)
+SYMBOL(exp2l, std::, <cmath>)
+SYMBOL(exp2l, None, <cmath>)
+SYMBOL(exp2l, None, <math.h>)
+SYMBOL(expf, std::, <cmath>)
+SYMBOL(expf, None, <cmath>)
+SYMBOL(expf, None, <math.h>)
+SYMBOL(expint, std::, <cmath>)
+SYMBOL(expintf, std::, <cmath>)
+SYMBOL(expintl, std::, <cmath>)
+SYMBOL(expl, std::, <cmath>)
+SYMBOL(expl, None, <cmath>)
+SYMBOL(expl, None, <math.h>)
+SYMBOL(expm1, std::, <cmath>)
+SYMBOL(expm1, None, <cmath>)
+SYMBOL(expm1, None, <math.h>)
+SYMBOL(expm1f, std::, <cmath>)
+SYMBOL(expm1f, None, <cmath>)
+SYMBOL(expm1f, None, <math.h>)
+SYMBOL(expm1l, std::, <cmath>)
+SYMBOL(expm1l, None, <cmath>)
+SYMBOL(expm1l, None, <math.h>)
+SYMBOL(exponential_distribution, std::, <random>)
+SYMBOL(extent, std::, <type_traits>)
+SYMBOL(extent_v, std::, <type_traits>)
+SYMBOL(extreme_value_distribution, std::, <random>)
+SYMBOL(fabs, std::, <cmath>)
+SYMBOL(fabs, None, <cmath>)
+SYMBOL(fabs, None, <math.h>)
+SYMBOL(fabsf, std::, <cmath>)
+SYMBOL(fabsf, None, <cmath>)
+SYMBOL(fabsf, None, <math.h>)
+SYMBOL(fabsl, std::, <cmath>)
+SYMBOL(fabsl, None, <cmath>)
+SYMBOL(fabsl, None, <math.h>)
+SYMBOL(false_type, std::, <type_traits>)
+SYMBOL(fclose, std::, <cstdio>)
+SYMBOL(fclose, None, <cstdio>)
+SYMBOL(fclose, None, <stdio.h>)
+SYMBOL(fdim, std::, <cmath>)
+SYMBOL(fdim, None, <cmath>)
+SYMBOL(fdim, None, <math.h>)
+SYMBOL(fdimf, std::, <cmath>)
+SYMBOL(fdimf, None, <cmath>)
+SYMBOL(fdimf, None, <math.h>)
+SYMBOL(fdiml, std::, <cmath>)
+SYMBOL(fdiml, None, <cmath>)
+SYMBOL(fdiml, None, <math.h>)
+SYMBOL(feclearexcept, std::, <cfenv>)
+SYMBOL(feclearexcept, None, <cfenv>)
+SYMBOL(feclearexcept, None, <fenv.h>)
+SYMBOL(fegetenv, std::, <cfenv>)
+SYMBOL(fegetenv, None, <cfenv>)
+SYMBOL(fegetenv, None, <fenv.h>)
+SYMBOL(fegetexceptflag, std::, <cfenv>)
+SYMBOL(fegetexceptflag, None, <cfenv>)
+SYMBOL(fegetexceptflag, None, <fenv.h>)
+SYMBOL(fegetround, std::, <cfenv>)
+SYMBOL(fegetround, None, <cfenv>)
+SYMBOL(fegetround, None, <fenv.h>)
+SYMBOL(feholdexcept, std::, <cfenv>)
+SYMBOL(feholdexcept, None, <cfenv>)
+SYMBOL(feholdexcept, None, <fenv.h>)
+SYMBOL(femto, std::, <ratio>)
+SYMBOL(fenv_t, std::, <cfenv>)
+SYMBOL(fenv_t, None, <cfenv>)
+SYMBOL(fenv_t, None, <fenv.h>)
+SYMBOL(feof, std::, <cstdio>)
+SYMBOL(feof, None, <cstdio>)
+SYMBOL(feof, None, <stdio.h>)
+SYMBOL(feraiseexcept, std::, <cfenv>)
+SYMBOL(feraiseexcept, None, <cfenv>)
+SYMBOL(feraiseexcept, None, <fenv.h>)
+SYMBOL(ferror, std::, <cstdio>)
+SYMBOL(ferror, None, <cstdio>)
+SYMBOL(ferror, None, <stdio.h>)
+SYMBOL(fesetenv, std::, <cfenv>)
+SYMBOL(fesetenv, None, <cfenv>)
+SYMBOL(fesetenv, None, <fenv.h>)
+SYMBOL(fesetexceptflag, std::, <cfenv>)
+SYMBOL(fesetexceptflag, None, <cfenv>)
+SYMBOL(fesetexceptflag, None, <fenv.h>)
+SYMBOL(fesetround, std::, <cfenv>)
+SYMBOL(fesetround, None, <cfenv>)
+SYMBOL(fesetround, None, <fenv.h>)
+SYMBOL(fetestexcept, std::, <cfenv>)
+SYMBOL(fetestexcept, None, <cfenv>)
+SYMBOL(fetestexcept, None, <fenv.h>)
+SYMBOL(feupdateenv, std::, <cfenv>)
+SYMBOL(feupdateenv, None, <cfenv>)
+SYMBOL(feupdateenv, None, <fenv.h>)
+SYMBOL(fexcept_t, std::, <cfenv>)
+SYMBOL(fexcept_t, None, <cfenv>)
+SYMBOL(fexcept_t, None, <fenv.h>)
+SYMBOL(fflush, std::, <cstdio>)
+SYMBOL(fflush, None, <cstdio>)
+SYMBOL(fflush, None, <stdio.h>)
+SYMBOL(fgetc, std::, <cstdio>)
+SYMBOL(fgetc, None, <cstdio>)
+SYMBOL(fgetc, None, <stdio.h>)
+SYMBOL(fgetpos, std::, <cstdio>)
+SYMBOL(fgetpos, None, <cstdio>)
+SYMBOL(fgetpos, None, <stdio.h>)
+SYMBOL(fgets, std::, <cstdio>)
+SYMBOL(fgets, None, <cstdio>)
+SYMBOL(fgets, None, <stdio.h>)
+SYMBOL(fgetwc, std::, <cwchar>)
+SYMBOL(fgetwc, None, <cwchar>)
+SYMBOL(fgetwc, None, <wchar.h>)
+SYMBOL(fgetws, std::, <cwchar>)
+SYMBOL(fgetws, None, <cwchar>)
+SYMBOL(fgetws, None, <wchar.h>)
+SYMBOL(filebuf, std::, <streambuf>)
+SYMBOL(filebuf, std::, <iostream>)
+SYMBOL(filebuf, std::, <iosfwd>)
+SYMBOL(fill, std::, <algorithm>)
+SYMBOL(fill_n, std::, <algorithm>)
+SYMBOL(find, std::, <algorithm>)
+SYMBOL(find_end, std::, <algorithm>)
+SYMBOL(find_first_of, std::, <algorithm>)
+SYMBOL(find_if, std::, <algorithm>)
+SYMBOL(find_if_not, std::, <algorithm>)
+SYMBOL(fisher_f_distribution, std::, <random>)
+SYMBOL(fixed, std::, <ios>)
+SYMBOL(fixed, std::, <iostream>)
+SYMBOL(float_denorm_style, std::, <limits>)
+SYMBOL(float_round_style, std::, <limits>)
+SYMBOL(float_t, std::, <cmath>)
+SYMBOL(float_t, None, <cmath>)
+SYMBOL(float_t, None, <math.h>)
+SYMBOL(floating_point, std::, <concepts>)
+SYMBOL(floor, std::, <cmath>)
+SYMBOL(floor, None, <cmath>)
+SYMBOL(floor, None, <math.h>)
+SYMBOL(floorf, std::, <cmath>)
+SYMBOL(floorf, None, <cmath>)
+SYMBOL(floorf, None, <math.h>)
+SYMBOL(floorl, std::, <cmath>)
+SYMBOL(floorl, None, <cmath>)
+SYMBOL(floorl, None, <math.h>)
+SYMBOL(flush, std::, <ostream>)
+SYMBOL(flush, std::, <iostream>)
+SYMBOL(flush_emit, std::, <ostream>)
+SYMBOL(flush_emit, std::, <iostream>)
+SYMBOL(fma, std::, <cmath>)
+SYMBOL(fma, None, <cmath>)
+SYMBOL(fma, None, <math.h>)
+SYMBOL(fmaf, std::, <cmath>)
+SYMBOL(fmaf, None, <cmath>)
+SYMBOL(fmaf, None, <math.h>)
+SYMBOL(fmal, std::, <cmath>)
+SYMBOL(fmal, None, <cmath>)
+SYMBOL(fmal, None, <math.h>)
+SYMBOL(fmax, std::, <cmath>)
+SYMBOL(fmax, None, <cmath>)
+SYMBOL(fmax, None, <math.h>)
+SYMBOL(fmaxf, std::, <cmath>)
+SYMBOL(fmaxf, None, <cmath>)
+SYMBOL(fmaxf, None, <math.h>)
+SYMBOL(fmaxl, std::, <cmath>)
+SYMBOL(fmaxl, None, <cmath>)
+SYMBOL(fmaxl, None, <math.h>)
+SYMBOL(fmin, std::, <cmath>)
+SYMBOL(fmin, None, <cmath>)
+SYMBOL(fmin, None, <math.h>)
+SYMBOL(fminf, std::, <cmath>)
+SYMBOL(fminf, None, <cmath>)
+SYMBOL(fminf, None, <math.h>)
+SYMBOL(fminl, std::, <cmath>)
+SYMBOL(fminl, None, <cmath>)
+SYMBOL(fminl, None, <math.h>)
+SYMBOL(fmod, std::, <cmath>)
+SYMBOL(fmod, None, <cmath>)
+SYMBOL(fmod, None, <math.h>)
+SYMBOL(fmodf, std::, <cmath>)
+SYMBOL(fmodf, None, <cmath>)
+SYMBOL(fmodf, None, <math.h>)
+SYMBOL(fmodl, std::, <cmath>)
+SYMBOL(fmodl, None, <cmath>)
+SYMBOL(fmodl, None, <math.h>)
+SYMBOL(fopen, std::, <cstdio>)
+SYMBOL(fopen, None, <cstdio>)
+SYMBOL(fopen, None, <stdio.h>)
+SYMBOL(for_each, std::, <algorithm>)
+SYMBOL(for_each_n, std::, <algorithm>)
+SYMBOL(format, std::, <format>)
+SYMBOL(format_args, std::, <format>)
+SYMBOL(format_context, std::, <format>)
+SYMBOL(format_error, std::, <format>)
+SYMBOL(format_parse_context, std::, <format>)
+SYMBOL(format_to, std::, <format>)
+SYMBOL(format_to_n, std::, <format>)
+SYMBOL(format_to_n_result, std::, <format>)
+SYMBOL(formatted_size, std::, <format>)
+SYMBOL(formatter, std::, <format>)
+SYMBOL(forward, std::, <utility>)
+SYMBOL(forward_as_tuple, std::, <tuple>)
+SYMBOL(forward_iterator, std::, <iterator>)
+SYMBOL(forward_iterator_tag, std::, <iterator>)
+SYMBOL(forward_like, std::, <utility>)
+SYMBOL(forward_list, std::, <forward_list>)
+SYMBOL(fpclassify, std::, <cmath>)
+SYMBOL(fpclassify, None, <cmath>)
+SYMBOL(fpclassify, None, <math.h>)
+SYMBOL(fpos, std::, <ios>)
+SYMBOL(fpos, std::, <iostream>)
+SYMBOL(fpos, std::, <iosfwd>)
+SYMBOL(fpos_t, std::, <cstdio>)
+SYMBOL(fpos_t, None, <cstdio>)
+SYMBOL(fpos_t, None, <stdio.h>)
+SYMBOL(fprintf, std::, <cstdio>)
+SYMBOL(fprintf, None, <cstdio>)
+SYMBOL(fprintf, None, <stdio.h>)
+SYMBOL(fputc, std::, <cstdio>)
+SYMBOL(fputc, None, <cstdio>)
+SYMBOL(fputc, None, <stdio.h>)
+SYMBOL(fputs, std::, <cstdio>)
+SYMBOL(fputs, None, <cstdio>)
+SYMBOL(fputs, None, <stdio.h>)
+SYMBOL(fputwc, std::, <cwchar>)
+SYMBOL(fputwc, None, <cwchar>)
+SYMBOL(fputwc, None, <wchar.h>)
+SYMBOL(fputws, std::, <cwchar>)
+SYMBOL(fputws, None, <cwchar>)
+SYMBOL(fputws, None, <wchar.h>)
+SYMBOL(fread, std::, <cstdio>)
+SYMBOL(fread, None, <cstdio>)
+SYMBOL(fread, None, <stdio.h>)
+SYMBOL(free, std::, <cstdlib>)
+SYMBOL(free, None, <cstdlib>)
+SYMBOL(free, None, <stdlib.h>)
+SYMBOL(freopen, std::, <cstdio>)
+SYMBOL(freopen, None, <cstdio>)
+SYMBOL(freopen, None, <stdio.h>)
+SYMBOL(frexp, std::, <cmath>)
+SYMBOL(frexp, None, <cmath>)
+SYMBOL(frexp, None, <math.h>)
+SYMBOL(frexpf, std::, <cmath>)
+SYMBOL(frexpf, None, <cmath>)
+SYMBOL(frexpf, None, <math.h>)
+SYMBOL(frexpl, std::, <cmath>)
+SYMBOL(frexpl, None, <cmath>)
+SYMBOL(frexpl, None, <math.h>)
+SYMBOL(from_chars, std::, <charconv>)
+SYMBOL(from_chars_result, std::, <charconv>)
+SYMBOL(from_range, std::, <ranges>)
+SYMBOL(from_range_t, std::, <ranges>)
+SYMBOL(front_insert_iterator, std::, <iterator>)
+SYMBOL(front_inserter, std::, <iterator>)
+SYMBOL(fscanf, std::, <cstdio>)
+SYMBOL(fscanf, None, <cstdio>)
+SYMBOL(fscanf, None, <stdio.h>)
+SYMBOL(fseek, std::, <cstdio>)
+SYMBOL(fseek, None, <cstdio>)
+SYMBOL(fseek, None, <stdio.h>)
+SYMBOL(fsetpos, std::, <cstdio>)
+SYMBOL(fsetpos, None, <cstdio>)
+SYMBOL(fsetpos, None, <stdio.h>)
+SYMBOL(fstream, std::, <fstream>)
+SYMBOL(fstream, std::, <iosfwd>)
+SYMBOL(ftell, std::, <cstdio>)
+SYMBOL(ftell, None, <cstdio>)
+SYMBOL(ftell, None, <stdio.h>)
+SYMBOL(function, std::, <functional>)
+SYMBOL(future, std::, <future>)
+SYMBOL(future_category, std::, <future>)
+SYMBOL(future_errc, std::, <future>)
+SYMBOL(future_error, std::, <future>)
+SYMBOL(future_status, std::, <future>)
+SYMBOL(fwide, std::, <cwchar>)
+SYMBOL(fwide, None, <cwchar>)
+SYMBOL(fwide, None, <wchar.h>)
+SYMBOL(fwprintf, std::, <cwchar>)
+SYMBOL(fwprintf, None, <cwchar>)
+SYMBOL(fwprintf, None, <wchar.h>)
+SYMBOL(fwrite, std::, <cstdio>)
+SYMBOL(fwrite, None, <cstdio>)
+SYMBOL(fwrite, None, <stdio.h>)
+SYMBOL(fwscanf, std::, <cwchar>)
+SYMBOL(fwscanf, None, <cwchar>)
+SYMBOL(fwscanf, None, <wchar.h>)
+SYMBOL(gamma_distribution, std::, <random>)
+SYMBOL(gcd, std::, <numeric>)
+SYMBOL(generate, std::, <algorithm>)
+SYMBOL(generate_canonical, std::, <random>)
+SYMBOL(generate_n, std::, <algorithm>)
+SYMBOL(generic_category, std::, <system_error>)
+SYMBOL(geometric_distribution, std::, <random>)
+SYMBOL(get_deleter, std::, <memory>)
+SYMBOL(get_if, std::, <variant>)
+SYMBOL(get_money, std::, <iomanip>)
+SYMBOL(get_new_handler, std::, <new>)
+SYMBOL(get_pointer_safety, std::, <memory>)
+SYMBOL(get_temporary_buffer, std::, <memory>)
+SYMBOL(get_terminate, std::, <exception>)
+SYMBOL(get_time, std::, <iomanip>)
+SYMBOL(get_unexpected, std::, <exception>)
+SYMBOL(getc, std::, <cstdio>)
+SYMBOL(getc, None, <cstdio>)
+SYMBOL(getc, None, <stdio.h>)
+SYMBOL(getchar, std::, <cstdio>)
+SYMBOL(getchar, None, <cstdio>)
+SYMBOL(getchar, None, <stdio.h>)
+SYMBOL(getenv, std::, <cstdlib>)
+SYMBOL(getenv, None, <cstdlib>)
+SYMBOL(getenv, None, <stdlib.h>)
+SYMBOL(getline, std::, <string>)
+SYMBOL(gets, std::, <cstdio>)
+SYMBOL(gets, None, <cstdio>)
+SYMBOL(gets, None, <stdio.h>)
+SYMBOL(getwc, std::, <cwchar>)
+SYMBOL(getwc, None, <cwchar>)
+SYMBOL(getwc, None, <wchar.h>)
+SYMBOL(getwchar, std::, <cwchar>)
+SYMBOL(getwchar, None, <cwchar>)
+SYMBOL(getwchar, None, <wchar.h>)
+SYMBOL(giga, std::, <ratio>)
+SYMBOL(gmtime, std::, <ctime>)
+SYMBOL(gmtime, None, <ctime>)
+SYMBOL(gmtime, None, <time.h>)
+SYMBOL(greater, std::, <functional>)
+SYMBOL(greater_equal, std::, <functional>)
+SYMBOL(gslice, std::, <valarray>)
+SYMBOL(gslice_array, std::, <valarray>)
+SYMBOL(hardware_constructive_interference_size, std::, <new>)
+SYMBOL(hardware_destructive_interference_size, std::, <new>)
+SYMBOL(has_facet, std::, <locale>)
+SYMBOL(has_single_bit, std::, <bit>)
+SYMBOL(has_unique_object_representations, std::, <type_traits>)
+SYMBOL(has_unique_object_representations_v, std::, <type_traits>)
+SYMBOL(has_virtual_destructor, std::, <type_traits>)
+SYMBOL(has_virtual_destructor_v, std::, <type_traits>)
+SYMBOL(hash, std::, <functional>)
+SYMBOL(hecto, std::, <ratio>)
+SYMBOL(hermite, std::, <cmath>)
+SYMBOL(hermitef, std::, <cmath>)
+SYMBOL(hermitel, std::, <cmath>)
+SYMBOL(hex, std::, <ios>)
+SYMBOL(hex, std::, <iostream>)
+SYMBOL(hexfloat, std::, <ios>)
+SYMBOL(hexfloat, std::, <iostream>)
+SYMBOL(holds_alternative, std::, <variant>)
+SYMBOL(hypot, std::, <cmath>)
+SYMBOL(hypot, None, <cmath>)
+SYMBOL(hypot, None, <math.h>)
+SYMBOL(hypotf, std::, <cmath>)
+SYMBOL(hypotf, None, <cmath>)
+SYMBOL(hypotf, None, <math.h>)
+SYMBOL(hypotl, std::, <cmath>)
+SYMBOL(hypotl, None, <cmath>)
+SYMBOL(hypotl, None, <math.h>)
+SYMBOL(identity, std::, <functional>)
+SYMBOL(ifstream, std::, <fstream>)
+SYMBOL(ifstream, std::, <iosfwd>)
+SYMBOL(ignore, std::, <tuple>)
+SYMBOL(ilogb, std::, <cmath>)
+SYMBOL(ilogb, None, <cmath>)
+SYMBOL(ilogb, None, <math.h>)
+SYMBOL(ilogbf, std::, <cmath>)
+SYMBOL(ilogbf, None, <cmath>)
+SYMBOL(ilogbf, None, <math.h>)
+SYMBOL(ilogbl, std::, <cmath>)
+SYMBOL(ilogbl, None, <cmath>)
+SYMBOL(ilogbl, None, <math.h>)
+SYMBOL(imag, std::, <complex>)
+SYMBOL(imaxabs, std::, <cinttypes>)
+SYMBOL(imaxabs, None, <cinttypes>)
+SYMBOL(imaxabs, None, <inttypes.h>)
+SYMBOL(imaxdiv, std::, <cinttypes>)
+SYMBOL(imaxdiv, None, <cinttypes>)
+SYMBOL(imaxdiv, None, <inttypes.h>)
+SYMBOL(imaxdiv_t, std::, <cinttypes>)
+SYMBOL(imaxdiv_t, None, <cinttypes>)
+SYMBOL(imaxdiv_t, None, <inttypes.h>)
+SYMBOL(in_place, std::, <utility>)
+SYMBOL(in_place_index, std::, <utility>)
+SYMBOL(in_place_index_t, std::, <utility>)
+SYMBOL(in_place_t, std::, <utility>)
+SYMBOL(in_place_type, std::, <utility>)
+SYMBOL(in_place_type_t, std::, <utility>)
+SYMBOL(in_range, std::, <utility>)
+SYMBOL(includes, std::, <algorithm>)
+SYMBOL(inclusive_scan, std::, <numeric>)
+SYMBOL(incrementable, std::, <iterator>)
+SYMBOL(incrementable_traits, std::, <iterator>)
+SYMBOL(independent_bits_engine, std::, <random>)
+SYMBOL(indirect_array, std::, <valarray>)
+SYMBOL(indirect_binary_predicate, std::, <iterator>)
+SYMBOL(indirect_equivalence_relation, std::, <iterator>)
+SYMBOL(indirect_result_t, std::, <iterator>)
+SYMBOL(indirect_strict_weak_order, std::, <iterator>)
+SYMBOL(indirect_unary_predicate, std::, <iterator>)
+SYMBOL(indirectly_comparable, std::, <iterator>)
+SYMBOL(indirectly_copyable, std::, <iterator>)
+SYMBOL(indirectly_copyable_storable, std::, <iterator>)
+SYMBOL(indirectly_movable, std::, <iterator>)
+SYMBOL(indirectly_movable_storable, std::, <iterator>)
+SYMBOL(indirectly_readable, std::, <iterator>)
+SYMBOL(indirectly_readable_traits, std::, <iterator>)
+SYMBOL(indirectly_regular_unary_invocable, std::, <iterator>)
+SYMBOL(indirectly_swappable, std::, <iterator>)
+SYMBOL(indirectly_unary_invocable, std::, <iterator>)
+SYMBOL(indirectly_writable, std::, <iterator>)
+SYMBOL(initializer_list, std::, <initializer_list>)
+SYMBOL(inner_product, std::, <numeric>)
+SYMBOL(inout_ptr, std::, <memory>)
+SYMBOL(inout_ptr_t, std::, <memory>)
+SYMBOL(inplace_merge, std::, <algorithm>)
+SYMBOL(input_iterator, std::, <iterator>)
+SYMBOL(input_iterator_tag, std::, <iterator>)
+SYMBOL(input_or_output_iterator, std::, <iterator>)
+SYMBOL(insert_iterator, std::, <iterator>)
+SYMBOL(inserter, std::, <iterator>)
+SYMBOL(int16_t, std::, <cstdint>)
+SYMBOL(int16_t, None, <cstdint>)
+SYMBOL(int16_t, None, <stdint.h>)
+SYMBOL(int32_t, std::, <cstdint>)
+SYMBOL(int32_t, None, <cstdint>)
+SYMBOL(int32_t, None, <stdint.h>)
+SYMBOL(int64_t, std::, <cstdint>)
+SYMBOL(int64_t, None, <cstdint>)
+SYMBOL(int64_t, None, <stdint.h>)
+SYMBOL(int8_t, std::, <cstdint>)
+SYMBOL(int8_t, None, <cstdint>)
+SYMBOL(int8_t, None, <stdint.h>)
+SYMBOL(int_fast16_t, std::, <cstdint>)
+SYMBOL(int_fast16_t, None, <cstdint>)
+SYMBOL(int_fast16_t, None, <stdint.h>)
+SYMBOL(int_fast32_t, std::, <cstdint>)
+SYMBOL(int_fast32_t, None, <cstdint>)
+SYMBOL(int_fast32_t, None, <stdint.h>)
+SYMBOL(int_fast64_t, std::, <cstdint>)
+SYMBOL(int_fast64_t, None, <cstdint>)
+SYMBOL(int_fast64_t, None, <stdint.h>)
+SYMBOL(int_fast8_t, std::, <cstdint>)
+SYMBOL(int_fast8_t, None, <cstdint>)
+SYMBOL(int_fast8_t, None, <stdint.h>)
+SYMBOL(int_least16_t, std::, <cstdint>)
+SYMBOL(int_least16_t, None, <cstdint>)
+SYMBOL(int_least16_t, None, <stdint.h>)
+SYMBOL(int_least32_t, std::, <cstdint>)
+SYMBOL(int_least32_t, None, <cstdint>)
+SYMBOL(int_least32_t, None, <stdint.h>)
+SYMBOL(int_least64_t, std::, <cstdint>)
+SYMBOL(int_least64_t, None, <cstdint>)
+SYMBOL(int_least64_t, None, <stdint.h>)
+SYMBOL(int_least8_t, std::, <cstdint>)
+SYMBOL(int_least8_t, None, <cstdint>)
+SYMBOL(int_least8_t, None, <stdint.h>)
+SYMBOL(integer_sequence, std::, <utility>)
+SYMBOL(integral, std::, <concepts>)
+SYMBOL(integral_constant, std::, <type_traits>)
+SYMBOL(internal, std::, <ios>)
+SYMBOL(internal, std::, <iostream>)
+SYMBOL(intmax_t, std::, <cstdint>)
+SYMBOL(intmax_t, None, <cstdint>)
+SYMBOL(intmax_t, None, <stdint.h>)
+SYMBOL(intptr_t, std::, <cstdint>)
+SYMBOL(intptr_t, None, <cstdint>)
+SYMBOL(intptr_t, None, <stdint.h>)
+SYMBOL(invalid_argument, std::, <stdexcept>)
+SYMBOL(invocable, std::, <concepts>)
+SYMBOL(invoke, std::, <functional>)
+SYMBOL(invoke_r, std::, <functional>)
+SYMBOL(invoke_result, std::, <type_traits>)
+SYMBOL(invoke_result_t, std::, <type_traits>)
+SYMBOL(io_errc, std::, <ios>)
+SYMBOL(io_errc, std::, <iostream>)
+SYMBOL(io_state, std::, <ios>)
+SYMBOL(io_state, std::, <iostream>)
+SYMBOL(ios, std::, <ios>)
+SYMBOL(ios, std::, <iostream>)
+SYMBOL(ios, std::, <iosfwd>)
+SYMBOL(ios_base, std::, <ios>)
+SYMBOL(ios_base, std::, <iostream>)
+SYMBOL(iostream, std::, <istream>)
+SYMBOL(iostream, std::, <iostream>)
+SYMBOL(iostream, std::, <iosfwd>)
+SYMBOL(iostream_category, std::, <ios>)
+SYMBOL(iostream_category, std::, <iostream>)
+SYMBOL(iota, std::, <numeric>)
+SYMBOL(is_abstract, std::, <type_traits>)
+SYMBOL(is_abstract_v, std::, <type_traits>)
+SYMBOL(is_aggregate, std::, <type_traits>)
+SYMBOL(is_aggregate_v, std::, <type_traits>)
+SYMBOL(is_arithmetic, std::, <type_traits>)
+SYMBOL(is_arithmetic_v, std::, <type_traits>)
+SYMBOL(is_array, std::, <type_traits>)
+SYMBOL(is_array_v, std::, <type_traits>)
+SYMBOL(is_assignable, std::, <type_traits>)
+SYMBOL(is_assignable_v, std::, <type_traits>)
+SYMBOL(is_base_of, std::, <type_traits>)
+SYMBOL(is_base_of_v, std::, <type_traits>)
+SYMBOL(is_bind_expression, std::, <functional>)
+SYMBOL(is_bind_expression_v, std::, <functional>)
+SYMBOL(is_bounded_array, std::, <type_traits>)
+SYMBOL(is_bounded_array_v, std::, <type_traits>)
+SYMBOL(is_class, std::, <type_traits>)
+SYMBOL(is_class_v, std::, <type_traits>)
+SYMBOL(is_compound, std::, <type_traits>)
+SYMBOL(is_compound_v, std::, <type_traits>)
+SYMBOL(is_const, std::, <type_traits>)
+SYMBOL(is_const_v, std::, <type_traits>)
+SYMBOL(is_constant_evaluated, std::, <type_traits>)
+SYMBOL(is_constructible, std::, <type_traits>)
+SYMBOL(is_constructible_v, std::, <type_traits>)
+SYMBOL(is_convertible, std::, <type_traits>)
+SYMBOL(is_convertible_v, std::, <type_traits>)
+SYMBOL(is_copy_assignable, std::, <type_traits>)
+SYMBOL(is_copy_assignable_v, std::, <type_traits>)
+SYMBOL(is_copy_constructible, std::, <type_traits>)
+SYMBOL(is_copy_constructible_v, std::, <type_traits>)
+SYMBOL(is_corresponding_member, std::, <type_traits>)
+SYMBOL(is_default_constructible, std::, <type_traits>)
+SYMBOL(is_default_constructible_v, std::, <type_traits>)
+SYMBOL(is_destructible, std::, <type_traits>)
+SYMBOL(is_destructible_v, std::, <type_traits>)
+SYMBOL(is_empty, std::, <type_traits>)
+SYMBOL(is_empty_v, std::, <type_traits>)
+SYMBOL(is_enum, std::, <type_traits>)
+SYMBOL(is_enum_v, std::, <type_traits>)
+SYMBOL(is_eq, std::, <compare>)
+SYMBOL(is_error_code_enum, std::, <system_error>)
+SYMBOL(is_error_condition_enum, std::, <system_error>)
+SYMBOL(is_error_condition_enum_v, std::, <system_error>)
+SYMBOL(is_execution_policy, std::, <execution>)
+SYMBOL(is_execution_policy_v, std::, <execution>)
+SYMBOL(is_final, std::, <type_traits>)
+SYMBOL(is_final_v, std::, <type_traits>)
+SYMBOL(is_floating_point, std::, <type_traits>)
+SYMBOL(is_floating_point_v, std::, <type_traits>)
+SYMBOL(is_function, std::, <type_traits>)
+SYMBOL(is_function_v, std::, <type_traits>)
+SYMBOL(is_fundamental, std::, <type_traits>)
+SYMBOL(is_fundamental_v, std::, <type_traits>)
+SYMBOL(is_gt, std::, <compare>)
+SYMBOL(is_gteq, std::, <compare>)
+SYMBOL(is_heap, std::, <algorithm>)
+SYMBOL(is_heap_until, std::, <algorithm>)
+SYMBOL(is_integral, std::, <type_traits>)
+SYMBOL(is_integral_v, std::, <type_traits>)
+SYMBOL(is_invocable, std::, <type_traits>)
+SYMBOL(is_invocable_r, std::, <type_traits>)
+SYMBOL(is_invocable_r_v, std::, <type_traits>)
+SYMBOL(is_invocable_v, std::, <type_traits>)
+SYMBOL(is_layout_compatible, std::, <type_traits>)
+SYMBOL(is_layout_compatible_v, std::, <type_traits>)
+SYMBOL(is_literal_type, std::, <type_traits>)
+SYMBOL(is_literal_type_v, std::, <type_traits>)
+SYMBOL(is_lt, std::, <compare>)
+SYMBOL(is_lteq, std::, <compare>)
+SYMBOL(is_lvalue_reference, std::, <type_traits>)
+SYMBOL(is_lvalue_reference_v, std::, <type_traits>)
+SYMBOL(is_member_function_pointer, std::, <type_traits>)
+SYMBOL(is_member_function_pointer_v, std::, <type_traits>)
+SYMBOL(is_member_object_pointer, std::, <type_traits>)
+SYMBOL(is_member_object_pointer_v, std::, <type_traits>)
+SYMBOL(is_member_pointer, std::, <type_traits>)
+SYMBOL(is_member_pointer_v, std::, <type_traits>)
+SYMBOL(is_move_assignable, std::, <type_traits>)
+SYMBOL(is_move_assignable_v, std::, <type_traits>)
+SYMBOL(is_move_constructible, std::, <type_traits>)
+SYMBOL(is_move_constructible_v, std::, <type_traits>)
+SYMBOL(is_neq, std::, <compare>)
+SYMBOL(is_nothrow_assignable, std::, <type_traits>)
+SYMBOL(is_nothrow_assignable_v, std::, <type_traits>)
+SYMBOL(is_nothrow_constructible, std::, <type_traits>)
+SYMBOL(is_nothrow_constructible_v, std::, <type_traits>)
+SYMBOL(is_nothrow_convertible, std::, <type_traits>)
+SYMBOL(is_nothrow_convertible_v, std::, <type_traits>)
+SYMBOL(is_nothrow_copy_assignable, std::, <type_traits>)
+SYMBOL(is_nothrow_copy_assignable_v, std::, <type_traits>)
+SYMBOL(is_nothrow_copy_constructible, std::, <type_traits>)
+SYMBOL(is_nothrow_copy_constructible_v, std::, <type_traits>)
+SYMBOL(is_nothrow_default_constructible, std::, <type_traits>)
+SYMBOL(is_nothrow_default_constructible_v, std::, <type_traits>)
+SYMBOL(is_nothrow_destructible, std::, <type_traits>)
+SYMBOL(is_nothrow_destructible_v, std::, <type_traits>)
+SYMBOL(is_nothrow_invocable, std::, <type_traits>)
+SYMBOL(is_nothrow_invocable_r, std::, <type_traits>)
+SYMBOL(is_nothrow_invocable_r_v, std::, <type_traits>)
+SYMBOL(is_nothrow_invocable_v, std::, <type_traits>)
+SYMBOL(is_nothrow_move_assignable, std::, <type_traits>)
+SYMBOL(is_nothrow_move_assignable_v, std::, <type_traits>)
+SYMBOL(is_nothrow_move_constructible, std::, <type_traits>)
+SYMBOL(is_nothrow_move_constructible_v, std::, <type_traits>)
+SYMBOL(is_nothrow_swappable, std::, <type_traits>)
+SYMBOL(is_nothrow_swappable_v, std::, <type_traits>)
+SYMBOL(is_nothrow_swappable_with, std::, <type_traits>)
+SYMBOL(is_nothrow_swappable_with_v, std::, <type_traits>)
+SYMBOL(is_null_pointer, std::, <type_traits>)
+SYMBOL(is_null_pointer_v, std::, <type_traits>)
+SYMBOL(is_object, std::, <type_traits>)
+SYMBOL(is_object_v, std::, <type_traits>)
+SYMBOL(is_partitioned, std::, <algorithm>)
+SYMBOL(is_permutation, std::, <algorithm>)
+SYMBOL(is_placeholder, std::, <functional>)
+SYMBOL(is_placeholder_v, std::, <functional>)
+SYMBOL(is_pod, std::, <type_traits>)
+SYMBOL(is_pod_v, std::, <type_traits>)
+SYMBOL(is_pointer, std::, <type_traits>)
+SYMBOL(is_pointer_interconvertible_base_of, std::, <type_traits>)
+SYMBOL(is_pointer_interconvertible_base_of_v, std::, <type_traits>)
+SYMBOL(is_pointer_interconvertible_with_class, std::, <type_traits>)
+SYMBOL(is_pointer_v, std::, <type_traits>)
+SYMBOL(is_polymorphic, std::, <type_traits>)
+SYMBOL(is_polymorphic_v, std::, <type_traits>)
+SYMBOL(is_reference, std::, <type_traits>)
+SYMBOL(is_reference_v, std::, <type_traits>)
+SYMBOL(is_rvalue_reference, std::, <type_traits>)
+SYMBOL(is_rvalue_reference_v, std::, <type_traits>)
+SYMBOL(is_same, std::, <type_traits>)
+SYMBOL(is_same_v, std::, <type_traits>)
+SYMBOL(is_scalar, std::, <type_traits>)
+SYMBOL(is_scalar_v, std::, <type_traits>)
+SYMBOL(is_scoped_enum, std::, <type_traits>)
+SYMBOL(is_scoped_enum_v, std::, <type_traits>)
+SYMBOL(is_signed, std::, <type_traits>)
+SYMBOL(is_signed_v, std::, <type_traits>)
+SYMBOL(is_sorted, std::, <algorithm>)
+SYMBOL(is_sorted_until, std::, <algorithm>)
+SYMBOL(is_standard_layout, std::, <type_traits>)
+SYMBOL(is_standard_layout_v, std::, <type_traits>)
+SYMBOL(is_swappable, std::, <type_traits>)
+SYMBOL(is_swappable_v, std::, <type_traits>)
+SYMBOL(is_swappable_with, std::, <type_traits>)
+SYMBOL(is_swappable_with_v, std::, <type_traits>)
+SYMBOL(is_trivial, std::, <type_traits>)
+SYMBOL(is_trivial_v, std::, <type_traits>)
+SYMBOL(is_trivially_assignable, std::, <type_traits>)
+SYMBOL(is_trivially_assignable_v, std::, <type_traits>)
+SYMBOL(is_trivially_constructible, std::, <type_traits>)
+SYMBOL(is_trivially_constructible_v, std::, <type_traits>)
+SYMBOL(is_trivially_copy_assignable, std::, <type_traits>)
+SYMBOL(is_trivially_copy_assignable_v, std::, <type_traits>)
+SYMBOL(is_trivially_copy_constructible, std::, <type_traits>)
+SYMBOL(is_trivially_copy_constructible_v, std::, <type_traits>)
+SYMBOL(is_trivially_copyable, std::, <type_traits>)
+SYMBOL(is_trivially_copyable_v, std::, <type_traits>)
+SYMBOL(is_trivially_default_constructible, std::, <type_traits>)
+SYMBOL(is_trivially_default_constructible_v, std::, <type_traits>)
+SYMBOL(is_trivially_destructible, std::, <type_traits>)
+SYMBOL(is_trivially_destructible_v, std::, <type_traits>)
+SYMBOL(is_trivially_move_assignable, std::, <type_traits>)
+SYMBOL(is_trivially_move_assignable_v, std::, <type_traits>)
+SYMBOL(is_trivially_move_constructible, std::, <type_traits>)
+SYMBOL(is_trivially_move_constructible_v, std::, <type_traits>)
+SYMBOL(is_unbounded_array, std::, <type_traits>)
+SYMBOL(is_unbounded_array_v, std::, <type_traits>)
+SYMBOL(is_union, std::, <type_traits>)
+SYMBOL(is_union_v, std::, <type_traits>)
+SYMBOL(is_unsigned, std::, <type_traits>)
+SYMBOL(is_unsigned_v, std::, <type_traits>)
+SYMBOL(is_void, std::, <type_traits>)
+SYMBOL(is_void_v, std::, <type_traits>)
+SYMBOL(is_volatile, std::, <type_traits>)
+SYMBOL(is_volatile_v, std::, <type_traits>)
+SYMBOL(isalnum, std::, <cctype>)
+SYMBOL(isalnum, None, <cctype>)
+SYMBOL(isalnum, None, <ctype.h>)
+SYMBOL(isalpha, std::, <cctype>)
+SYMBOL(isalpha, None, <cctype>)
+SYMBOL(isalpha, None, <ctype.h>)
+SYMBOL(isblank, std::, <cctype>)
+SYMBOL(isblank, None, <cctype>)
+SYMBOL(isblank, None, <ctype.h>)
+SYMBOL(iscntrl, std::, <cctype>)
+SYMBOL(iscntrl, None, <cctype>)
+SYMBOL(iscntrl, None, <ctype.h>)
+SYMBOL(isdigit, std::, <cctype>)
+SYMBOL(isdigit, None, <cctype>)
+SYMBOL(isdigit, None, <ctype.h>)
+SYMBOL(isfinite, std::, <cmath>)
+SYMBOL(isfinite, None, <cmath>)
+SYMBOL(isfinite, None, <math.h>)
+SYMBOL(isgraph, std::, <cctype>)
+SYMBOL(isgraph, None, <cctype>)
+SYMBOL(isgraph, None, <ctype.h>)
+SYMBOL(isgreater, std::, <cmath>)
+SYMBOL(isgreater, None, <cmath>)
+SYMBOL(isgreater, None, <math.h>)
+SYMBOL(isgreaterequal, std::, <cmath>)
+SYMBOL(isgreaterequal, None, <cmath>)
+SYMBOL(isgreaterequal, None, <math.h>)
+SYMBOL(isinf, std::, <cmath>)
+SYMBOL(isinf, None, <cmath>)
+SYMBOL(isinf, None, <math.h>)
+SYMBOL(isless, std::, <cmath>)
+SYMBOL(isless, None, <cmath>)
+SYMBOL(isless, None, <math.h>)
+SYMBOL(islessequal, std::, <cmath>)
+SYMBOL(islessequal, None, <cmath>)
+SYMBOL(islessequal, None, <math.h>)
+SYMBOL(islessgreater, std::, <cmath>)
+SYMBOL(islessgreater, None, <cmath>)
+SYMBOL(islessgreater, None, <math.h>)
+SYMBOL(islower, std::, <cctype>)
+SYMBOL(islower, None, <cctype>)
+SYMBOL(islower, None, <ctype.h>)
+SYMBOL(isnan, std::, <cmath>)
+SYMBOL(isnan, None, <cmath>)
+SYMBOL(isnan, None, <math.h>)
+SYMBOL(isnormal, std::, <cmath>)
+SYMBOL(isnormal, None, <cmath>)
+SYMBOL(isnormal, None, <math.h>)
+SYMBOL(ispanstream, std::, <spanstream>)
+SYMBOL(ispanstream, std::, <iosfwd>)
+SYMBOL(isprint, std::, <cctype>)
+SYMBOL(isprint, None, <cctype>)
+SYMBOL(isprint, None, <ctype.h>)
+SYMBOL(ispunct, std::, <cctype>)
+SYMBOL(ispunct, None, <cctype>)
+SYMBOL(ispunct, None, <ctype.h>)
+SYMBOL(isspace, std::, <cctype>)
+SYMBOL(isspace, None, <cctype>)
+SYMBOL(isspace, None, <ctype.h>)
+SYMBOL(istream, std::, <istream>)
+SYMBOL(istream, std::, <iostream>)
+SYMBOL(istream, std::, <iosfwd>)
+SYMBOL(istream_iterator, std::, <iterator>)
+SYMBOL(istreambuf_iterator, std::, <iterator>)
+SYMBOL(istreambuf_iterator, std::, <iosfwd>)
+SYMBOL(istringstream, std::, <sstream>)
+SYMBOL(istringstream, std::, <iosfwd>)
+SYMBOL(istrstream, std::, <strstream>)
+SYMBOL(isunordered, std::, <cmath>)
+SYMBOL(isunordered, None, <cmath>)
+SYMBOL(isunordered, None, <math.h>)
+SYMBOL(isupper, std::, <cctype>)
+SYMBOL(isupper, None, <cctype>)
+SYMBOL(isupper, None, <ctype.h>)
+SYMBOL(iswalnum, std::, <cwctype>)
+SYMBOL(iswalnum, None, <cwctype>)
+SYMBOL(iswalnum, None, <wctype.h>)
+SYMBOL(iswalpha, std::, <cwctype>)
+SYMBOL(iswalpha, None, <cwctype>)
+SYMBOL(iswalpha, None, <wctype.h>)
+SYMBOL(iswblank, std::, <cwctype>)
+SYMBOL(iswblank, None, <cwctype>)
+SYMBOL(iswblank, None, <wctype.h>)
+SYMBOL(iswcntrl, std::, <cwctype>)
+SYMBOL(iswcntrl, None, <cwctype>)
+SYMBOL(iswcntrl, None, <wctype.h>)
+SYMBOL(iswctype, std::, <cwctype>)
+SYMBOL(iswctype, None, <cwctype>)
+SYMBOL(iswctype, None, <wctype.h>)
+SYMBOL(iswdigit, std::, <cwctype>)
+SYMBOL(iswdigit, None, <cwctype>)
+SYMBOL(iswdigit, None, <wctype.h>)
+SYMBOL(iswgraph, std::, <cwctype>)
+SYMBOL(iswgraph, None, <cwctype>)
+SYMBOL(iswgraph, None, <wctype.h>)
+SYMBOL(iswlower, std::, <cwctype>)
+SYMBOL(iswlower, None, <cwctype>)
+SYMBOL(iswlower, None, <wctype.h>)
+SYMBOL(iswprint, std::, <cwctype>)
+SYMBOL(iswprint, None, <cwctype>)
+SYMBOL(iswprint, None, <wctype.h>)
+SYMBOL(iswpunct, std::, <cwctype>)
+SYMBOL(iswpunct, None, <cwctype>)
+SYMBOL(iswpunct, None, <wctype.h>)
+SYMBOL(iswspace, std::, <cwctype>)
+SYMBOL(iswspace, None, <cwctype>)
+SYMBOL(iswspace, None, <wctype.h>)
+SYMBOL(iswupper, std::, <cwctype>)
+SYMBOL(iswupper, None, <cwctype>)
+SYMBOL(iswupper, None, <wctype.h>)
+SYMBOL(iswxdigit, std::, <cwctype>)
+SYMBOL(iswxdigit, None, <cwctype>)
+SYMBOL(iswxdigit, None, <wctype.h>)
+SYMBOL(isxdigit, std::, <cctype>)
+SYMBOL(isxdigit, None, <cctype>)
+SYMBOL(isxdigit, None, <ctype.h>)
+SYMBOL(iter_common_reference_t, std::, <iterator>)
+SYMBOL(iter_const_reference_t, std::, <iterator>)
+SYMBOL(iter_difference_t, std::, <iterator>)
+SYMBOL(iter_reference_t, std::, <iterator>)
+SYMBOL(iter_rvalue_reference_t, std::, <iterator>)
+SYMBOL(iter_swap, std::, <algorithm>)
+SYMBOL(iter_value_t, std::, <iterator>)
+SYMBOL(iterator, std::, <iterator>)
+SYMBOL(iterator_traits, std::, <iterator>)
+SYMBOL(jmp_buf, std::, <csetjmp>)
+SYMBOL(jmp_buf, None, <csetjmp>)
+SYMBOL(jmp_buf, None, <setjmp.h>)
+SYMBOL(jthread, std::, <thread>)
+SYMBOL(kill_dependency, std::, <atomic>)
+SYMBOL(kilo, std::, <ratio>)
+SYMBOL(knuth_b, std::, <random>)
+SYMBOL(labs, std::, <cstdlib>)
+SYMBOL(labs, None, <cstdlib>)
+SYMBOL(labs, None, <stdlib.h>)
+SYMBOL(laguerre, std::, <cmath>)
+SYMBOL(laguerref, std::, <cmath>)
+SYMBOL(laguerrel, std::, <cmath>)
+SYMBOL(latch, std::, <latch>)
+SYMBOL(launch, std::, <future>)
+SYMBOL(launder, std::, <new>)
+SYMBOL(lcm, std::, <numeric>)
+SYMBOL(lconv, std::, <clocale>)
+SYMBOL(lconv, None, <clocale>)
+SYMBOL(lconv, None, <locale.h>)
+SYMBOL(ldexp, std::, <cmath>)
+SYMBOL(ldexp, None, <cmath>)
+SYMBOL(ldexp, None, <math.h>)
+SYMBOL(ldexpf, std::, <cmath>)
+SYMBOL(ldexpf, None, <cmath>)
+SYMBOL(ldexpf, None, <math.h>)
+SYMBOL(ldexpl, std::, <cmath>)
+SYMBOL(ldexpl, None, <cmath>)
+SYMBOL(ldexpl, None, <math.h>)
+SYMBOL(ldiv, std::, <cstdlib>)
+SYMBOL(ldiv, None, <cstdlib>)
+SYMBOL(ldiv, None, <stdlib.h>)
+SYMBOL(ldiv_t, std::, <cstdlib>)
+SYMBOL(ldiv_t, None, <cstdlib>)
+SYMBOL(ldiv_t, None, <stdlib.h>)
+SYMBOL(left, std::, <ios>)
+SYMBOL(left, std::, <iostream>)
+SYMBOL(legendre, std::, <cmath>)
+SYMBOL(legendref, std::, <cmath>)
+SYMBOL(legendrel, std::, <cmath>)
+SYMBOL(length_error, std::, <stdexcept>)
+SYMBOL(lerp, std::, <cmath>)
+SYMBOL(less, std::, <functional>)
+SYMBOL(less_equal, std::, <functional>)
+SYMBOL(lexicographical_compare, std::, <algorithm>)
+SYMBOL(lexicographical_compare_three_way, std::, <algorithm>)
+SYMBOL(lgamma, std::, <cmath>)
+SYMBOL(lgamma, None, <cmath>)
+SYMBOL(lgamma, None, <math.h>)
+SYMBOL(lgammaf, std::, <cmath>)
+SYMBOL(lgammaf, None, <cmath>)
+SYMBOL(lgammaf, None, <math.h>)
+SYMBOL(lgammal, std::, <cmath>)
+SYMBOL(lgammal, None, <cmath>)
+SYMBOL(lgammal, None, <math.h>)
+SYMBOL(linear_congruential_engine, std::, <random>)
+SYMBOL(list, std::, <list>)
+SYMBOL(llabs, std::, <cstdlib>)
+SYMBOL(llabs, None, <cstdlib>)
+SYMBOL(llabs, None, <stdlib.h>)
+SYMBOL(lldiv, std::, <cstdlib>)
+SYMBOL(lldiv, None, <cstdlib>)
+SYMBOL(lldiv, None, <stdlib.h>)
+SYMBOL(lldiv_t, std::, <cstdlib>)
+SYMBOL(lldiv_t, None, <cstdlib>)
+SYMBOL(lldiv_t, None, <stdlib.h>)
+SYMBOL(llrint, std::, <cmath>)
+SYMBOL(llrint, None, <cmath>)
+SYMBOL(llrint, None, <math.h>)
+SYMBOL(llrintf, std::, <cmath>)
+SYMBOL(llrintf, None, <cmath>)
+SYMBOL(llrintf, None, <math.h>)
+SYMBOL(llrintl, std::, <cmath>)
+SYMBOL(llrintl, None, <cmath>)
+SYMBOL(llrintl, None, <math.h>)
+SYMBOL(llround, std::, <cmath>)
+SYMBOL(llround, None, <cmath>)
+SYMBOL(llround, None, <math.h>)
+SYMBOL(llroundf, std::, <cmath>)
+SYMBOL(llroundf, None, <cmath>)
+SYMBOL(llroundf, None, <math.h>)
+SYMBOL(llroundl, std::, <cmath>)
+SYMBOL(llroundl, None, <cmath>)
+SYMBOL(llroundl, None, <math.h>)
+SYMBOL(locale, std::, <locale>)
+SYMBOL(localeconv, std::, <clocale>)
+SYMBOL(localeconv, None, <clocale>)
+SYMBOL(localeconv, None, <locale.h>)
+SYMBOL(localtime, std::, <ctime>)
+SYMBOL(localtime, None, <ctime>)
+SYMBOL(localtime, None, <time.h>)
+SYMBOL(lock, std::, <mutex>)
+SYMBOL(lock_guard, std::, <mutex>)
+SYMBOL(log, std::, <cmath>)
+SYMBOL(log, None, <cmath>)
+SYMBOL(log, None, <math.h>)
+SYMBOL(log10, std::, <cmath>)
+SYMBOL(log10, None, <cmath>)
+SYMBOL(log10, None, <math.h>)
+SYMBOL(log10f, std::, <cmath>)
+SYMBOL(log10f, None, <cmath>)
+SYMBOL(log10f, None, <math.h>)
+SYMBOL(log10l, std::, <cmath>)
+SYMBOL(log10l, None, <cmath>)
+SYMBOL(log10l, None, <math.h>)
+SYMBOL(log1p, std::, <cmath>)
+SYMBOL(log1p, None, <cmath>)
+SYMBOL(log1p, None, <math.h>)
+SYMBOL(log1pf, std::, <cmath>)
+SYMBOL(log1pf, None, <cmath>)
+SYMBOL(log1pf, None, <math.h>)
+SYMBOL(log1pl, std::, <cmath>)
+SYMBOL(log1pl, None, <cmath>)
+SYMBOL(log1pl, None, <math.h>)
+SYMBOL(log2, std::, <cmath>)
+SYMBOL(log2, None, <cmath>)
+SYMBOL(log2, None, <math.h>)
+SYMBOL(log2f, std::, <cmath>)
+SYMBOL(log2f, None, <cmath>)
+SYMBOL(log2f, None, <math.h>)
+SYMBOL(log2l, std::, <cmath>)
+SYMBOL(log2l, None, <cmath>)
+SYMBOL(log2l, None, <math.h>)
+SYMBOL(logb, std::, <cmath>)
+SYMBOL(logb, None, <cmath>)
+SYMBOL(logb, None, <math.h>)
+SYMBOL(logbf, std::, <cmath>)
+SYMBOL(logbf, None, <cmath>)
+SYMBOL(logbf, None, <math.h>)
+SYMBOL(logbl, std::, <cmath>)
+SYMBOL(logbl, None, <cmath>)
+SYMBOL(logbl, None, <math.h>)
+SYMBOL(logf, std::, <cmath>)
+SYMBOL(logf, None, <cmath>)
+SYMBOL(logf, None, <math.h>)
+SYMBOL(logic_error, std::, <stdexcept>)
+SYMBOL(logical_and, std::, <functional>)
+SYMBOL(logical_not, std::, <functional>)
+SYMBOL(logical_or, std::, <functional>)
+SYMBOL(logl, std::, <cmath>)
+SYMBOL(logl, None, <cmath>)
+SYMBOL(logl, None, <math.h>)
+SYMBOL(lognormal_distribution, std::, <random>)
+SYMBOL(longjmp, std::, <csetjmp>)
+SYMBOL(longjmp, None, <csetjmp>)
+SYMBOL(longjmp, None, <setjmp.h>)
+SYMBOL(lower_bound, std::, <algorithm>)
+SYMBOL(lrint, std::, <cmath>)
+SYMBOL(lrint, None, <cmath>)
+SYMBOL(lrint, None, <math.h>)
+SYMBOL(lrintf, std::, <cmath>)
+SYMBOL(lrintf, None, <cmath>)
+SYMBOL(lrintf, None, <math.h>)
+SYMBOL(lrintl, std::, <cmath>)
+SYMBOL(lrintl, None, <cmath>)
+SYMBOL(lrintl, None, <math.h>)
+SYMBOL(lround, std::, <cmath>)
+SYMBOL(lround, None, <cmath>)
+SYMBOL(lround, None, <math.h>)
+SYMBOL(lroundf, std::, <cmath>)
+SYMBOL(lroundf, None, <cmath>)
+SYMBOL(lroundf, None, <math.h>)
+SYMBOL(lroundl, std::, <cmath>)
+SYMBOL(lroundl, None, <cmath>)
+SYMBOL(lroundl, None, <math.h>)
+SYMBOL(make_exception_ptr, std::, <exception>)
+SYMBOL(make_format_args, std::, <format>)
+SYMBOL(make_from_tuple, std::, <tuple>)
+SYMBOL(make_heap, std::, <algorithm>)
+SYMBOL(make_move_iterator, std::, <iterator>)
+SYMBOL(make_obj_using_allocator, std::, <memory>)
+SYMBOL(make_optional, std::, <optional>)
+SYMBOL(make_pair, std::, <utility>)
+SYMBOL(make_reverse_iterator, std::, <iterator>)
+SYMBOL(make_shared, std::, <memory>)
+SYMBOL(make_shared_for_overwrite, std::, <memory>)
+SYMBOL(make_signed, std::, <type_traits>)
+SYMBOL(make_signed_t, std::, <type_traits>)
+SYMBOL(make_tuple, std::, <tuple>)
+SYMBOL(make_unique, std::, <memory>)
+SYMBOL(make_unique_for_overwrite, std::, <memory>)
+SYMBOL(make_unsigned, std::, <type_traits>)
+SYMBOL(make_unsigned_t, std::, <type_traits>)
+SYMBOL(make_wformat_args, std::, <format>)
+SYMBOL(malloc, std::, <cstdlib>)
+SYMBOL(malloc, None, <cstdlib>)
+SYMBOL(malloc, None, <stdlib.h>)
+SYMBOL(map, std::, <map>)
+SYMBOL(mask_array, std::, <valarray>)
+SYMBOL(match_results, std::, <regex>)
+SYMBOL(max, std::, <algorithm>)
+SYMBOL(max_align_t, std::, <cstddef>)
+SYMBOL(max_align_t, None, <cstddef>)
+SYMBOL(max_align_t, None, <stddef.h>)
+SYMBOL(max_element, std::, <algorithm>)
+SYMBOL(mblen, std::, <cstdlib>)
+SYMBOL(mblen, None, <cstdlib>)
+SYMBOL(mblen, None, <stdlib.h>)
+SYMBOL(mbrlen, std::, <cwchar>)
+SYMBOL(mbrlen, None, <cwchar>)
+SYMBOL(mbrlen, None, <wchar.h>)
+SYMBOL(mbrtoc16, std::, <cuchar>)
+SYMBOL(mbrtoc16, None, <cuchar>)
+SYMBOL(mbrtoc16, None, <uchar.h>)
+SYMBOL(mbrtoc32, std::, <cuchar>)
+SYMBOL(mbrtoc32, None, <cuchar>)
+SYMBOL(mbrtoc32, None, <uchar.h>)
+SYMBOL(mbrtoc8, std::, <cuchar>)
+SYMBOL(mbrtoc8, None, <cuchar>)
+SYMBOL(mbrtoc8, None, <uchar.h>)
+SYMBOL(mbrtowc, std::, <cwchar>)
+SYMBOL(mbrtowc, None, <cwchar>)
+SYMBOL(mbrtowc, None, <wchar.h>)
+SYMBOL(mbsinit, std::, <cwchar>)
+SYMBOL(mbsinit, None, <cwchar>)
+SYMBOL(mbsinit, None, <wchar.h>)
+SYMBOL(mbsrtowcs, std::, <cwchar>)
+SYMBOL(mbsrtowcs, None, <cwchar>)
+SYMBOL(mbsrtowcs, None, <wchar.h>)
+SYMBOL(mbstowcs, std::, <cstdlib>)
+SYMBOL(mbstowcs, None, <cstdlib>)
+SYMBOL(mbstowcs, None, <stdlib.h>)
+SYMBOL(mbtowc, std::, <cstdlib>)
+SYMBOL(mbtowc, None, <cstdlib>)
+SYMBOL(mbtowc, None, <stdlib.h>)
+SYMBOL(mega, std::, <ratio>)
+SYMBOL(mem_fn, std::, <functional>)
+SYMBOL(mem_fun, std::, <functional>)
+SYMBOL(mem_fun1_ref_t, std::, <functional>)
+SYMBOL(mem_fun1_t, std::, <functional>)
+SYMBOL(mem_fun_ref, std::, <functional>)
+SYMBOL(mem_fun_ref_t, std::, <functional>)
+SYMBOL(mem_fun_t, std::, <functional>)
+SYMBOL(memchr, std::, <cstring>)
+SYMBOL(memchr, None, <cstring>)
+SYMBOL(memchr, None, <string.h>)
+SYMBOL(memcmp, std::, <cstring>)
+SYMBOL(memcmp, None, <cstring>)
+SYMBOL(memcmp, None, <string.h>)
+SYMBOL(memcpy, std::, <cstring>)
+SYMBOL(memcpy, None, <cstring>)
+SYMBOL(memcpy, None, <string.h>)
+SYMBOL(memmove, std::, <cstring>)
+SYMBOL(memmove, None, <cstring>)
+SYMBOL(memmove, None, <string.h>)
+SYMBOL(memory_order, std::, <atomic>)
+SYMBOL(memory_order_acq_rel, std::, <atomic>)
+SYMBOL(memory_order_acquire, std::, <atomic>)
+SYMBOL(memory_order_consume, std::, <atomic>)
+SYMBOL(memory_order_relaxed, std::, <atomic>)
+SYMBOL(memory_order_release, std::, <atomic>)
+SYMBOL(memory_order_seq_cst, std::, <atomic>)
+SYMBOL(memset, std::, <cstring>)
+SYMBOL(memset, None, <cstring>)
+SYMBOL(memset, None, <string.h>)
+SYMBOL(merge, std::, <algorithm>)
+SYMBOL(mergeable, std::, <iterator>)
+SYMBOL(mersenne_twister_engine, std::, <random>)
+SYMBOL(messages, std::, <locale>)
+SYMBOL(messages_base, std::, <locale>)
+SYMBOL(messages_byname, std::, <locale>)
+SYMBOL(micro, std::, <ratio>)
+SYMBOL(midpoint, std::, <numeric>)
+SYMBOL(milli, std::, <ratio>)
+SYMBOL(min, std::, <algorithm>)
+SYMBOL(min_element, std::, <algorithm>)
+SYMBOL(minmax, std::, <algorithm>)
+SYMBOL(minmax_element, std::, <algorithm>)
+SYMBOL(minstd_rand, std::, <random>)
+SYMBOL(minstd_rand0, std::, <random>)
+SYMBOL(minus, std::, <functional>)
+SYMBOL(mismatch, std::, <algorithm>)
+SYMBOL(mktime, std::, <ctime>)
+SYMBOL(mktime, None, <ctime>)
+SYMBOL(mktime, None, <time.h>)
+SYMBOL(modf, std::, <cmath>)
+SYMBOL(modf, None, <cmath>)
+SYMBOL(modf, None, <math.h>)
+SYMBOL(modff, std::, <cmath>)
+SYMBOL(modff, None, <cmath>)
+SYMBOL(modff, None, <math.h>)
+SYMBOL(modfl, std::, <cmath>)
+SYMBOL(modfl, None, <cmath>)
+SYMBOL(modfl, None, <math.h>)
+SYMBOL(modulus, std::, <functional>)
+SYMBOL(money_base, std::, <locale>)
+SYMBOL(money_get, std::, <locale>)
+SYMBOL(money_put, std::, <locale>)
+SYMBOL(moneypunct, std::, <locale>)
+SYMBOL(moneypunct_byname, std::, <locale>)
+SYMBOL(monostate, std::, <variant>)
+SYMBOL(movable, std::, <concepts>)
+SYMBOL(move_backward, std::, <algorithm>)
+SYMBOL(move_constructible, std::, <concepts>)
+SYMBOL(move_if_noexcept, std::, <utility>)
+SYMBOL(move_iterator, std::, <iterator>)
+SYMBOL(move_only_function, std::, <functional>)
+SYMBOL(move_sentinel, std::, <iterator>)
+SYMBOL(mt19937, std::, <random>)
+SYMBOL(mt19937_64, std::, <random>)
+SYMBOL(multimap, std::, <map>)
+SYMBOL(multiplies, std::, <functional>)
+SYMBOL(multiset, std::, <set>)
+SYMBOL(mutex, std::, <mutex>)
+SYMBOL(nan, std::, <cmath>)
+SYMBOL(nan, None, <cmath>)
+SYMBOL(nan, None, <math.h>)
+SYMBOL(nanf, std::, <cmath>)
+SYMBOL(nanf, None, <cmath>)
+SYMBOL(nanf, None, <math.h>)
+SYMBOL(nanl, std::, <cmath>)
+SYMBOL(nanl, None, <cmath>)
+SYMBOL(nanl, None, <math.h>)
+SYMBOL(nano, std::, <ratio>)
+SYMBOL(nearbyint, std::, <cmath>)
+SYMBOL(nearbyint, None, <cmath>)
+SYMBOL(nearbyint, None, <math.h>)
+SYMBOL(nearbyintf, std::, <cmath>)
+SYMBOL(nearbyintf, None, <cmath>)
+SYMBOL(nearbyintf, None, <math.h>)
+SYMBOL(nearbyintl, std::, <cmath>)
+SYMBOL(nearbyintl, None, <cmath>)
+SYMBOL(nearbyintl, None, <math.h>)
+SYMBOL(negate, std::, <functional>)
+SYMBOL(negation, std::, <type_traits>)
+SYMBOL(negation_v, std::, <type_traits>)
+SYMBOL(negative_binomial_distribution, std::, <random>)
+SYMBOL(nested_exception, std::, <exception>)
+SYMBOL(new_handler, std::, <new>)
+SYMBOL(next, std::, <iterator>)
+SYMBOL(next_permutation, std::, <algorithm>)
+SYMBOL(nextafter, std::, <cmath>)
+SYMBOL(nextafter, None, <cmath>)
+SYMBOL(nextafter, None, <math.h>)
+SYMBOL(nextafterf, std::, <cmath>)
+SYMBOL(nextafterf, None, <cmath>)
+SYMBOL(nextafterf, None, <math.h>)
+SYMBOL(nextafterl, std::, <cmath>)
+SYMBOL(nextafterl, None, <cmath>)
+SYMBOL(nextafterl, None, <math.h>)
+SYMBOL(nexttoward, std::, <cmath>)
+SYMBOL(nexttoward, None, <cmath>)
+SYMBOL(nexttoward, None, <math.h>)
+SYMBOL(nexttowardf, std::, <cmath>)
+SYMBOL(nexttowardf, None, <cmath>)
+SYMBOL(nexttowardf, None, <math.h>)
+SYMBOL(nexttowardl, std::, <cmath>)
+SYMBOL(nexttowardl, None, <cmath>)
+SYMBOL(nexttowardl, None, <math.h>)
+SYMBOL(noboolalpha, std::, <ios>)
+SYMBOL(noboolalpha, std::, <iostream>)
+SYMBOL(noemit_on_flush, std::, <ostream>)
+SYMBOL(noemit_on_flush, std::, <iostream>)
+SYMBOL(none_of, std::, <algorithm>)
+SYMBOL(noop_coroutine, std::, <coroutine>)
+SYMBOL(noop_coroutine_handle, std::, <coroutine>)
+SYMBOL(noop_coroutine_promise, std::, <coroutine>)
+SYMBOL(norm, std::, <complex>)
+SYMBOL(normal_distribution, std::, <random>)
+SYMBOL(noshowbase, std::, <ios>)
+SYMBOL(noshowbase, std::, <iostream>)
+SYMBOL(noshowpoint, std::, <ios>)
+SYMBOL(noshowpoint, std::, <iostream>)
+SYMBOL(noshowpos, std::, <ios>)
+SYMBOL(noshowpos, std::, <iostream>)
+SYMBOL(noskipws, std::, <ios>)
+SYMBOL(noskipws, std::, <iostream>)
+SYMBOL(nostopstate, std::, <stop_token>)
+SYMBOL(nostopstate_t, std::, <stop_token>)
+SYMBOL(not1, std::, <functional>)
+SYMBOL(not2, std::, <functional>)
+SYMBOL(not_equal_to, std::, <functional>)
+SYMBOL(not_fn, std::, <functional>)
+SYMBOL(nothrow, std::, <new>)
+SYMBOL(nothrow_t, std::, <new>)
+SYMBOL(notify_all_at_thread_exit, std::, <condition_variable>)
+SYMBOL(nounitbuf, std::, <ios>)
+SYMBOL(nounitbuf, std::, <iostream>)
+SYMBOL(nouppercase, std::, <ios>)
+SYMBOL(nouppercase, std::, <iostream>)
+SYMBOL(nth_element, std::, <algorithm>)
+SYMBOL(nullopt, std::, <optional>)
+SYMBOL(nullopt_t, std::, <optional>)
+SYMBOL(nullptr_t, std::, <cstddef>)
+SYMBOL(nullptr_t, None, <cstddef>)
+SYMBOL(nullptr_t, None, <stddef.h>)
+SYMBOL(num_get, std::, <locale>)
+SYMBOL(num_put, std::, <locale>)
+SYMBOL(numeric_limits, std::, <limits>)
+SYMBOL(numpunct, std::, <locale>)
+SYMBOL(numpunct_byname, std::, <locale>)
+SYMBOL(oct, std::, <ios>)
+SYMBOL(oct, std::, <iostream>)
+SYMBOL(ofstream, std::, <fstream>)
+SYMBOL(ofstream, std::, <iosfwd>)
+SYMBOL(once_flag, std::, <mutex>)
+SYMBOL(open_mode, std::, <ios>)
+SYMBOL(open_mode, std::, <iostream>)
+SYMBOL(optional, std::, <optional>)
+SYMBOL(ospanstream, std::, <spanstream>)
+SYMBOL(ospanstream, std::, <iosfwd>)
+SYMBOL(ostream, std::, <ostream>)
+SYMBOL(ostream, std::, <iostream>)
+SYMBOL(ostream, std::, <iosfwd>)
+SYMBOL(ostream_iterator, std::, <iterator>)
+SYMBOL(ostreambuf_iterator, std::, <iterator>)
+SYMBOL(ostreambuf_iterator, std::, <iosfwd>)
+SYMBOL(ostringstream, std::, <sstream>)
+SYMBOL(ostringstream, std::, <iosfwd>)
+SYMBOL(ostrstream, std::, <strstream>)
+SYMBOL(osyncstream, std::, <syncstream>)
+SYMBOL(osyncstream, std::, <iosfwd>)
+SYMBOL(out_of_range, std::, <stdexcept>)
+SYMBOL(out_ptr, std::, <memory>)
+SYMBOL(out_ptr_t, std::, <memory>)
+SYMBOL(output_iterator, std::, <iterator>)
+SYMBOL(output_iterator_tag, std::, <iterator>)
+SYMBOL(overflow_error, std::, <stdexcept>)
+SYMBOL(owner_less, std::, <memory>)
+SYMBOL(packaged_task, std::, <future>)
+SYMBOL(pair, std::, <utility>)
+SYMBOL(partial_order, std::, <compare>)
+SYMBOL(partial_ordering, std::, <compare>)
+SYMBOL(partial_sort, std::, <algorithm>)
+SYMBOL(partial_sort_copy, std::, <algorithm>)
+SYMBOL(partial_sum, std::, <numeric>)
+SYMBOL(partition, std::, <algorithm>)
+SYMBOL(partition_copy, std::, <algorithm>)
+SYMBOL(partition_point, std::, <algorithm>)
+SYMBOL(permutable, std::, <iterator>)
+SYMBOL(perror, std::, <cstdio>)
+SYMBOL(perror, None, <cstdio>)
+SYMBOL(perror, None, <stdio.h>)
+SYMBOL(peta, std::, <ratio>)
+SYMBOL(pico, std::, <ratio>)
+SYMBOL(piecewise_constant_distribution, std::, <random>)
+SYMBOL(piecewise_construct, std::, <utility>)
+SYMBOL(piecewise_construct_t, std::, <utility>)
+SYMBOL(piecewise_linear_distribution, std::, <random>)
+SYMBOL(plus, std::, <functional>)
+SYMBOL(pointer_safety, std::, <memory>)
+SYMBOL(pointer_traits, std::, <memory>)
+SYMBOL(poisson_distribution, std::, <random>)
+SYMBOL(polar, std::, <complex>)
+SYMBOL(pop_heap, std::, <algorithm>)
+SYMBOL(popcount, std::, <bit>)
+SYMBOL(pow, std::, <cmath>)
+SYMBOL(pow, None, <cmath>)
+SYMBOL(pow, None, <math.h>)
+SYMBOL(powf, std::, <cmath>)
+SYMBOL(powf, None, <cmath>)
+SYMBOL(powf, None, <math.h>)
+SYMBOL(powl, std::, <cmath>)
+SYMBOL(powl, None, <cmath>)
+SYMBOL(powl, None, <math.h>)
+SYMBOL(predicate, std::, <concepts>)
+SYMBOL(preferred, std::, <memory>)
+SYMBOL(prev, std::, <iterator>)
+SYMBOL(prev_permutation, std::, <algorithm>)
+SYMBOL(printf, std::, <cstdio>)
+SYMBOL(printf, None, <cstdio>)
+SYMBOL(printf, None, <stdio.h>)
+SYMBOL(priority_queue, std::, <queue>)
+SYMBOL(proj, std::, <complex>)
+SYMBOL(projected, std::, <iterator>)
+SYMBOL(promise, std::, <future>)
+SYMBOL(ptr_fun, std::, <functional>)
+SYMBOL(ptrdiff_t, std::, <cstddef>)
+SYMBOL(ptrdiff_t, None, <cstddef>)
+SYMBOL(ptrdiff_t, None, <stddef.h>)
+SYMBOL(push_heap, std::, <algorithm>)
+SYMBOL(put_money, std::, <iomanip>)
+SYMBOL(put_time, std::, <iomanip>)
+SYMBOL(putc, std::, <cstdio>)
+SYMBOL(putc, None, <cstdio>)
+SYMBOL(putc, None, <stdio.h>)
+SYMBOL(putchar, std::, <cstdio>)
+SYMBOL(putchar, None, <cstdio>)
+SYMBOL(putchar, None, <stdio.h>)
+SYMBOL(puts, std::, <cstdio>)
+SYMBOL(puts, None, <cstdio>)
+SYMBOL(puts, None, <stdio.h>)
+SYMBOL(putwc, std::, <cwchar>)
+SYMBOL(putwc, None, <cwchar>)
+SYMBOL(putwc, None, <wchar.h>)
+SYMBOL(putwchar, std::, <cwchar>)
+SYMBOL(putwchar, None, <cwchar>)
+SYMBOL(putwchar, None, <wchar.h>)
+SYMBOL(qsort, std::, <cstdlib>)
+SYMBOL(qsort, None, <cstdlib>)
+SYMBOL(qsort, None, <stdlib.h>)
+SYMBOL(queue, std::, <queue>)
+SYMBOL(quick_exit, std::, <cstdlib>)
+SYMBOL(quick_exit, None, <cstdlib>)
+SYMBOL(quick_exit, None, <stdlib.h>)
+SYMBOL(quoted, std::, <iomanip>)
+SYMBOL(raise, std::, <csignal>)
+SYMBOL(raise, None, <csignal>)
+SYMBOL(raise, None, <signal.h>)
+SYMBOL(rand, std::, <cstdlib>)
+SYMBOL(rand, None, <cstdlib>)
+SYMBOL(rand, None, <stdlib.h>)
+SYMBOL(random_access_iterator, std::, <iterator>)
+SYMBOL(random_access_iterator_tag, std::, <iterator>)
+SYMBOL(random_device, std::, <random>)
+SYMBOL(random_shuffle, std::, <algorithm>)
+SYMBOL(range_error, std::, <stdexcept>)
+SYMBOL(rank, std::, <type_traits>)
+SYMBOL(rank_v, std::, <type_traits>)
+SYMBOL(ranlux24, std::, <random>)
+SYMBOL(ranlux24_base, std::, <random>)
+SYMBOL(ranlux48, std::, <random>)
+SYMBOL(ranlux48_base, std::, <random>)
+SYMBOL(ratio, std::, <ratio>)
+SYMBOL(ratio_add, std::, <ratio>)
+SYMBOL(ratio_divide, std::, <ratio>)
+SYMBOL(ratio_equal, std::, <ratio>)
+SYMBOL(ratio_equal_v, std::, <ratio>)
+SYMBOL(ratio_greater, std::, <ratio>)
+SYMBOL(ratio_greater_equal, std::, <ratio>)
+SYMBOL(ratio_greater_equal_v, std::, <ratio>)
+SYMBOL(ratio_greater_v, std::, <ratio>)
+SYMBOL(ratio_less, std::, <ratio>)
+SYMBOL(ratio_less_equal, std::, <ratio>)
+SYMBOL(ratio_less_equal_v, std::, <ratio>)
+SYMBOL(ratio_less_v, std::, <ratio>)
+SYMBOL(ratio_multiply, std::, <ratio>)
+SYMBOL(ratio_not_equal, std::, <ratio>)
+SYMBOL(ratio_not_equal_v, std::, <ratio>)
+SYMBOL(ratio_subtract, std::, <ratio>)
+SYMBOL(raw_storage_iterator, std::, <memory>)
+SYMBOL(real, std::, <complex>)
+SYMBOL(realloc, std::, <cstdlib>)
+SYMBOL(realloc, None, <cstdlib>)
+SYMBOL(realloc, None, <stdlib.h>)
+SYMBOL(recursive_mutex, std::, <mutex>)
+SYMBOL(recursive_timed_mutex, std::, <mutex>)
+SYMBOL(reduce, std::, <numeric>)
+SYMBOL(ref, std::, <functional>)
+SYMBOL(reference_wrapper, std::, <functional>)
+SYMBOL(regex, std::, <regex>)
+SYMBOL(regex_error, std::, <regex>)
+SYMBOL(regex_iterator, std::, <regex>)
+SYMBOL(regex_match, std::, <regex>)
+SYMBOL(regex_replace, std::, <regex>)
+SYMBOL(regex_search, std::, <regex>)
+SYMBOL(regex_token_iterator, std::, <regex>)
+SYMBOL(regex_traits, std::, <regex>)
+SYMBOL(regular, std::, <concepts>)
+SYMBOL(regular_invocable, std::, <concepts>)
+SYMBOL(reinterpret_pointer_cast, std::, <memory>)
+SYMBOL(relation, std::, <concepts>)
+SYMBOL(remainder, std::, <cmath>)
+SYMBOL(remainder, None, <cmath>)
+SYMBOL(remainder, None, <math.h>)
+SYMBOL(remainderf, std::, <cmath>)
+SYMBOL(remainderf, None, <cmath>)
+SYMBOL(remainderf, None, <math.h>)
+SYMBOL(remainderl, std::, <cmath>)
+SYMBOL(remainderl, None, <cmath>)
+SYMBOL(remainderl, None, <math.h>)
+SYMBOL(remove_all_extents, std::, <type_traits>)
+SYMBOL(remove_all_extents_t, std::, <type_traits>)
+SYMBOL(remove_const, std::, <type_traits>)
+SYMBOL(remove_const_t, std::, <type_traits>)
+SYMBOL(remove_copy, std::, <algorithm>)
+SYMBOL(remove_copy_if, std::, <algorithm>)
+SYMBOL(remove_cv, std::, <type_traits>)
+SYMBOL(remove_cv_t, std::, <type_traits>)
+SYMBOL(remove_cvref, std::, <type_traits>)
+SYMBOL(remove_cvref_t, std::, <type_traits>)
+SYMBOL(remove_extent, std::, <type_traits>)
+SYMBOL(remove_extent_t, std::, <type_traits>)
+SYMBOL(remove_if, std::, <algorithm>)
+SYMBOL(remove_pointer, std::, <type_traits>)
+SYMBOL(remove_pointer_t, std::, <type_traits>)
+SYMBOL(remove_reference, std::, <type_traits>)
+SYMBOL(remove_reference_t, std::, <type_traits>)
+SYMBOL(remove_volatile, std::, <type_traits>)
+SYMBOL(remove_volatile_t, std::, <type_traits>)
+SYMBOL(remquo, std::, <cmath>)
+SYMBOL(remquo, None, <cmath>)
+SYMBOL(remquo, None, <math.h>)
+SYMBOL(remquof, std::, <cmath>)
+SYMBOL(remquof, None, <cmath>)
+SYMBOL(remquof, None, <math.h>)
+SYMBOL(remquol, std::, <cmath>)
+SYMBOL(remquol, None, <cmath>)
+SYMBOL(remquol, None, <math.h>)
+SYMBOL(rename, std::, <cstdio>)
+SYMBOL(rename, None, <cstdio>)
+SYMBOL(rename, None, <stdio.h>)
+SYMBOL(replace, std::, <algorithm>)
+SYMBOL(replace_copy, std::, <algorithm>)
+SYMBOL(replace_copy_if, std::, <algorithm>)
+SYMBOL(replace_if, std::, <algorithm>)
+SYMBOL(resetiosflags, std::, <iomanip>)
+SYMBOL(result_of, std::, <type_traits>)
+SYMBOL(result_of_t, std::, <type_traits>)
+SYMBOL(rethrow_exception, std::, <exception>)
+SYMBOL(rethrow_if_nested, std::, <exception>)
+SYMBOL(return_temporary_buffer, std::, <memory>)
+SYMBOL(reverse, std::, <algorithm>)
+SYMBOL(reverse_copy, std::, <algorithm>)
+SYMBOL(reverse_iterator, std::, <iterator>)
+SYMBOL(rewind, std::, <cstdio>)
+SYMBOL(rewind, None, <cstdio>)
+SYMBOL(rewind, None, <stdio.h>)
+SYMBOL(riemann_zeta, std::, <cmath>)
+SYMBOL(riemann_zetaf, std::, <cmath>)
+SYMBOL(riemann_zetal, std::, <cmath>)
+SYMBOL(right, std::, <ios>)
+SYMBOL(right, std::, <iostream>)
+SYMBOL(rint, std::, <cmath>)
+SYMBOL(rint, None, <cmath>)
+SYMBOL(rint, None, <math.h>)
+SYMBOL(rintf, std::, <cmath>)
+SYMBOL(rintf, None, <cmath>)
+SYMBOL(rintf, None, <math.h>)
+SYMBOL(rintl, std::, <cmath>)
+SYMBOL(rintl, None, <cmath>)
+SYMBOL(rintl, None, <math.h>)
+SYMBOL(rotate, std::, <algorithm>)
+SYMBOL(rotate_copy, std::, <algorithm>)
+SYMBOL(rotl, std::, <bit>)
+SYMBOL(rotr, std::, <bit>)
+SYMBOL(round, std::, <cmath>)
+SYMBOL(round, None, <cmath>)
+SYMBOL(round, None, <math.h>)
+SYMBOL(round_indeterminate, std::, <limits>)
+SYMBOL(round_to_nearest, std::, <limits>)
+SYMBOL(round_toward_infinity, std::, <limits>)
+SYMBOL(round_toward_neg_infinity, std::, <limits>)
+SYMBOL(round_toward_zero, std::, <limits>)
+SYMBOL(roundf, std::, <cmath>)
+SYMBOL(roundf, None, <cmath>)
+SYMBOL(roundf, None, <math.h>)
+SYMBOL(roundl, std::, <cmath>)
+SYMBOL(roundl, None, <cmath>)
+SYMBOL(roundl, None, <math.h>)
+SYMBOL(runtime_error, std::, <stdexcept>)
+SYMBOL(same_as, std::, <concepts>)
+SYMBOL(sample, std::, <algorithm>)
+SYMBOL(scalbln, std::, <cmath>)
+SYMBOL(scalbln, None, <cmath>)
+SYMBOL(scalbln, None, <math.h>)
+SYMBOL(scalblnf, std::, <cmath>)
+SYMBOL(scalblnf, None, <cmath>)
+SYMBOL(scalblnf, None, <math.h>)
+SYMBOL(scalblnl, std::, <cmath>)
+SYMBOL(scalblnl, None, <cmath>)
+SYMBOL(scalblnl, None, <math.h>)
+SYMBOL(scalbn, std::, <cmath>)
+SYMBOL(scalbn, None, <cmath>)
+SYMBOL(scalbn, None, <math.h>)
+SYMBOL(scalbnf, std::, <cmath>)
+SYMBOL(scalbnf, None, <cmath>)
+SYMBOL(scalbnf, None, <math.h>)
+SYMBOL(scalbnl, std::, <cmath>)
+SYMBOL(scalbnl, None, <cmath>)
+SYMBOL(scalbnl, None, <math.h>)
+SYMBOL(scanf, std::, <cstdio>)
+SYMBOL(scanf, None, <cstdio>)
+SYMBOL(scanf, None, <stdio.h>)
+SYMBOL(scientific, std::, <ios>)
+SYMBOL(scientific, std::, <iostream>)
+SYMBOL(scoped_allocator_adaptor, std::, <scoped_allocator>)
+SYMBOL(scoped_lock, std::, <mutex>)
+SYMBOL(search, std::, <algorithm>)
+SYMBOL(search_n, std::, <algorithm>)
+SYMBOL(seed_seq, std::, <random>)
+SYMBOL(seek_dir, std::, <ios>)
+SYMBOL(seek_dir, std::, <iostream>)
+SYMBOL(semiregular, std::, <concepts>)
+SYMBOL(sentinel_for, std::, <iterator>)
+SYMBOL(set, std::, <set>)
+SYMBOL(set_difference, std::, <algorithm>)
+SYMBOL(set_intersection, std::, <algorithm>)
+SYMBOL(set_new_handler, std::, <new>)
+SYMBOL(set_symmetric_difference, std::, <algorithm>)
+SYMBOL(set_terminate, std::, <exception>)
+SYMBOL(set_unexpected, std::, <exception>)
+SYMBOL(set_union, std::, <algorithm>)
+SYMBOL(setbase, std::, <iomanip>)
+SYMBOL(setbuf, std::, <cstdio>)
+SYMBOL(setbuf, None, <cstdio>)
+SYMBOL(setbuf, None, <stdio.h>)
+SYMBOL(setfill, std::, <iomanip>)
+SYMBOL(setiosflags, std::, <iomanip>)
+SYMBOL(setlocale, std::, <clocale>)
+SYMBOL(setlocale, None, <clocale>)
+SYMBOL(setlocale, None, <locale.h>)
+SYMBOL(setprecision, std::, <iomanip>)
+SYMBOL(setvbuf, std::, <cstdio>)
+SYMBOL(setvbuf, None, <cstdio>)
+SYMBOL(setvbuf, None, <stdio.h>)
+SYMBOL(setw, std::, <iomanip>)
+SYMBOL(shared_future, std::, <future>)
+SYMBOL(shared_lock, std::, <shared_mutex>)
+SYMBOL(shared_mutex, std::, <shared_mutex>)
+SYMBOL(shared_ptr, std::, <memory>)
+SYMBOL(shared_timed_mutex, std::, <shared_mutex>)
+SYMBOL(shift_left, std::, <algorithm>)
+SYMBOL(shift_right, std::, <algorithm>)
+SYMBOL(showbase, std::, <ios>)
+SYMBOL(showbase, std::, <iostream>)
+SYMBOL(showpoint, std::, <ios>)
+SYMBOL(showpoint, std::, <iostream>)
+SYMBOL(showpos, std::, <ios>)
+SYMBOL(showpos, std::, <iostream>)
+SYMBOL(shuffle, std::, <algorithm>)
+SYMBOL(shuffle_order_engine, std::, <random>)
+SYMBOL(sig_atomic_t, std::, <csignal>)
+SYMBOL(sig_atomic_t, None, <csignal>)
+SYMBOL(sig_atomic_t, None, <signal.h>)
+SYMBOL(signal, std::, <csignal>)
+SYMBOL(signal, None, <csignal>)
+SYMBOL(signal, None, <signal.h>)
+SYMBOL(signbit, std::, <cmath>)
+SYMBOL(signbit, None, <cmath>)
+SYMBOL(signbit, None, <math.h>)
+SYMBOL(signed_integral, std::, <concepts>)
+SYMBOL(sin, std::, <cmath>)
+SYMBOL(sin, None, <cmath>)
+SYMBOL(sin, None, <math.h>)
+SYMBOL(sinf, std::, <cmath>)
+SYMBOL(sinf, None, <cmath>)
+SYMBOL(sinf, None, <math.h>)
+SYMBOL(sinh, std::, <cmath>)
+SYMBOL(sinh, None, <cmath>)
+SYMBOL(sinh, None, <math.h>)
+SYMBOL(sinhf, std::, <cmath>)
+SYMBOL(sinhf, None, <cmath>)
+SYMBOL(sinhf, None, <math.h>)
+SYMBOL(sinhl, std::, <cmath>)
+SYMBOL(sinhl, None, <cmath>)
+SYMBOL(sinhl, None, <math.h>)
+SYMBOL(sinl, std::, <cmath>)
+SYMBOL(sinl, None, <cmath>)
+SYMBOL(sinl, None, <math.h>)
+SYMBOL(sized_sentinel_for, std::, <iterator>)
+SYMBOL(skipws, std::, <ios>)
+SYMBOL(skipws, std::, <iostream>)
+SYMBOL(slice, std::, <valarray>)
+SYMBOL(slice_array, std::, <valarray>)
+SYMBOL(smatch, std::, <regex>)
+SYMBOL(snprintf, std::, <cstdio>)
+SYMBOL(snprintf, None, <cstdio>)
+SYMBOL(snprintf, None, <stdio.h>)
+SYMBOL(sort, std::, <algorithm>)
+SYMBOL(sort_heap, std::, <algorithm>)
+SYMBOL(sortable, std::, <iterator>)
+SYMBOL(source_location, std::, <source_location>)
+SYMBOL(span, std::, <span>)
+SYMBOL(spanbuf, std::, <spanstream>)
+SYMBOL(spanbuf, std::, <iosfwd>)
+SYMBOL(spanstream, std::, <spanstream>)
+SYMBOL(spanstream, std::, <iosfwd>)
+SYMBOL(sph_bessel, std::, <cmath>)
+SYMBOL(sph_bessel, None, <cmath>)
+SYMBOL(sph_bessel, None, <math.h>)
+SYMBOL(sph_besself, std::, <cmath>)
+SYMBOL(sph_besself, None, <cmath>)
+SYMBOL(sph_besself, None, <math.h>)
+SYMBOL(sph_bessell, std::, <cmath>)
+SYMBOL(sph_bessell, None, <cmath>)
+SYMBOL(sph_bessell, None, <math.h>)
+SYMBOL(sph_legendre, std::, <cmath>)
+SYMBOL(sph_legendref, std::, <cmath>)
+SYMBOL(sph_legendrel, std::, <cmath>)
+SYMBOL(sph_neumann, std::, <cmath>)
+SYMBOL(sph_neumannf, std::, <cmath>)
+SYMBOL(sph_neumannl, std::, <cmath>)
+SYMBOL(sprintf, std::, <cstdio>)
+SYMBOL(sprintf, None, <cstdio>)
+SYMBOL(sprintf, None, <stdio.h>)
+SYMBOL(sqrt, std::, <cmath>)
+SYMBOL(sqrt, None, <cmath>)
+SYMBOL(sqrt, None, <math.h>)
+SYMBOL(sqrtf, std::, <cmath>)
+SYMBOL(sqrtf, None, <cmath>)
+SYMBOL(sqrtf, None, <math.h>)
+SYMBOL(sqrtl, std::, <cmath>)
+SYMBOL(sqrtl, None, <cmath>)
+SYMBOL(sqrtl, None, <math.h>)
+SYMBOL(srand, std::, <cstdlib>)
+SYMBOL(srand, None, <cstdlib>)
+SYMBOL(srand, None, <stdlib.h>)
+SYMBOL(sregex_iterator, std::, <regex>)
+SYMBOL(sregex_token_iterator, std::, <regex>)
+SYMBOL(sscanf, std::, <cstdio>)
+SYMBOL(sscanf, None, <cstdio>)
+SYMBOL(sscanf, None, <stdio.h>)
+SYMBOL(ssub_match, std::, <regex>)
+SYMBOL(stable_partition, std::, <algorithm>)
+SYMBOL(stable_sort, std::, <algorithm>)
+SYMBOL(stack, std::, <stack>)
+SYMBOL(stacktrace, std::, <stacktrace>)
+SYMBOL(stacktrace_entry, std::, <stacktrace>)
+SYMBOL(static_pointer_cast, std::, <memory>)
+SYMBOL(stod, std::, <string>)
+SYMBOL(stof, std::, <string>)
+SYMBOL(stoi, std::, <string>)
+SYMBOL(stol, std::, <string>)
+SYMBOL(stold, std::, <string>)
+SYMBOL(stoll, std::, <string>)
+SYMBOL(stop_callback, std::, <stop_token>)
+SYMBOL(stop_source, std::, <stop_token>)
+SYMBOL(stop_token, std::, <stop_token>)
+SYMBOL(stoul, std::, <string>)
+SYMBOL(stoull, std::, <string>)
+SYMBOL(strcat, std::, <cstring>)
+SYMBOL(strcat, None, <cstring>)
+SYMBOL(strcat, None, <string.h>)
+SYMBOL(strchr, std::, <cstring>)
+SYMBOL(strchr, None, <cstring>)
+SYMBOL(strchr, None, <string.h>)
+SYMBOL(strcmp, std::, <cstring>)
+SYMBOL(strcmp, None, <cstring>)
+SYMBOL(strcmp, None, <string.h>)
+SYMBOL(strcoll, std::, <cstring>)
+SYMBOL(strcoll, None, <cstring>)
+SYMBOL(strcoll, None, <string.h>)
+SYMBOL(strcpy, std::, <cstring>)
+SYMBOL(strcpy, None, <cstring>)
+SYMBOL(strcpy, None, <string.h>)
+SYMBOL(strcspn, std::, <cstring>)
+SYMBOL(strcspn, None, <cstring>)
+SYMBOL(strcspn, None, <string.h>)
+SYMBOL(streambuf, std::, <streambuf>)
+SYMBOL(streambuf, std::, <iostream>)
+SYMBOL(streambuf, std::, <iosfwd>)
+SYMBOL(streamoff, std::, <ios>)
+SYMBOL(streamoff, std::, <iostream>)
+SYMBOL(streampos, std::, <iosfwd>)
+SYMBOL(streampos, std::, <iosfwd>)
+SYMBOL(streamsize, std::, <ios>)
+SYMBOL(streamsize, std::, <iostream>)
+SYMBOL(strerror, std::, <cstring>)
+SYMBOL(strerror, None, <cstring>)
+SYMBOL(strerror, None, <string.h>)
+SYMBOL(strftime, std::, <ctime>)
+SYMBOL(strftime, None, <ctime>)
+SYMBOL(strftime, None, <time.h>)
+SYMBOL(strict, std::, <memory>)
+SYMBOL(strict_weak_order, std::, <concepts>)
+SYMBOL(string, std::, <string>)
+SYMBOL(string_view, std::, <string_view>)
+SYMBOL(stringbuf, std::, <sstream>)
+SYMBOL(stringbuf, std::, <iosfwd>)
+SYMBOL(stringstream, std::, <sstream>)
+SYMBOL(stringstream, std::, <iosfwd>)
+SYMBOL(strlen, std::, <cstring>)
+SYMBOL(strlen, None, <cstring>)
+SYMBOL(strlen, None, <string.h>)
+SYMBOL(strncat, std::, <cstring>)
+SYMBOL(strncat, None, <cstring>)
+SYMBOL(strncat, None, <string.h>)
+SYMBOL(strncmp, std::, <cstring>)
+SYMBOL(strncmp, None, <cstring>)
+SYMBOL(strncmp, None, <string.h>)
+SYMBOL(strncpy, std::, <cstring>)
+SYMBOL(strncpy, None, <cstring>)
+SYMBOL(strncpy, None, <string.h>)
+SYMBOL(strong_order, std::, <compare>)
+SYMBOL(strong_ordering, std::, <compare>)
+SYMBOL(strpbrk, std::, <cstring>)
+SYMBOL(strpbrk, None, <cstring>)
+SYMBOL(strpbrk, None, <string.h>)
+SYMBOL(strrchr, std::, <cstring>)
+SYMBOL(strrchr, None, <cstring>)
+SYMBOL(strrchr, None, <string.h>)
+SYMBOL(strspn, std::, <cstring>)
+SYMBOL(strspn, None, <cstring>)
+SYMBOL(strspn, None, <string.h>)
+SYMBOL(strstr, std::, <cstring>)
+SYMBOL(strstr, None, <cstring>)
+SYMBOL(strstr, None, <string.h>)
+SYMBOL(strstream, std::, <strstream>)
+SYMBOL(strstreambuf, std::, <strstream>)
+SYMBOL(strtod, std::, <cstdlib>)
+SYMBOL(strtod, None, <cstdlib>)
+SYMBOL(strtod, None, <stdlib.h>)
+SYMBOL(strtof, std::, <cstdlib>)
+SYMBOL(strtof, None, <cstdlib>)
+SYMBOL(strtof, None, <stdlib.h>)
+SYMBOL(strtoimax, std::, <cinttypes>)
+SYMBOL(strtoimax, None, <cinttypes>)
+SYMBOL(strtoimax, None, <inttypes.h>)
+SYMBOL(strtok, std::, <cstring>)
+SYMBOL(strtok, None, <cstring>)
+SYMBOL(strtok, None, <string.h>)
+SYMBOL(strtol, std::, <cstdlib>)
+SYMBOL(strtol, None, <cstdlib>)
+SYMBOL(strtol, None, <stdlib.h>)
+SYMBOL(strtold, std::, <cstdlib>)
+SYMBOL(strtold, None, <cstdlib>)
+SYMBOL(strtold, None, <stdlib.h>)
+SYMBOL(strtoll, std::, <cstdlib>)
+SYMBOL(strtoll, None, <cstdlib>)
+SYMBOL(strtoll, None, <stdlib.h>)
+SYMBOL(strtoul, std::, <cstdlib>)
+SYMBOL(strtoul, None, <cstdlib>)
+SYMBOL(strtoul, None, <stdlib.h>)
+SYMBOL(strtoull, std::, <cstdlib>)
+SYMBOL(strtoull, None, <cstdlib>)
+SYMBOL(strtoull, None, <stdlib.h>)
+SYMBOL(strtoumax, std::, <cinttypes>)
+SYMBOL(strtoumax, None, <cinttypes>)
+SYMBOL(strtoumax, None, <inttypes.h>)
+SYMBOL(strxfrm, std::, <cstring>)
+SYMBOL(strxfrm, None, <cstring>)
+SYMBOL(strxfrm, None, <string.h>)
+SYMBOL(student_t_distribution, std::, <random>)
+SYMBOL(sub_match, std::, <regex>)
+SYMBOL(subtract_with_carry_engine, std::, <random>)
+SYMBOL(suspend_always, std::, <coroutine>)
+SYMBOL(suspend_never, std::, <coroutine>)
+SYMBOL(swap_ranges, std::, <algorithm>)
+SYMBOL(swappable, std::, <concepts>)
+SYMBOL(swappable_with, std::, <concepts>)
+SYMBOL(swprintf, std::, <cwchar>)
+SYMBOL(swprintf, None, <cwchar>)
+SYMBOL(swprintf, None, <wchar.h>)
+SYMBOL(swscanf, std::, <cwchar>)
+SYMBOL(swscanf, None, <cwchar>)
+SYMBOL(swscanf, None, <wchar.h>)
+SYMBOL(syncbuf, std::, <syncstream>)
+SYMBOL(syncbuf, std::, <iosfwd>)
+SYMBOL(system, std::, <cstdlib>)
+SYMBOL(system, None, <cstdlib>)
+SYMBOL(system, None, <stdlib.h>)
+SYMBOL(system_category, std::, <system_error>)
+SYMBOL(system_error, std::, <system_error>)
+SYMBOL(tan, std::, <cmath>)
+SYMBOL(tan, None, <cmath>)
+SYMBOL(tan, None, <math.h>)
+SYMBOL(tanf, std::, <cmath>)
+SYMBOL(tanf, None, <cmath>)
+SYMBOL(tanf, None, <math.h>)
+SYMBOL(tanh, std::, <cmath>)
+SYMBOL(tanh, None, <cmath>)
+SYMBOL(tanh, None, <math.h>)
+SYMBOL(tanhf, std::, <cmath>)
+SYMBOL(tanhf, None, <cmath>)
+SYMBOL(tanhf, None, <math.h>)
+SYMBOL(tanhl, std::, <cmath>)
+SYMBOL(tanhl, None, <cmath>)
+SYMBOL(tanhl, None, <math.h>)
+SYMBOL(tanl, std::, <cmath>)
+SYMBOL(tanl, None, <cmath>)
+SYMBOL(tanl, None, <math.h>)
+SYMBOL(tera, std::, <ratio>)
+SYMBOL(terminate, std::, <exception>)
+SYMBOL(terminate_handler, std::, <exception>)
+SYMBOL(tgamma, std::, <cmath>)
+SYMBOL(tgamma, None, <cmath>)
+SYMBOL(tgamma, None, <math.h>)
+SYMBOL(tgammaf, std::, <cmath>)
+SYMBOL(tgammaf, None, <cmath>)
+SYMBOL(tgammaf, None, <math.h>)
+SYMBOL(tgammal, std::, <cmath>)
+SYMBOL(tgammal, None, <cmath>)
+SYMBOL(tgammal, None, <math.h>)
+SYMBOL(thread, std::, <thread>)
+SYMBOL(three_way_comparable, std::, <compare>)
+SYMBOL(three_way_comparable_with, std::, <compare>)
+SYMBOL(throw_with_nested, std::, <exception>)
+SYMBOL(tie, std::, <tuple>)
+SYMBOL(time, std::, <ctime>)
+SYMBOL(time, None, <ctime>)
+SYMBOL(time, None, <time.h>)
+SYMBOL(time_base, std::, <locale>)
+SYMBOL(time_get, std::, <locale>)
+SYMBOL(time_get_byname, std::, <locale>)
+SYMBOL(time_put, std::, <locale>)
+SYMBOL(time_put_byname, std::, <locale>)
+SYMBOL(time_t, std::, <ctime>)
+SYMBOL(time_t, None, <ctime>)
+SYMBOL(time_t, None, <time.h>)
+SYMBOL(timed_mutex, std::, <mutex>)
+SYMBOL(timespec, std::, <ctime>)
+SYMBOL(timespec, None, <ctime>)
+SYMBOL(timespec, None, <time.h>)
+SYMBOL(timespec_get, std::, <ctime>)
+SYMBOL(timespec_get, None, <ctime>)
+SYMBOL(timespec_get, None, <time.h>)
+SYMBOL(tm, std::, <ctime>)
+SYMBOL(tm, None, <ctime>)
+SYMBOL(tm, None, <time.h>)
+SYMBOL(tmpfile, std::, <cstdio>)
+SYMBOL(tmpfile, None, <cstdio>)
+SYMBOL(tmpfile, None, <stdio.h>)
+SYMBOL(tmpnam, std::, <cstdio>)
+SYMBOL(tmpnam, None, <cstdio>)
+SYMBOL(tmpnam, None, <stdio.h>)
+SYMBOL(to_address, std::, <memory>)
+SYMBOL(to_array, std::, <array>)
+SYMBOL(to_chars, std::, <charconv>)
+SYMBOL(to_chars_result, std::, <charconv>)
+SYMBOL(to_integer, std::, <cstddef>)
+SYMBOL(to_integer, None, <cstddef>)
+SYMBOL(to_integer, None, <stddef.h>)
+SYMBOL(to_string, std::, <string>)
+SYMBOL(to_underlying, std::, <utility>)
+SYMBOL(to_wstring, std::, <string>)
+SYMBOL(tolower, std::, <cctype>)
+SYMBOL(tolower, None, <cctype>)
+SYMBOL(tolower, None, <ctype.h>)
+SYMBOL(totally_ordered, std::, <concepts>)
+SYMBOL(totally_ordered_with, std::, <concepts>)
+SYMBOL(toupper, std::, <cctype>)
+SYMBOL(toupper, None, <cctype>)
+SYMBOL(toupper, None, <ctype.h>)
+SYMBOL(towctrans, std::, <cwctype>)
+SYMBOL(towctrans, None, <cwctype>)
+SYMBOL(towctrans, None, <wctype.h>)
+SYMBOL(towlower, std::, <cwctype>)
+SYMBOL(towlower, None, <cwctype>)
+SYMBOL(towlower, None, <wctype.h>)
+SYMBOL(towupper, std::, <cwctype>)
+SYMBOL(towupper, None, <cwctype>)
+SYMBOL(towupper, None, <wctype.h>)
+SYMBOL(transform, std::, <algorithm>)
+SYMBOL(transform_exclusive_scan, std::, <numeric>)
+SYMBOL(transform_inclusive_scan, std::, <numeric>)
+SYMBOL(transform_reduce, std::, <numeric>)
+SYMBOL(true_type, std::, <type_traits>)
+SYMBOL(trunc, std::, <cmath>)
+SYMBOL(trunc, None, <cmath>)
+SYMBOL(trunc, None, <math.h>)
+SYMBOL(truncf, std::, <cmath>)
+SYMBOL(truncf, None, <cmath>)
+SYMBOL(truncf, None, <math.h>)
+SYMBOL(truncl, std::, <cmath>)
+SYMBOL(truncl, None, <cmath>)
+SYMBOL(truncl, None, <math.h>)
+SYMBOL(try_lock, std::, <mutex>)
+SYMBOL(try_to_lock, std::, <mutex>)
+SYMBOL(try_to_lock_t, std::, <mutex>)
+SYMBOL(tuple, std::, <tuple>)
+SYMBOL(tuple_cat, std::, <tuple>)
+SYMBOL(tuple_element_t, std::, <tuple>)
+SYMBOL(tuple_size_v, std::, <tuple>)
+SYMBOL(type_identity, std::, <type_traits>)
+SYMBOL(type_identity_t, std::, <type_traits>)
+SYMBOL(type_index, std::, <typeindex>)
+SYMBOL(type_info, std::, <typeinfo>)
+SYMBOL(u16streampos, std::, <iosfwd>)
+SYMBOL(u16streampos, std::, <iosfwd>)
+SYMBOL(u16string, std::, <string>)
+SYMBOL(u16string_view, std::, <string_view>)
+SYMBOL(u32streampos, std::, <iosfwd>)
+SYMBOL(u32streampos, std::, <iosfwd>)
+SYMBOL(u32string, std::, <string>)
+SYMBOL(u32string_view, std::, <string_view>)
+SYMBOL(u8streampos, std::, <iosfwd>)
+SYMBOL(u8streampos, std::, <iosfwd>)
+SYMBOL(u8string, std::, <string>)
+SYMBOL(u8string_view, std::, <string_view>)
+SYMBOL(uint16_t, std::, <cstdint>)
+SYMBOL(uint16_t, None, <cstdint>)
+SYMBOL(uint16_t, None, <stdint.h>)
+SYMBOL(uint32_t, std::, <cstdint>)
+SYMBOL(uint32_t, None, <cstdint>)
+SYMBOL(uint32_t, None, <stdint.h>)
+SYMBOL(uint64_t, std::, <cstdint>)
+SYMBOL(uint64_t, None, <cstdint>)
+SYMBOL(uint64_t, None, <stdint.h>)
+SYMBOL(uint8_t, std::, <cstdint>)
+SYMBOL(uint8_t, None, <cstdint>)
+SYMBOL(uint8_t, None, <stdint.h>)
+SYMBOL(uint_fast16_t, std::, <cstdint>)
+SYMBOL(uint_fast16_t, None, <cstdint>)
+SYMBOL(uint_fast16_t, None, <stdint.h>)
+SYMBOL(uint_fast32_t, std::, <cstdint>)
+SYMBOL(uint_fast32_t, None, <cstdint>)
+SYMBOL(uint_fast32_t, None, <stdint.h>)
+SYMBOL(uint_fast64_t, std::, <cstdint>)
+SYMBOL(uint_fast64_t, None, <cstdint>)
+SYMBOL(uint_fast64_t, None, <stdint.h>)
+SYMBOL(uint_fast8_t, std::, <cstdint>)
+SYMBOL(uint_fast8_t, None, <cstdint>)
+SYMBOL(uint_fast8_t, None, <stdint.h>)
+SYMBOL(uint_least16_t, std::, <cstdint>)
+SYMBOL(uint_least16_t, None, <cstdint>)
+SYMBOL(uint_least16_t, None, <stdint.h>)
+SYMBOL(uint_least32_t, std::, <cstdint>)
+SYMBOL(uint_least32_t, None, <cstdint>)
+SYMBOL(uint_least32_t, None, <stdint.h>)
+SYMBOL(uint_least64_t, std::, <cstdint>)
+SYMBOL(uint_least64_t, None, <cstdint>)
+SYMBOL(uint_least64_t, None, <stdint.h>)
+SYMBOL(uint_least8_t, std::, <cstdint>)
+SYMBOL(uint_least8_t, None, <cstdint>)
+SYMBOL(uint_least8_t, None, <stdint.h>)
+SYMBOL(uintmax_t, std::, <cstdint>)
+SYMBOL(uintmax_t, None, <cstdint>)
+SYMBOL(uintmax_t, None, <stdint.h>)
+SYMBOL(uintptr_t, std::, <cstdint>)
+SYMBOL(uintptr_t, None, <cstdint>)
+SYMBOL(uintptr_t, None, <stdint.h>)
+SYMBOL(unary_function, std::, <functional>)
+SYMBOL(unary_negate, std::, <functional>)
+SYMBOL(uncaught_exception, std::, <exception>)
+SYMBOL(uncaught_exceptions, std::, <exception>)
+SYMBOL(undeclare_no_pointers, std::, <memory>)
+SYMBOL(undeclare_reachable, std::, <memory>)
+SYMBOL(underflow_error, std::, <stdexcept>)
+SYMBOL(underlying_type, std::, <type_traits>)
+SYMBOL(underlying_type_t, std::, <type_traits>)
+SYMBOL(unexpected_handler, std::, <exception>)
+SYMBOL(ungetc, std::, <cstdio>)
+SYMBOL(ungetc, None, <cstdio>)
+SYMBOL(ungetc, None, <stdio.h>)
+SYMBOL(ungetwc, std::, <cwchar>)
+SYMBOL(ungetwc, None, <cwchar>)
+SYMBOL(ungetwc, None, <wchar.h>)
+SYMBOL(uniform_int_distribution, std::, <random>)
+SYMBOL(uniform_random_bit_generator, std::, <random>)
+SYMBOL(uniform_real_distribution, std::, <random>)
+SYMBOL(uninitialized_construct_using_allocator, std::, <memory>)
+SYMBOL(uninitialized_copy, std::, <memory>)
+SYMBOL(uninitialized_copy_n, std::, <memory>)
+SYMBOL(uninitialized_default_construct, std::, <memory>)
+SYMBOL(uninitialized_default_construct_n, std::, <memory>)
+SYMBOL(uninitialized_fill, std::, <memory>)
+SYMBOL(uninitialized_fill_n, std::, <memory>)
+SYMBOL(uninitialized_move, std::, <memory>)
+SYMBOL(uninitialized_move_n, std::, <memory>)
+SYMBOL(uninitialized_value_construct, std::, <memory>)
+SYMBOL(uninitialized_value_construct_n, std::, <memory>)
+SYMBOL(unique, std::, <algorithm>)
+SYMBOL(unique_copy, std::, <algorithm>)
+SYMBOL(unique_lock, std::, <mutex>)
+SYMBOL(unique_ptr, std::, <memory>)
+SYMBOL(unitbuf, std::, <ios>)
+SYMBOL(unitbuf, std::, <iostream>)
+SYMBOL(unordered_map, std::, <unordered_map>)
+SYMBOL(unordered_multimap, std::, <unordered_map>)
+SYMBOL(unordered_multiset, std::, <unordered_set>)
+SYMBOL(unordered_set, std::, <unordered_set>)
+SYMBOL(unreachable, std::, <utility>)
+SYMBOL(unreachable_sentinel, std::, <iterator>)
+SYMBOL(unreachable_sentinel_t, std::, <iterator>)
+SYMBOL(unsigned_integral, std::, <concepts>)
+SYMBOL(upper_bound, std::, <algorithm>)
+SYMBOL(uppercase, std::, <ios>)
+SYMBOL(uppercase, std::, <iostream>)
+SYMBOL(use_facet, std::, <locale>)
+SYMBOL(uses_allocator, std::, <memory>)
+SYMBOL(uses_allocator_construction_args, std::, <memory>)
+SYMBOL(uses_allocator_v, std::, <memory>)
+SYMBOL(va_list, std::, <cstdarg>)
+SYMBOL(va_list, None, <cstdarg>)
+SYMBOL(va_list, None, <stdarg.h>)
+SYMBOL(valarray, std::, <valarray>)
+SYMBOL(variant, std::, <variant>)
+SYMBOL(variant_alternative, std::, <variant>)
+SYMBOL(variant_alternative_t, std::, <variant>)
+SYMBOL(variant_npos, std::, <variant>)
+SYMBOL(variant_size, std::, <variant>)
+SYMBOL(variant_size_v, std::, <variant>)
+SYMBOL(vector, std::, <vector>)
+SYMBOL(vformat, std::, <format>)
+SYMBOL(vformat_to, std::, <format>)
+SYMBOL(vfprintf, std::, <cstdio>)
+SYMBOL(vfprintf, None, <cstdio>)
+SYMBOL(vfprintf, None, <stdio.h>)
+SYMBOL(vfscanf, std::, <cstdio>)
+SYMBOL(vfscanf, None, <cstdio>)
+SYMBOL(vfscanf, None, <stdio.h>)
+SYMBOL(vfwprintf, std::, <cwchar>)
+SYMBOL(vfwprintf, None, <cwchar>)
+SYMBOL(vfwprintf, None, <wchar.h>)
+SYMBOL(vfwscanf, std::, <cwchar>)
+SYMBOL(vfwscanf, None, <cwchar>)
+SYMBOL(vfwscanf, None, <wchar.h>)
+SYMBOL(visit, std::, <variant>)
+SYMBOL(visit_format_arg, std::, <format>)
+SYMBOL(void_t, std::, <type_traits>)
+SYMBOL(vprintf, std::, <cstdio>)
+SYMBOL(vprintf, None, <cstdio>)
+SYMBOL(vprintf, None, <stdio.h>)
+SYMBOL(vscanf, std::, <cstdio>)
+SYMBOL(vscanf, None, <cstdio>)
+SYMBOL(vscanf, None, <stdio.h>)
+SYMBOL(vsnprintf, std::, <cstdio>)
+SYMBOL(vsnprintf, None, <cstdio>)
+SYMBOL(vsnprintf, None, <stdio.h>)
+SYMBOL(vsprintf, std::, <cstdio>)
+SYMBOL(vsprintf, None, <cstdio>)
+SYMBOL(vsprintf, None, <stdio.h>)
+SYMBOL(vsscanf, std::, <cstdio>)
+SYMBOL(vsscanf, None, <cstdio>)
+SYMBOL(vsscanf, None, <stdio.h>)
+SYMBOL(vswprintf, std::, <cwchar>)
+SYMBOL(vswprintf, None, <cwchar>)
+SYMBOL(vswprintf, None, <wchar.h>)
+SYMBOL(vswscanf, std::, <cwchar>)
+SYMBOL(vswscanf, None, <cwchar>)
+SYMBOL(vswscanf, None, <wchar.h>)
+SYMBOL(vwprintf, std::, <cwchar>)
+SYMBOL(vwprintf, None, <cwchar>)
+SYMBOL(vwprintf, None, <wchar.h>)
+SYMBOL(vwscanf, std::, <cwchar>)
+SYMBOL(vwscanf, None, <cwchar>)
+SYMBOL(vwscanf, None, <wchar.h>)
+SYMBOL(wbuffer_convert, std::, <locale>)
+SYMBOL(wcerr, std::, <iostream>)
+SYMBOL(wcin, std::, <iostream>)
+SYMBOL(wclog, std::, <iostream>)
+SYMBOL(wcmatch, std::, <regex>)
+SYMBOL(wcout, std::, <iostream>)
+SYMBOL(wcregex_iterator, std::, <regex>)
+SYMBOL(wcregex_token_iterator, std::, <regex>)
+SYMBOL(wcrtomb, std::, <cwchar>)
+SYMBOL(wcrtomb, None, <cwchar>)
+SYMBOL(wcrtomb, None, <wchar.h>)
+SYMBOL(wcscat, std::, <cwchar>)
+SYMBOL(wcscat, None, <cwchar>)
+SYMBOL(wcscat, None, <wchar.h>)
+SYMBOL(wcschr, std::, <cwchar>)
+SYMBOL(wcschr, None, <cwchar>)
+SYMBOL(wcschr, None, <wchar.h>)
+SYMBOL(wcscmp, std::, <cwchar>)
+SYMBOL(wcscmp, None, <cwchar>)
+SYMBOL(wcscmp, None, <wchar.h>)
+SYMBOL(wcscoll, std::, <cwchar>)
+SYMBOL(wcscoll, None, <cwchar>)
+SYMBOL(wcscoll, None, <wchar.h>)
+SYMBOL(wcscpy, std::, <cwchar>)
+SYMBOL(wcscpy, None, <cwchar>)
+SYMBOL(wcscpy, None, <wchar.h>)
+SYMBOL(wcscspn, std::, <cwchar>)
+SYMBOL(wcscspn, None, <cwchar>)
+SYMBOL(wcscspn, None, <wchar.h>)
+SYMBOL(wcsftime, std::, <cwchar>)
+SYMBOL(wcsftime, None, <cwchar>)
+SYMBOL(wcsftime, None, <wchar.h>)
+SYMBOL(wcslen, std::, <cwchar>)
+SYMBOL(wcslen, None, <cwchar>)
+SYMBOL(wcslen, None, <wchar.h>)
+SYMBOL(wcsncat, std::, <cwchar>)
+SYMBOL(wcsncat, None, <cwchar>)
+SYMBOL(wcsncat, None, <wchar.h>)
+SYMBOL(wcsncmp, std::, <cwchar>)
+SYMBOL(wcsncmp, None, <cwchar>)
+SYMBOL(wcsncmp, None, <wchar.h>)
+SYMBOL(wcsncpy, std::, <cwchar>)
+SYMBOL(wcsncpy, None, <cwchar>)
+SYMBOL(wcsncpy, None, <wchar.h>)
+SYMBOL(wcspbrk, std::, <cwchar>)
+SYMBOL(wcspbrk, None, <cwchar>)
+SYMBOL(wcspbrk, None, <wchar.h>)
+SYMBOL(wcsrchr, std::, <cwchar>)
+SYMBOL(wcsrchr, None, <cwchar>)
+SYMBOL(wcsrchr, None, <wchar.h>)
+SYMBOL(wcsrtombs, std::, <cwchar>)
+SYMBOL(wcsrtombs, None, <cwchar>)
+SYMBOL(wcsrtombs, None, <wchar.h>)
+SYMBOL(wcsspn, std::, <cwchar>)
+SYMBOL(wcsspn, None, <cwchar>)
+SYMBOL(wcsspn, None, <wchar.h>)
+SYMBOL(wcsstr, std::, <cwchar>)
+SYMBOL(wcsstr, None, <cwchar>)
+SYMBOL(wcsstr, None, <wchar.h>)
+SYMBOL(wcstod, std::, <cwchar>)
+SYMBOL(wcstod, None, <cwchar>)
+SYMBOL(wcstod, None, <wchar.h>)
+SYMBOL(wcstof, std::, <cwchar>)
+SYMBOL(wcstof, None, <cwchar>)
+SYMBOL(wcstof, None, <wchar.h>)
+SYMBOL(wcstoimax, std::, <cinttypes>)
+SYMBOL(wcstoimax, None, <cinttypes>)
+SYMBOL(wcstoimax, None, <inttypes.h>)
+SYMBOL(wcstok, std::, <cwchar>)
+SYMBOL(wcstok, None, <cwchar>)
+SYMBOL(wcstok, None, <wchar.h>)
+SYMBOL(wcstol, std::, <cwchar>)
+SYMBOL(wcstol, None, <cwchar>)
+SYMBOL(wcstol, None, <wchar.h>)
+SYMBOL(wcstold, std::, <cwchar>)
+SYMBOL(wcstold, None, <cwchar>)
+SYMBOL(wcstold, None, <wchar.h>)
+SYMBOL(wcstoll, std::, <cwchar>)
+SYMBOL(wcstoll, None, <cwchar>)
+SYMBOL(wcstoll, None, <wchar.h>)
+SYMBOL(wcstombs, std::, <cstdlib>)
+SYMBOL(wcstombs, None, <cstdlib>)
+SYMBOL(wcstombs, None, <stdlib.h>)
+SYMBOL(wcstoul, std::, <cwchar>)
+SYMBOL(wcstoul, None, <cwchar>)
+SYMBOL(wcstoul, None, <wchar.h>)
+SYMBOL(wcstoull, std::, <cwchar>)
+SYMBOL(wcstoull, None, <cwchar>)
+SYMBOL(wcstoull, None, <wchar.h>)
+SYMBOL(wcstoumax, std::, <cinttypes>)
+SYMBOL(wcstoumax, None, <cinttypes>)
+SYMBOL(wcstoumax, None, <inttypes.h>)
+SYMBOL(wcsub_match, std::, <regex>)
+SYMBOL(wcsxfrm, std::, <cwchar>)
+SYMBOL(wcsxfrm, None, <cwchar>)
+SYMBOL(wcsxfrm, None, <wchar.h>)
+SYMBOL(wctob, std::, <cwchar>)
+SYMBOL(wctob, None, <cwchar>)
+SYMBOL(wctob, None, <wchar.h>)
+SYMBOL(wctomb, std::, <cstdlib>)
+SYMBOL(wctomb, None, <cstdlib>)
+SYMBOL(wctomb, None, <stdlib.h>)
+SYMBOL(wctrans, std::, <cwctype>)
+SYMBOL(wctrans, None, <cwctype>)
+SYMBOL(wctrans, None, <wctype.h>)
+SYMBOL(wctrans_t, std::, <cwctype>)
+SYMBOL(wctrans_t, None, <cwctype>)
+SYMBOL(wctrans_t, None, <wctype.h>)
+SYMBOL(wctype, std::, <cwctype>)
+SYMBOL(wctype, None, <cwctype>)
+SYMBOL(wctype, None, <wctype.h>)
+SYMBOL(wctype_t, std::, <cwctype>)
+SYMBOL(wctype_t, None, <cwctype>)
+SYMBOL(wctype_t, None, <wctype.h>)
+SYMBOL(weak_order, std::, <compare>)
+SYMBOL(weak_ordering, std::, <compare>)
+SYMBOL(weak_ptr, std::, <memory>)
+SYMBOL(weakly_incrementable, std::, <iterator>)
+SYMBOL(weibull_distribution, std::, <random>)
+SYMBOL(wfilebuf, std::, <streambuf>)
+SYMBOL(wfilebuf, std::, <iostream>)
+SYMBOL(wfilebuf, std::, <iosfwd>)
+SYMBOL(wformat_args, std::, <format>)
+SYMBOL(wformat_context, std::, <format>)
+SYMBOL(wformat_parse_context, std::, <format>)
+SYMBOL(wfstream, std::, <fstream>)
+SYMBOL(wfstream, std::, <iosfwd>)
+SYMBOL(wifstream, std::, <fstream>)
+SYMBOL(wifstream, std::, <iosfwd>)
+SYMBOL(wios, std::, <ios>)
+SYMBOL(wios, std::, <iostream>)
+SYMBOL(wios, std::, <iosfwd>)
+SYMBOL(wiostream, std::, <istream>)
+SYMBOL(wiostream, std::, <iostream>)
+SYMBOL(wiostream, std::, <iosfwd>)
+SYMBOL(wispanstream, std::, <spanstream>)
+SYMBOL(wispanstream, std::, <iosfwd>)
+SYMBOL(wistream, std::, <istream>)
+SYMBOL(wistream, std::, <iostream>)
+SYMBOL(wistream, std::, <iosfwd>)
+SYMBOL(wistringstream, std::, <sstream>)
+SYMBOL(wistringstream, std::, <iosfwd>)
+SYMBOL(wmemchr, std::, <cwchar>)
+SYMBOL(wmemchr, None, <cwchar>)
+SYMBOL(wmemchr, None, <wchar.h>)
+SYMBOL(wmemcmp, std::, <cwchar>)
+SYMBOL(wmemcmp, None, <cwchar>)
+SYMBOL(wmemcmp, None, <wchar.h>)
+SYMBOL(wmemcpy, std::, <cwchar>)
+SYMBOL(wmemcpy, None, <cwchar>)
+SYMBOL(wmemcpy, None, <wchar.h>)
+SYMBOL(wmemmove, std::, <cwchar>)
+SYMBOL(wmemmove, None, <cwchar>)
+SYMBOL(wmemmove, None, <wchar.h>)
+SYMBOL(wmemset, std::, <cwchar>)
+SYMBOL(wmemset, None, <cwchar>)
+SYMBOL(wmemset, None, <wchar.h>)
+SYMBOL(wofstream, std::, <fstream>)
+SYMBOL(wofstream, std::, <iosfwd>)
+SYMBOL(wospanstream, std::, <spanstream>)
+SYMBOL(wospanstream, std::, <iosfwd>)
+SYMBOL(wostream, std::, <ostream>)
+SYMBOL(wostream, std::, <iostream>)
+SYMBOL(wostream, std::, <iosfwd>)
+SYMBOL(wostringstream, std::, <sstream>)
+SYMBOL(wostringstream, std::, <iosfwd>)
+SYMBOL(wosyncstream, std::, <syncstream>)
+SYMBOL(wosyncstream, std::, <iosfwd>)
+SYMBOL(wprintf, std::, <cwchar>)
+SYMBOL(wprintf, None, <cwchar>)
+SYMBOL(wprintf, None, <wchar.h>)
+SYMBOL(wregex, std::, <regex>)
+SYMBOL(ws, std::, <istream>)
+SYMBOL(ws, std::, <iostream>)
+SYMBOL(wscanf, std::, <cwchar>)
+SYMBOL(wscanf, None, <cwchar>)
+SYMBOL(wscanf, None, <wchar.h>)
+SYMBOL(wsmatch, std::, <regex>)
+SYMBOL(wspanbuf, std::, <spanstream>)
+SYMBOL(wspanbuf, std::, <iosfwd>)
+SYMBOL(wspanstream, std::, <spanstream>)
+SYMBOL(wspanstream, std::, <iosfwd>)
+SYMBOL(wsregex_iterator, std::, <regex>)
+SYMBOL(wsregex_token_iterator, std::, <regex>)
+SYMBOL(wssub_match, std::, <regex>)
+SYMBOL(wstreambuf, std::, <streambuf>)
+SYMBOL(wstreambuf, std::, <iostream>)
+SYMBOL(wstreambuf, std::, <iosfwd>)
+SYMBOL(wstreampos, std::, <iosfwd>)
+SYMBOL(wstreampos, std::, <iosfwd>)
+SYMBOL(wstring, std::, <string>)
+SYMBOL(wstring_convert, std::, <locale>)
+SYMBOL(wstring_view, std::, <string_view>)
+SYMBOL(wstringbuf, std::, <sstream>)
+SYMBOL(wstringbuf, std::, <iosfwd>)
+SYMBOL(wstringstream, std::, <sstream>)
+SYMBOL(wstringstream, std::, <iosfwd>)
+SYMBOL(wsyncbuf, std::, <syncstream>)
+SYMBOL(wsyncbuf, std::, <iosfwd>)
+SYMBOL(yocto, std::, <ratio>)
+SYMBOL(yotta, std::, <ratio>)
+SYMBOL(zepto, std::, <ratio>)
+SYMBOL(zetta, std::, <ratio>)
+SYMBOL(April, std::chrono::, <chrono>)
+SYMBOL(August, std::chrono::, <chrono>)
+SYMBOL(December, std::chrono::, <chrono>)
+SYMBOL(February, std::chrono::, <chrono>)
+SYMBOL(Friday, std::chrono::, <chrono>)
+SYMBOL(January, std::chrono::, <chrono>)
+SYMBOL(July, std::chrono::, <chrono>)
+SYMBOL(June, std::chrono::, <chrono>)
+SYMBOL(March, std::chrono::, <chrono>)
+SYMBOL(May, std::chrono::, <chrono>)
+SYMBOL(Monday, std::chrono::, <chrono>)
+SYMBOL(November, std::chrono::, <chrono>)
+SYMBOL(October, std::chrono::, <chrono>)
+SYMBOL(Saturday, std::chrono::, <chrono>)
+SYMBOL(September, std::chrono::, <chrono>)
+SYMBOL(Sunday, std::chrono::, <chrono>)
+SYMBOL(Thursday, std::chrono::, <chrono>)
+SYMBOL(Tuesday, std::chrono::, <chrono>)
+SYMBOL(Wednesday, std::chrono::, <chrono>)
+SYMBOL(abs, std::chrono::, <chrono>)
+SYMBOL(ambiguous_local_time, std::chrono::, <chrono>)
+SYMBOL(choose, std::chrono::, <chrono>)
+SYMBOL(clock_cast, std::chrono::, <chrono>)
+SYMBOL(clock_time_conversion, std::chrono::, <chrono>)
+SYMBOL(current_zone, std::chrono::, <chrono>)
+SYMBOL(day, std::chrono::, <chrono>)
+SYMBOL(duration, std::chrono::, <chrono>)
+SYMBOL(duration_cast, std::chrono::, <chrono>)
+SYMBOL(duration_values, std::chrono::, <chrono>)
+SYMBOL(file_clock, std::chrono::, <chrono>)
+SYMBOL(file_seconds, std::chrono::, <chrono>)
+SYMBOL(file_time, std::chrono::, <chrono>)
+SYMBOL(get_leap_second_info, std::chrono::, <chrono>)
+SYMBOL(gps_clock, std::chrono::, <chrono>)
+SYMBOL(gps_seconds, std::chrono::, <chrono>)
+SYMBOL(gps_time, std::chrono::, <chrono>)
+SYMBOL(hh_mm_ss, std::chrono::, <chrono>)
+SYMBOL(high_resolution_clock, std::chrono::, <chrono>)
+SYMBOL(hours, std::chrono::, <chrono>)
+SYMBOL(is_am, std::chrono::, <chrono>)
+SYMBOL(is_clock, std::chrono::, <chrono>)
+SYMBOL(is_clock_v, std::chrono::, <chrono>)
+SYMBOL(is_pm, std::chrono::, <chrono>)
+SYMBOL(last, std::chrono::, <chrono>)
+SYMBOL(last_spec, std::chrono::, <chrono>)
+SYMBOL(leap_second, std::chrono::, <chrono>)
+SYMBOL(leap_second_info, std::chrono::, <chrono>)
+SYMBOL(local_info, std::chrono::, <chrono>)
+SYMBOL(local_seconds, std::chrono::, <chrono>)
+SYMBOL(local_t, std::chrono::, <chrono>)
+SYMBOL(local_time, std::chrono::, <chrono>)
+SYMBOL(local_time_format, std::chrono::, <chrono>)
+SYMBOL(locate_zone, std::chrono::, <chrono>)
+SYMBOL(make12, std::chrono::, <chrono>)
+SYMBOL(make24, std::chrono::, <chrono>)
+SYMBOL(microseconds, std::chrono::, <chrono>)
+SYMBOL(milliseconds, std::chrono::, <chrono>)
+SYMBOL(minutes, std::chrono::, <chrono>)
+SYMBOL(month, std::chrono::, <chrono>)
+SYMBOL(month_day, std::chrono::, <chrono>)
+SYMBOL(month_day_last, std::chrono::, <chrono>)
+SYMBOL(month_weekday, std::chrono::, <chrono>)
+SYMBOL(month_weekday_last, std::chrono::, <chrono>)
+SYMBOL(nanoseconds, std::chrono::, <chrono>)
+SYMBOL(nonexistent_local_time, std::chrono::, <chrono>)
+SYMBOL(parse, std::chrono::, <chrono>)
+SYMBOL(seconds, std::chrono::, <chrono>)
+SYMBOL(steady_clock, std::chrono::, <chrono>)
+SYMBOL(sys_days, std::chrono::, <chrono>)
+SYMBOL(sys_info, std::chrono::, <chrono>)
+SYMBOL(sys_seconds, std::chrono::, <chrono>)
+SYMBOL(sys_time, std::chrono::, <chrono>)
+SYMBOL(system_clock, std::chrono::, <chrono>)
+SYMBOL(tai_clock, std::chrono::, <chrono>)
+SYMBOL(tai_seconds, std::chrono::, <chrono>)
+SYMBOL(tai_time, std::chrono::, <chrono>)
+SYMBOL(time_point, std::chrono::, <chrono>)
+SYMBOL(time_point_cast, std::chrono::, <chrono>)
+SYMBOL(time_zone, std::chrono::, <chrono>)
+SYMBOL(time_zone_link, std::chrono::, <chrono>)
+SYMBOL(treat_as_floating_point, std::chrono::, <chrono>)
+SYMBOL(treat_as_floating_point_v, std::chrono::, <chrono>)
+SYMBOL(tzdb, std::chrono::, <chrono>)
+SYMBOL(tzdb_list, std::chrono::, <chrono>)
+SYMBOL(utc_clock, std::chrono::, <chrono>)
+SYMBOL(utc_seconds, std::chrono::, <chrono>)
+SYMBOL(utc_time, std::chrono::, <chrono>)
+SYMBOL(weekday, std::chrono::, <chrono>)
+SYMBOL(weekday_indexed, std::chrono::, <chrono>)
+SYMBOL(weekday_last, std::chrono::, <chrono>)
+SYMBOL(year, std::chrono::, <chrono>)
+SYMBOL(year_month, std::chrono::, <chrono>)
+SYMBOL(year_month_day, std::chrono::, <chrono>)
+SYMBOL(year_month_day_last, std::chrono::, <chrono>)
+SYMBOL(year_month_weekday, std::chrono::, <chrono>)
+SYMBOL(year_month_weekday_last, std::chrono::, <chrono>)
+SYMBOL(zoned_seconds, std::chrono::, <chrono>)
+SYMBOL(zoned_time, std::chrono::, <chrono>)
+SYMBOL(zoned_traits, std::chrono::, <chrono>)
+SYMBOL(par, std::execution::, <execution>)
+SYMBOL(par_unseq, std::execution::, <execution>)
+SYMBOL(parallel_policy, std::execution::, <execution>)
+SYMBOL(parallel_unsequenced_policy, std::execution::, <execution>)
+SYMBOL(seq, std::execution::, <execution>)
+SYMBOL(sequenced_policy, std::execution::, <execution>)
+SYMBOL(unseq, std::execution::, <execution>)
+SYMBOL(unsequenced_policy, std::execution::, <execution>)
+SYMBOL(absolute, std::filesystem::, <filesystem>)
+SYMBOL(canonical, std::filesystem::, <filesystem>)
+SYMBOL(copy, std::filesystem::, <filesystem>)
+SYMBOL(copy_file, std::filesystem::, <filesystem>)
+SYMBOL(copy_options, std::filesystem::, <filesystem>)
+SYMBOL(copy_symlink, std::filesystem::, <filesystem>)
+SYMBOL(create_directories, std::filesystem::, <filesystem>)
+SYMBOL(create_directory, std::filesystem::, <filesystem>)
+SYMBOL(create_directory_symlink, std::filesystem::, <filesystem>)
+SYMBOL(create_hard_link, std::filesystem::, <filesystem>)
+SYMBOL(create_symlink, std::filesystem::, <filesystem>)
+SYMBOL(current_path, std::filesystem::, <filesystem>)
+SYMBOL(directory_entry, std::filesystem::, <filesystem>)
+SYMBOL(directory_iterator, std::filesystem::, <filesystem>)
+SYMBOL(directory_options, std::filesystem::, <filesystem>)
+SYMBOL(equivalent, std::filesystem::, <filesystem>)
+SYMBOL(exists, std::filesystem::, <filesystem>)
+SYMBOL(file_size, std::filesystem::, <filesystem>)
+SYMBOL(file_status, std::filesystem::, <filesystem>)
+SYMBOL(file_time_type, std::filesystem::, <filesystem>)
+SYMBOL(file_type, std::filesystem::, <filesystem>)
+SYMBOL(filesystem_error, std::filesystem::, <filesystem>)
+SYMBOL(hard_link_count, std::filesystem::, <filesystem>)
+SYMBOL(hash_value, std::filesystem::, <filesystem>)
+SYMBOL(is_block_file, std::filesystem::, <filesystem>)
+SYMBOL(is_character_file, std::filesystem::, <filesystem>)
+SYMBOL(is_directory, std::filesystem::, <filesystem>)
+SYMBOL(is_empty, std::filesystem::, <filesystem>)
+SYMBOL(is_fifo, std::filesystem::, <filesystem>)
+SYMBOL(is_other, std::filesystem::, <filesystem>)
+SYMBOL(is_regular_file, std::filesystem::, <filesystem>)
+SYMBOL(is_socket, std::filesystem::, <filesystem>)
+SYMBOL(is_symlink, std::filesystem::, <filesystem>)
+SYMBOL(last_write_time, std::filesystem::, <filesystem>)
+SYMBOL(path, std::filesystem::, <filesystem>)
+SYMBOL(perm_options, std::filesystem::, <filesystem>)
+SYMBOL(permissions, std::filesystem::, <filesystem>)
+SYMBOL(perms, std::filesystem::, <filesystem>)
+SYMBOL(proximate, std::filesystem::, <filesystem>)
+SYMBOL(read_symlink, std::filesystem::, <filesystem>)
+SYMBOL(recursive_directory_iterator, std::filesystem::, <filesystem>)
+SYMBOL(relative, std::filesystem::, <filesystem>)
+SYMBOL(remove, std::filesystem::, <filesystem>)
+SYMBOL(remove_all, std::filesystem::, <filesystem>)
+SYMBOL(rename, std::filesystem::, <filesystem>)
+SYMBOL(resize_file, std::filesystem::, <filesystem>)
+SYMBOL(space, std::filesystem::, <filesystem>)
+SYMBOL(space_info, std::filesystem::, <filesystem>)
+SYMBOL(status, std::filesystem::, <filesystem>)
+SYMBOL(status_known, std::filesystem::, <filesystem>)
+SYMBOL(symlink_status, std::filesystem::, <filesystem>)
+SYMBOL(temp_directory_path, std::filesystem::, <filesystem>)
+SYMBOL(u8path, std::filesystem::, <filesystem>)
+SYMBOL(weakly_canonical, std::filesystem::, <filesystem>)
+SYMBOL(e, std::numbers::, <numbers>)
+SYMBOL(e_v, std::numbers::, <numbers>)
+SYMBOL(egamma, std::numbers::, <numbers>)
+SYMBOL(egamma_v, std::numbers::, <numbers>)
+SYMBOL(inv_pi, std::numbers::, <numbers>)
+SYMBOL(inv_pi_v, std::numbers::, <numbers>)
+SYMBOL(inv_sqrt3, std::numbers::, <numbers>)
+SYMBOL(inv_sqrt3_v, std::numbers::, <numbers>)
+SYMBOL(inv_sqrtpi, std::numbers::, <numbers>)
+SYMBOL(inv_sqrtpi_v, std::numbers::, <numbers>)
+SYMBOL(ln10, std::numbers::, <numbers>)
+SYMBOL(ln10_v, std::numbers::, <numbers>)
+SYMBOL(ln2, std::numbers::, <numbers>)
+SYMBOL(ln2_v, std::numbers::, <numbers>)
+SYMBOL(log10e, std::numbers::, <numbers>)
+SYMBOL(log10e_v, std::numbers::, <numbers>)
+SYMBOL(log2e, std::numbers::, <numbers>)
+SYMBOL(log2e_v, std::numbers::, <numbers>)
+SYMBOL(phi, std::numbers::, <numbers>)
+SYMBOL(phi_v, std::numbers::, <numbers>)
+SYMBOL(pi, std::numbers::, <numbers>)
+SYMBOL(pi_v, std::numbers::, <numbers>)
+SYMBOL(sqrt2, std::numbers::, <numbers>)
+SYMBOL(sqrt2_v, std::numbers::, <numbers>)
+SYMBOL(sqrt3, std::numbers::, <numbers>)
+SYMBOL(sqrt3_v, std::numbers::, <numbers>)
+SYMBOL(basic_string, std::pmr::, <string>)
+SYMBOL(cmatch, std::pmr::, <regex>)
+SYMBOL(deque, std::pmr::, <deque>)
+SYMBOL(forward_list, std::pmr::, <forward_list>)
+SYMBOL(get_default_resource, std::pmr::, <memory_resource>)
+SYMBOL(list, std::pmr::, <list>)
+SYMBOL(map, std::pmr::, <map>)
+SYMBOL(match_results, std::pmr::, <regex>)
+SYMBOL(memory_resource, std::pmr::, <memory_resource>)
+SYMBOL(monotonic_buffer_resource, std::pmr::, <memory_resource>)
+SYMBOL(multimap, std::pmr::, <map>)
+SYMBOL(multiset, std::pmr::, <set>)
+SYMBOL(new_delete_resource, std::pmr::, <memory_resource>)
+SYMBOL(null_memory_resource, std::pmr::, <memory_resource>)
+SYMBOL(polymorphic_allocator, std::pmr::, <memory_resource>)
+SYMBOL(pool_options, std::pmr::, <memory_resource>)
+SYMBOL(set, std::pmr::, <set>)
+SYMBOL(set_default_resource, std::pmr::, <memory_resource>)
+SYMBOL(smatch, std::pmr::, <regex>)
+SYMBOL(stacktrace, std::pmr::, <stacktrace>)
+SYMBOL(string, std::pmr::, <string>)
+SYMBOL(synchronized_pool_resource, std::pmr::, <memory_resource>)
+SYMBOL(u16string, std::pmr::, <string>)
+SYMBOL(u32string, std::pmr::, <string>)
+SYMBOL(u8string, std::pmr::, <string>)
+SYMBOL(unordered_map, std::pmr::, <unordered_map>)
+SYMBOL(unordered_multimap, std::pmr::, <unordered_map>)
+SYMBOL(unordered_multiset, std::pmr::, <unordered_set>)
+SYMBOL(unordered_set, std::pmr::, <unordered_set>)
+SYMBOL(unsynchronized_pool_resource, std::pmr::, <memory_resource>)
+SYMBOL(vector, std::pmr::, <vector>)
+SYMBOL(wcmatch, std::pmr::, <regex>)
+SYMBOL(wsmatch, std::pmr::, <regex>)
+SYMBOL(wstring, std::pmr::, <string>)
+SYMBOL(adjacent_find, std::ranges::, <algorithm>)
+SYMBOL(advance, std::ranges::, <iterator>)
+SYMBOL(all_of, std::ranges::, <algorithm>)
+SYMBOL(any_of, std::ranges::, <algorithm>)
+SYMBOL(as_const_view, std::ranges::, <ranges>)
+SYMBOL(as_rvalue_view, std::ranges::, <ranges>)
+SYMBOL(basic_istream_view, std::ranges::, <ranges>)
+SYMBOL(begin, std::ranges::, <ranges>)
+SYMBOL(bidirectional_range, std::ranges::, <ranges>)
+SYMBOL(binary_transform_result, std::ranges::, <algorithm>)
+SYMBOL(borrowed_iterator_t, std::ranges::, <ranges>)
+SYMBOL(borrowed_range, std::ranges::, <ranges>)
+SYMBOL(borrowed_subrange_t, std::ranges::, <ranges>)
+SYMBOL(cbegin, std::ranges::, <ranges>)
+SYMBOL(cdata, std::ranges::, <ranges>)
+SYMBOL(cend, std::ranges::, <ranges>)
+SYMBOL(clamp, std::ranges::, <algorithm>)
+SYMBOL(common_range, std::ranges::, <ranges>)
+SYMBOL(common_view, std::ranges::, <ranges>)
+SYMBOL(const_iterator_t, std::ranges::, <ranges>)
+SYMBOL(constant_range, std::ranges::, <ranges>)
+SYMBOL(construct_at, std::ranges::, <memory>)
+SYMBOL(contains, std::ranges::, <algorithm>)
+SYMBOL(contains_subrange, std::ranges::, <algorithm>)
+SYMBOL(contiguous_range, std::ranges::, <ranges>)
+SYMBOL(copy, std::ranges::, <algorithm>)
+SYMBOL(copy_backward, std::ranges::, <algorithm>)
+SYMBOL(copy_backward_result, std::ranges::, <algorithm>)
+SYMBOL(copy_if, std::ranges::, <algorithm>)
+SYMBOL(copy_if_result, std::ranges::, <algorithm>)
+SYMBOL(copy_n, std::ranges::, <algorithm>)
+SYMBOL(copy_n_result, std::ranges::, <algorithm>)
+SYMBOL(copy_result, std::ranges::, <algorithm>)
+SYMBOL(count, std::ranges::, <algorithm>)
+SYMBOL(count_if, std::ranges::, <algorithm>)
+SYMBOL(crbegin, std::ranges::, <ranges>)
+SYMBOL(crend, std::ranges::, <ranges>)
+SYMBOL(dangling, std::ranges::, <ranges>)
+SYMBOL(data, std::ranges::, <ranges>)
+SYMBOL(destroy, std::ranges::, <memory>)
+SYMBOL(destroy_at, std::ranges::, <memory>)
+SYMBOL(destroy_n, std::ranges::, <memory>)
+SYMBOL(disable_sized_range, std::ranges::, <ranges>)
+SYMBOL(distance, std::ranges::, <iterator>)
+SYMBOL(drop_view, std::ranges::, <ranges>)
+SYMBOL(drop_while_view, std::ranges::, <ranges>)
+SYMBOL(elements_view, std::ranges::, <ranges>)
+SYMBOL(empty, std::ranges::, <ranges>)
+SYMBOL(empty_view, std::ranges::, <ranges>)
+SYMBOL(enable_borrowed_range, std::ranges::, <ranges>)
+SYMBOL(enable_view, std::ranges::, <ranges>)
+SYMBOL(end, std::ranges::, <ranges>)
+SYMBOL(ends_with, std::ranges::, <algorithm>)
+SYMBOL(equal, std::ranges::, <algorithm>)
+SYMBOL(equal_to, std::ranges::, <functional>)
+SYMBOL(fill, std::ranges::, <algorithm>)
+SYMBOL(fill_n, std::ranges::, <algorithm>)
+SYMBOL(filter_view, std::ranges::, <ranges>)
+SYMBOL(find, std::ranges::, <algorithm>)
+SYMBOL(find_end, std::ranges::, <algorithm>)
+SYMBOL(find_first_of, std::ranges::, <algorithm>)
+SYMBOL(find_if, std::ranges::, <algorithm>)
+SYMBOL(find_if_not, std::ranges::, <algorithm>)
+SYMBOL(find_last, std::ranges::, <algorithm>)
+SYMBOL(find_last_if, std::ranges::, <algorithm>)
+SYMBOL(find_last_if_not, std::ranges::, <algorithm>)
+SYMBOL(for_each, std::ranges::, <algorithm>)
+SYMBOL(for_each_n, std::ranges::, <algorithm>)
+SYMBOL(for_each_n_result, std::ranges::, <algorithm>)
+SYMBOL(for_each_result, std::ranges::, <algorithm>)
+SYMBOL(forward_range, std::ranges::, <ranges>)
+SYMBOL(generate, std::ranges::, <algorithm>)
+SYMBOL(generate_n, std::ranges::, <algorithm>)
+SYMBOL(greater, std::ranges::, <functional>)
+SYMBOL(greater_equal, std::ranges::, <functional>)
+SYMBOL(in_found_result, std::ranges::, <algorithm>)
+SYMBOL(in_fun_result, std::ranges::, <algorithm>)
+SYMBOL(in_in_out_result, std::ranges::, <algorithm>)
+SYMBOL(in_in_result, std::ranges::, <algorithm>)
+SYMBOL(in_out_out_result, std::ranges::, <algorithm>)
+SYMBOL(in_out_result, std::ranges::, <algorithm>)
+SYMBOL(in_value_result, std::ranges::, <algorithm>)
+SYMBOL(includes, std::ranges::, <algorithm>)
+SYMBOL(inplace_merge, std::ranges::, <algorithm>)
+SYMBOL(input_range, std::ranges::, <ranges>)
+SYMBOL(iota, std::ranges::, <numeric>)
+SYMBOL(iota_result, std::ranges::, <numeric>)
+SYMBOL(iota_view, std::ranges::, <ranges>)
+SYMBOL(is_heap, std::ranges::, <algorithm>)
+SYMBOL(is_heap_until, std::ranges::, <algorithm>)
+SYMBOL(is_partitioned, std::ranges::, <algorithm>)
+SYMBOL(is_permutation, std::ranges::, <algorithm>)
+SYMBOL(is_sorted, std::ranges::, <algorithm>)
+SYMBOL(is_sorted_until, std::ranges::, <algorithm>)
+SYMBOL(istream_view, std::ranges::, <ranges>)
+SYMBOL(iter_move, std::ranges::, <iterator>)
+SYMBOL(iter_swap, std::ranges::, <iterator>)
+SYMBOL(iterator_t, std::ranges::, <ranges>)
+SYMBOL(join_view, std::ranges::, <ranges>)
+SYMBOL(join_with_view, std::ranges::, <ranges>)
+SYMBOL(keys_view, std::ranges::, <ranges>)
+SYMBOL(lazy_split_view, std::ranges::, <ranges>)
+SYMBOL(less, std::ranges::, <functional>)
+SYMBOL(less_equal, std::ranges::, <functional>)
+SYMBOL(lexicographical_compare, std::ranges::, <algorithm>)
+SYMBOL(make_heap, std::ranges::, <algorithm>)
+SYMBOL(max, std::ranges::, <algorithm>)
+SYMBOL(max_element, std::ranges::, <algorithm>)
+SYMBOL(merge, std::ranges::, <algorithm>)
+SYMBOL(merge_result, std::ranges::, <algorithm>)
+SYMBOL(min, std::ranges::, <algorithm>)
+SYMBOL(min_element, std::ranges::, <algorithm>)
+SYMBOL(min_max_result, std::ranges::, <algorithm>)
+SYMBOL(minmax, std::ranges::, <algorithm>)
+SYMBOL(minmax_element, std::ranges::, <algorithm>)
+SYMBOL(minmax_element_result, std::ranges::, <algorithm>)
+SYMBOL(minmax_result, std::ranges::, <algorithm>)
+SYMBOL(mismatch, std::ranges::, <algorithm>)
+SYMBOL(mismatch_result, std::ranges::, <algorithm>)
+SYMBOL(move, std::ranges::, <algorithm>)
+SYMBOL(move_backward, std::ranges::, <algorithm>)
+SYMBOL(move_backward_result, std::ranges::, <algorithm>)
+SYMBOL(move_result, std::ranges::, <algorithm>)
+SYMBOL(next, std::ranges::, <iterator>)
+SYMBOL(next_permutation, std::ranges::, <algorithm>)
+SYMBOL(next_permutation_result, std::ranges::, <algorithm>)
+SYMBOL(none_of, std::ranges::, <algorithm>)
+SYMBOL(not_equal_to, std::ranges::, <functional>)
+SYMBOL(nth_element, std::ranges::, <algorithm>)
+SYMBOL(out_value_result, std::ranges::, <algorithm>)
+SYMBOL(output_range, std::ranges::, <ranges>)
+SYMBOL(owning_view, std::ranges::, <ranges>)
+SYMBOL(partial_sort, std::ranges::, <algorithm>)
+SYMBOL(partial_sort_copy, std::ranges::, <algorithm>)
+SYMBOL(partial_sort_copy_result, std::ranges::, <algorithm>)
+SYMBOL(partition, std::ranges::, <algorithm>)
+SYMBOL(partition_copy, std::ranges::, <algorithm>)
+SYMBOL(partition_copy_result, std::ranges::, <algorithm>)
+SYMBOL(partition_point, std::ranges::, <algorithm>)
+SYMBOL(pop_heap, std::ranges::, <algorithm>)
+SYMBOL(prev, std::ranges::, <iterator>)
+SYMBOL(prev_permutation, std::ranges::, <algorithm>)
+SYMBOL(prev_permutation_result, std::ranges::, <algorithm>)
+SYMBOL(push_heap, std::ranges::, <algorithm>)
+SYMBOL(random_access_range, std::ranges::, <ranges>)
+SYMBOL(range, std::ranges::, <ranges>)
+SYMBOL(range_const_reference_t, std::ranges::, <ranges>)
+SYMBOL(range_difference_t, std::ranges::, <ranges>)
+SYMBOL(range_reference_t, std::ranges::, <ranges>)
+SYMBOL(range_rvalue_reference_t, std::ranges::, <ranges>)
+SYMBOL(range_size_t, std::ranges::, <ranges>)
+SYMBOL(range_value_t, std::ranges::, <ranges>)
+SYMBOL(rbegin, std::ranges::, <ranges>)
+SYMBOL(ref_view, std::ranges::, <ranges>)
+SYMBOL(remove, std::ranges::, <algorithm>)
+SYMBOL(remove_copy, std::ranges::, <algorithm>)
+SYMBOL(remove_copy_if, std::ranges::, <algorithm>)
+SYMBOL(remove_copy_if_result, std::ranges::, <algorithm>)
+SYMBOL(remove_copy_result, std::ranges::, <algorithm>)
+SYMBOL(remove_if, std::ranges::, <algorithm>)
+SYMBOL(rend, std::ranges::, <ranges>)
+SYMBOL(replace, std::ranges::, <algorithm>)
+SYMBOL(replace_copy, std::ranges::, <algorithm>)
+SYMBOL(replace_copy_if, std::ranges::, <algorithm>)
+SYMBOL(replace_copy_if_result, std::ranges::, <algorithm>)
+SYMBOL(replace_copy_result, std::ranges::, <algorithm>)
+SYMBOL(replace_if, std::ranges::, <algorithm>)
+SYMBOL(reverse, std::ranges::, <algorithm>)
+SYMBOL(reverse_copy, std::ranges::, <algorithm>)
+SYMBOL(reverse_copy_result, std::ranges::, <algorithm>)
+SYMBOL(reverse_view, std::ranges::, <ranges>)
+SYMBOL(rotate, std::ranges::, <algorithm>)
+SYMBOL(rotate_copy, std::ranges::, <algorithm>)
+SYMBOL(rotate_copy_result, std::ranges::, <algorithm>)
+SYMBOL(sample, std::ranges::, <algorithm>)
+SYMBOL(search, std::ranges::, <algorithm>)
+SYMBOL(search_n, std::ranges::, <algorithm>)
+SYMBOL(sentinel_t, std::ranges::, <ranges>)
+SYMBOL(set_difference, std::ranges::, <algorithm>)
+SYMBOL(set_difference_result, std::ranges::, <algorithm>)
+SYMBOL(set_intersection, std::ranges::, <algorithm>)
+SYMBOL(set_intersection_result, std::ranges::, <algorithm>)
+SYMBOL(set_symmetric_difference, std::ranges::, <algorithm>)
+SYMBOL(set_symmetric_difference_result, std::ranges::, <algorithm>)
+SYMBOL(set_union, std::ranges::, <algorithm>)
+SYMBOL(set_union_result, std::ranges::, <algorithm>)
+SYMBOL(shift_left, std::ranges::, <algorithm>)
+SYMBOL(shift_right, std::ranges::, <algorithm>)
+SYMBOL(shuffle, std::ranges::, <algorithm>)
+SYMBOL(single_view, std::ranges::, <ranges>)
+SYMBOL(size, std::ranges::, <ranges>)
+SYMBOL(sized_range, std::ranges::, <ranges>)
+SYMBOL(sort, std::ranges::, <algorithm>)
+SYMBOL(sort_heap, std::ranges::, <algorithm>)
+SYMBOL(split_view, std::ranges::, <ranges>)
+SYMBOL(ssize, std::ranges::, <ranges>)
+SYMBOL(stable_partition, std::ranges::, <algorithm>)
+SYMBOL(stable_sort, std::ranges::, <algorithm>)
+SYMBOL(starts_with, std::ranges::, <algorithm>)
+SYMBOL(subrange, std::ranges::, <ranges>)
+SYMBOL(subrange_kind, std::ranges::, <ranges>)
+SYMBOL(swap, std::ranges::, <concepts>)
+SYMBOL(swap_ranges, std::ranges::, <algorithm>)
+SYMBOL(swap_ranges_result, std::ranges::, <algorithm>)
+SYMBOL(take_view, std::ranges::, <ranges>)
+SYMBOL(take_while_view, std::ranges::, <ranges>)
+SYMBOL(to, std::ranges::, <ranges>)
+SYMBOL(transform, std::ranges::, <algorithm>)
+SYMBOL(transform_view, std::ranges::, <ranges>)
+SYMBOL(unary_transform_result, std::ranges::, <algorithm>)
+SYMBOL(uninitialized_copy, std::ranges::, <memory>)
+SYMBOL(uninitialized_copy_n, std::ranges::, <memory>)
+SYMBOL(uninitialized_copy_n_result, std::ranges::, <memory>)
+SYMBOL(uninitialized_copy_result, std::ranges::, <memory>)
+SYMBOL(uninitialized_default_construct, std::ranges::, <memory>)
+SYMBOL(uninitialized_default_construct_n, std::ranges::, <memory>)
+SYMBOL(uninitialized_fill, std::ranges::, <memory>)
+SYMBOL(uninitialized_fill_n, std::ranges::, <memory>)
+SYMBOL(uninitialized_move, std::ranges::, <memory>)
+SYMBOL(uninitialized_move_n, std::ranges::, <memory>)
+SYMBOL(uninitialized_move_n_result, std::ranges::, <memory>)
+SYMBOL(uninitialized_move_result, std::ranges::, <memory>)
+SYMBOL(uninitialized_value_construct, std::ranges::, <memory>)
+SYMBOL(uninitialized_value_construct_n, std::ranges::, <memory>)
+SYMBOL(unique, std::ranges::, <algorithm>)
+SYMBOL(unique_copy, std::ranges::, <algorithm>)
+SYMBOL(unique_copy_result, std::ranges::, <algorithm>)
+SYMBOL(values_view, std::ranges::, <ranges>)
+SYMBOL(view, std::ranges::, <ranges>)
+SYMBOL(view_base, std::ranges::, <ranges>)
+SYMBOL(view_interface, std::ranges::, <ranges>)
+SYMBOL(viewable_range, std::ranges::, <ranges>)
+SYMBOL(wistream_view, std::ranges::, <ranges>)
+SYMBOL(zip_transform_view, std::ranges::, <ranges>)
+SYMBOL(zip_view, std::ranges::, <ranges>)
+SYMBOL(ECMAScript, std::regex_constants::, <regex>)
+SYMBOL(awk, std::regex_constants::, <regex>)
+SYMBOL(basic, std::regex_constants::, <regex>)
+SYMBOL(collate, std::regex_constants::, <regex>)
+SYMBOL(egrep, std::regex_constants::, <regex>)
+SYMBOL(error_backref, std::regex_constants::, <regex>)
+SYMBOL(error_badbrace, std::regex_constants::, <regex>)
+SYMBOL(error_badrepeat, std::regex_constants::, <regex>)
+SYMBOL(error_brace, std::regex_constants::, <regex>)
+SYMBOL(error_brack, std::regex_constants::, <regex>)
+SYMBOL(error_collate, std::regex_constants::, <regex>)
+SYMBOL(error_complexity, std::regex_constants::, <regex>)
+SYMBOL(error_ctype, std::regex_constants::, <regex>)
+SYMBOL(error_escape, std::regex_constants::, <regex>)
+SYMBOL(error_paren, std::regex_constants::, <regex>)
+SYMBOL(error_range, std::regex_constants::, <regex>)
+SYMBOL(error_space, std::regex_constants::, <regex>)
+SYMBOL(error_stack, std::regex_constants::, <regex>)
+SYMBOL(error_type, std::regex_constants::, <regex>)
+SYMBOL(extended, std::regex_constants::, <regex>)
+SYMBOL(format_default, std::regex_constants::, <regex>)
+SYMBOL(format_first_only, std::regex_constants::, <regex>)
+SYMBOL(format_no_copy, std::regex_constants::, <regex>)
+SYMBOL(format_sed, std::regex_constants::, <regex>)
+SYMBOL(grep, std::regex_constants::, <regex>)
+SYMBOL(icase, std::regex_constants::, <regex>)
+SYMBOL(match_any, std::regex_constants::, <regex>)
+SYMBOL(match_continuous, std::regex_constants::, <regex>)
+SYMBOL(match_default, std::regex_constants::, <regex>)
+SYMBOL(match_flag_type, std::regex_constants::, <regex>)
+SYMBOL(match_not_bol, std::regex_constants::, <regex>)
+SYMBOL(match_not_bow, std::regex_constants::, <regex>)
+SYMBOL(match_not_eol, std::regex_constants::, <regex>)
+SYMBOL(match_not_eow, std::regex_constants::, <regex>)
+SYMBOL(match_not_null, std::regex_constants::, <regex>)
+SYMBOL(match_prev_avail, std::regex_constants::, <regex>)
+SYMBOL(multiline, std::regex_constants::, <regex>)
+SYMBOL(nosubs, std::regex_constants::, <regex>)
+SYMBOL(optimize, std::regex_constants::, <regex>)
+SYMBOL(syntax_option_type, std::regex_constants::, <regex>)
+SYMBOL(get_id, std::this_thread::, <thread>)
+SYMBOL(sleep_for, std::this_thread::, <thread>)
+SYMBOL(sleep_until, std::this_thread::, <thread>)
+SYMBOL(yield, std::this_thread::, <thread>)
diff --git a/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/StdTsSymbolMap.inc b/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/StdTsSymbolMap.inc
new file mode 100644
index 000000000000..2733cb3f2ec4
--- /dev/null
+++ b/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/StdTsSymbolMap.inc
@@ -0,0 +1,52 @@
+// These are derived from N4100[fs.filesystem.synopsis], final draft for
+// experimental filesystem.
+SYMBOL(absolute, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(canonical, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(copy, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(copy_file, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(copy_options, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(copy_symlink, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(create_directories, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(create_directory, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(create_directory_symlink, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(create_hard_link, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(create_symlink, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(current_path, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(directory_entry, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(directory_iterator, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(directory_options, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(equivalent, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(exists, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(file_size, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(file_status, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(file_time_type, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(file_type, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(filesystem_error, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(hard_link_count, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(is_block_file, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(is_character_file, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(is_directory, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(is_empty, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(is_fifo, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(is_other, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(is_regular_file, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(is_socket, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(is_symlink, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(last_write_time, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(path, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(permissions, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(perms, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(read_symlink, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(recursive_directory_iterator, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(remove, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(remove_all, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(rename, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(resize_file, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(space, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(space_info, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(status, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(status_known, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(symlink_status, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(system_complete, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(temp_directory_path, std::experimental::filesystem::, <experimental/filesystem>)
+SYMBOL(u8path, std::experimental::filesystem::, <experimental/filesystem>)
diff --git a/contrib/llvm-project/clang/lib/Tooling/JSONCompilationDatabase.cpp b/contrib/llvm-project/clang/lib/Tooling/JSONCompilationDatabase.cpp
index cdda587d0925..a77686996879 100644
--- a/contrib/llvm-project/clang/lib/Tooling/JSONCompilationDatabase.cpp
+++ b/contrib/llvm-project/clang/lib/Tooling/JSONCompilationDatabase.cpp
@@ -19,18 +19,18 @@
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Triple.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorOr.h"
-#include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/YAMLParser.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/TargetParser/Host.h"
+#include "llvm/TargetParser/Triple.h"
 #include <cassert>
 #include <memory>
 #include <optional>
diff --git a/contrib/llvm-project/clang/lib/Tooling/Refactoring/Rename/USRLocFinder.cpp b/contrib/llvm-project/clang/lib/Tooling/Refactoring/Rename/USRLocFinder.cpp
index aecfffcbef1f..9cdeeec0574b 100644
--- a/contrib/llvm-project/clang/lib/Tooling/Refactoring/Rename/USRLocFinder.cpp
+++ b/contrib/llvm-project/clang/lib/Tooling/Refactoring/Rename/USRLocFinder.cpp
@@ -228,16 +228,17 @@ public:
 
   bool VisitDesignatedInitExpr(const DesignatedInitExpr *E) {
     for (const DesignatedInitExpr::Designator &D : E->designators()) {
-      if (D.isFieldDesignator() && D.getField()) {
-        const FieldDecl *Decl = D.getField();
-        if (isInUSRSet(Decl)) {
-          auto StartLoc = D.getFieldLoc();
-          auto EndLoc = D.getFieldLoc();
-          RenameInfos.push_back({StartLoc, EndLoc,
-                                 /*FromDecl=*/nullptr,
-                                 /*Context=*/nullptr,
-                                 /*Specifier=*/nullptr,
-                                 /*IgnorePrefixQualifiers=*/true});
+      if (D.isFieldDesignator()) {
+        if (const FieldDecl *Decl = D.getFieldDecl()) {
+          if (isInUSRSet(Decl)) {
+            auto StartLoc = D.getFieldLoc();
+            auto EndLoc = D.getFieldLoc();
+            RenameInfos.push_back({StartLoc, EndLoc,
+                                   /*FromDecl=*/nullptr,
+                                   /*Context=*/nullptr,
+                                   /*Specifier=*/nullptr,
+                                   /*IgnorePrefixQualifiers=*/true});
+          }
         }
       }
     }
diff --git a/contrib/llvm-project/clang/lib/Tooling/Syntax/Tokens.cpp b/contrib/llvm-project/clang/lib/Tooling/Syntax/Tokens.cpp
index b13dc9ef4aee..9c2f470e985f 100644
--- a/contrib/llvm-project/clang/lib/Tooling/Syntax/Tokens.cpp
+++ b/contrib/llvm-project/clang/lib/Tooling/Syntax/Tokens.cpp
@@ -103,66 +103,13 @@ SourceRange spelledForExpandedSlow(SourceLocation First, SourceLocation Last,
     // The token `a` is wrapped in 4 arg-expansions, we only want to unwrap 2.
     // We distinguish them by whether the macro expands into the target file.
     // Fortunately, the target file ones will always appear first.
-    auto &ExpMacro =
-        SM.getSLocEntry(SM.getFileID(ExpFirst.getExpansionLocStart()))
-            .getExpansion();
-    if (ExpMacro.getExpansionLocStart().isMacroID())
+    auto ExpFileID = SM.getFileID(ExpFirst.getExpansionLocStart());
+    if (ExpFileID == TargetFile)
       break;
     // Replace each endpoint with its spelling inside the macro arg.
     // (This is getImmediateSpellingLoc without repeating lookups).
     First = ExpFirst.getSpellingLoc().getLocWithOffset(DecFirst.second);
     Last = ExpLast.getSpellingLoc().getLocWithOffset(DecLast.second);
-
-    // Now: how do we adjust the previous/next bounds? Three cases:
-    // A) If they are also part of the same macro arg, we translate them too.
-    //   This will ensure that we don't select any macros nested within the
-    //   macro arg that cover extra tokens. Critical case:
-    //      #define ID(X) X
-    //      ID(prev target) // selecting 'target' succeeds
-    //      #define LARGE ID(prev target)
-    //      LARGE // selecting 'target' fails.
-    // B) They are not in the macro at all, then their expansion range is a
-    //    sibling to it, and we can safely substitute that.
-    //      #define PREV prev
-    //      #define ID(X) X
-    //      PREV ID(target) // selecting 'target' succeeds.
-    //      #define LARGE PREV ID(target)
-    //      LARGE // selecting 'target' fails.
-    // C) They are in a different arg of this macro, or the macro body.
-    //    Now selecting the whole macro arg is fine, but the whole macro is not.
-    //    Model this by setting using the edge of the macro call as the bound.
-    //      #define ID2(X, Y) X Y
-    //      ID2(prev, target) // selecting 'target' succeeds
-    //      #define LARGE ID2(prev, target)
-    //      LARGE // selecting 'target' fails
-    auto AdjustBound = [&](SourceLocation &Bound) {
-      if (Bound.isInvalid() || !Bound.isMacroID()) // Non-macro must be case B.
-        return;
-      auto DecBound = SM.getDecomposedLoc(Bound);
-      auto &ExpBound = SM.getSLocEntry(DecBound.first).getExpansion();
-      if (ExpBound.isMacroArgExpansion() &&
-          ExpBound.getExpansionLocStart() == ExpFirst.getExpansionLocStart()) {
-        // Case A: translate to (spelling) loc within the macro arg.
-        Bound = ExpBound.getSpellingLoc().getLocWithOffset(DecBound.second);
-        return;
-      }
-      while (Bound.isMacroID()) {
-        SourceRange Exp = SM.getImmediateExpansionRange(Bound).getAsRange();
-        if (Exp.getBegin() == ExpMacro.getExpansionLocStart()) {
-          // Case B: bounds become the macro call itself.
-          Bound = (&Bound == &Prev) ? Exp.getBegin() : Exp.getEnd();
-          return;
-        }
-        // Either case C, or expansion location will later find case B.
-        // We choose the upper bound for Prev and the lower one for Next:
-        //   ID(prev) target ID(next)
-        //          ^        ^
-        //      new-prev  new-next
-        Bound = (&Bound == &Prev) ? Exp.getEnd() : Exp.getBegin();
-      }
-    };
-    AdjustBound(Prev);
-    AdjustBound(Next);
   }
 
   // In all remaining cases we need the full containing macros.
@@ -170,9 +117,10 @@ SourceRange spelledForExpandedSlow(SourceLocation First, SourceLocation Last,
   SourceRange Candidate =
       SM.getExpansionRange(SourceRange(First, Last)).getAsRange();
   auto DecFirst = SM.getDecomposedExpansionLoc(Candidate.getBegin());
-  auto DecLast = SM.getDecomposedLoc(Candidate.getEnd());
+  auto DecLast = SM.getDecomposedExpansionLoc(Candidate.getEnd());
   // Can end up in the wrong file due to bad input or token-pasting shenanigans.
-  if (Candidate.isInvalid() || DecFirst.first != TargetFile || DecLast.first != TargetFile)
+  if (Candidate.isInvalid() || DecFirst.first != TargetFile ||
+      DecLast.first != TargetFile)
     return SourceRange();
   // Check bounds, which may still be inside macros.
   if (Prev.isValid()) {
@@ -986,7 +934,7 @@ std::string TokenBuffer::dumpForTests() const {
   OS << "\n";
 
   std::vector<FileID> Keys;
-  for (auto F : Files)
+  for (const auto &F : Files)
     Keys.push_back(F.first);
   llvm::sort(Keys);
 
diff --git a/contrib/llvm-project/clang/lib/Tooling/Tooling.cpp b/contrib/llvm-project/clang/lib/Tooling/Tooling.cpp
index 8966c12ef7c1..46a784e44b93 100644
--- a/contrib/llvm-project/clang/lib/Tooling/Tooling.cpp
+++ b/contrib/llvm-project/clang/lib/Tooling/Tooling.cpp
@@ -43,14 +43,15 @@
 #include "llvm/Option/OptTable.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/TargetParser/Host.h"
 #include <cassert>
 #include <cstring>
 #include <memory>
@@ -299,6 +300,31 @@ void addTargetAndModeForProgramName(std::vector<std::string> &CommandLine,
   }
 }
 
+void addExpandedResponseFiles(std::vector<std::string> &CommandLine,
+                              llvm::StringRef WorkingDir,
+                              llvm::cl::TokenizerCallback Tokenizer,
+                              llvm::vfs::FileSystem &FS) {
+  bool SeenRSPFile = false;
+  llvm::SmallVector<const char *, 20> Argv;
+  Argv.reserve(CommandLine.size());
+  for (auto &Arg : CommandLine) {
+    Argv.push_back(Arg.c_str());
+    if (!Arg.empty())
+      SeenRSPFile |= Arg.front() == '@';
+  }
+  if (!SeenRSPFile)
+    return;
+  llvm::BumpPtrAllocator Alloc;
+  llvm::cl::ExpansionContext ECtx(Alloc, Tokenizer);
+  llvm::Error Err =
+      ECtx.setVFS(&FS).setCurrentDir(WorkingDir).expandResponseFiles(Argv);
+  if (Err)
+    llvm::errs() << Err;
+  // Don't assign directly, Argv aliases CommandLine.
+  std::vector<std::string> ExpandedArgv(Argv.begin(), Argv.end());
+  CommandLine = std::move(ExpandedArgv);
+}
+
 } // namespace tooling
 } // namespace clang
 
@@ -516,13 +542,11 @@ int ClangTool::run(ToolAction *Action) {
 
   // Remember the working directory in case we need to restore it.
   std::string InitialWorkingDir;
-  if (RestoreCWD) {
-    if (auto CWD = OverlayFileSystem->getCurrentWorkingDirectory()) {
-      InitialWorkingDir = std::move(*CWD);
-    } else {
-      llvm::errs() << "Could not get working directory: "
-                   << CWD.getError().message() << "\n";
-    }
+  if (auto CWD = OverlayFileSystem->getCurrentWorkingDirectory()) {
+    InitialWorkingDir = std::move(*CWD);
+  } else {
+    llvm::errs() << "Could not get working directory: "
+                 << CWD.getError().message() << "\n";
   }
 
   for (llvm::StringRef File : AbsolutePaths) {
@@ -636,10 +660,6 @@ int ClangTool::buildASTs(std::vector<std::unique_ptr<ASTUnit>> &ASTs) {
   return run(&Action);
 }
 
-void ClangTool::setRestoreWorkingDir(bool RestoreCWD) {
-  this->RestoreCWD = RestoreCWD;
-}
-
 void ClangTool::setPrintErrorMessage(bool PrintErrorMessage) {
   this->PrintErrorMessage = PrintErrorMessage;
 }
@@ -684,7 +704,7 @@ std::unique_ptr<ASTUnit> buildASTFromCodeWithArgs(
 
   if (!Invocation.run())
     return nullptr;
- 
+
   assert(ASTs.size() == 1);
   return std::move(ASTs[0]);
 }
diff --git a/contrib/llvm-project/clang/lib/Tooling/Transformer/Stencil.cpp b/contrib/llvm-project/clang/lib/Tooling/Transformer/Stencil.cpp
index 2198aefddc9f..f2c1b6f8520a 100644
--- a/contrib/llvm-project/clang/lib/Tooling/Transformer/Stencil.cpp
+++ b/contrib/llvm-project/clang/lib/Tooling/Transformer/Stencil.cpp
@@ -327,7 +327,7 @@ public:
     assert(containsNoNullStencils(CaseStencils) &&
            "cases of selectBound may not be null");
   }
-  ~SelectBoundStencil() override{};
+  ~SelectBoundStencil() override {}
 
   llvm::Error eval(const MatchFinder::MatchResult &match,
                    std::string *result) const override {