Index: clangd/StdSymbolMap.imp
===================================================================
--- /dev/null
+++ clangd/StdSymbolMap.imp
@@ -0,0 +1,1301 @@
+//===-- StdSymbolMap.imp - ---------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// Used to build a map (qualified names => include headers) for all symbols from
+// C++ Standard Library (up to C++17).
+//
+// Automatically generated file, do not edit.
+//===----------------------------------------------------------------------===//
+
+{ "std::_Exit", { "<cstdlib>" } }, // C++11
+{ "std::accumulate", { "<numeric>" } },
+{ "std::add_const", { "<type_traits>" } }, // C++11
+{ "std::add_const_t", { "<type_traits>" } }, // C++14
+{ "std::add_cv", { "<type_traits>" } }, // C++11
+{ "std::add_cv_t", { "<type_traits>" } }, // C++14
+{ "std::add_pointer", { "<type_traits>" } }, // C++11
+{ "std::add_pointer_t", { "<type_traits>" } }, // C++14
+{ "std::add_lvalue_reference", { "<type_traits>" } }, // C++11
+{ "std::add_lvalue_reference_t", { "<type_traits>" } }, // C++14
+{ "std::addressof", { "<memory>" } }, // C++11
+{ "std::add_rvalue_reference", { "<type_traits>" } }, // C++11
+{ "std::add_rvalue_reference_t", { "<type_traits>" } }, // C++14
+{ "std::add_volatile", { "<type_traits>" } }, // C++11
+{ "std::add_volatile_t", { "<type_traits>" } }, // C++14
+{ "std::adjacent_difference", { "<numeric>" } },
+{ "std::adjacent_find", { "<algorithm>" } },
+{ "std::adopt_lock", { "<mutex>" } }, // C++11
+{ "std::adopt_lock_t", { "<mutex>" } }, // C++11
+{ "std::advance", { "<iterator>" } },
+{ "std::align", { "<memory>" } }, // C++11
+{ "std::aligned_alloc", { "<cstdlib>" } }, // C++17
+{ "std::aligned_storage", { "<type_traits>" } }, // C++11
+{ "std::aligned_storage_t", { "<type_traits>" } }, // C++14
+{ "std::aligned_union", { "<type_traits>" } }, // C++11
+{ "std::aligned_union_t", { "<type_traits>" } }, // C++14
+{ "std::alignment_of", { "<type_traits>" } }, // C++11
+{ "std::alignment_of_v", { "<type_traits>" } }, // C++17
+{ "std::align_val_t", { "<new>" } }, // C++17
+{ "std::all_of", { "<algorithm>" } }, // C++11
+{ "std::allocate_shared", { "<memory>" } }, // C++11
+{ "std::allocator", { "<memory>" } },
+{ "std::allocator_arg", { "<memory>" } }, // C++11
+{ "std::allocator_arg_t", { "<memory>" } }, // C++11
+{ "std::allocator_traits", { "<memory>" } }, // C++11
+{ "std::any", { "<any>" } }, // C++17
+{ "std::any_of", { "<algorithm>" } }, // C++11
+{ "std::apply", { "<tuple>" } }, // C++17
+{ "std::arg", { "<complex>" } },
+{ "std::array", { "<array>" } }, // C++11
+{ "std::as_const", { "<utility>" } }, // C++17
+{ "std::asctime", { "<ctime>" } },
+{ "std::async", { "<future>" } }, // C++11
+{ "std::at_quick_exit", { "<cstdlib>" } }, // C++11
+{ "std::atexit", { "<cstdlib>" } },
+{ "std::atof", { "<cstdlib>" } },
+{ "std::atoi", { "<cstdlib>" } },
+{ "std::atol", { "<cstdlib>" } },
+{ "std::atoll", { "<cstdlib>" } }, // C++11
+{ "std::atomic", { "<atomic>" } }, // C++11
+{ "std::atomic_bool", { "<atomic>" } }, // C++11
+{ "std::atomic_char", { "<atomic>" } }, // C++11
+{ "std::atomic_char16_t", { "<atomic>" } }, // C++11
+{ "std::atomic_char32_t", { "<atomic>" } }, // C++11
+{ "std::atomic_int", { "<atomic>" } }, // C++11
+{ "std::atomic_int8_t", { "<atomic>" } }, // C++11
+{ "std::atomic_int16_t", { "<atomic>" } }, // C++11
+{ "std::atomic_int32_t", { "<atomic>" } }, // C++11
+{ "std::atomic_int64_t", { "<atomic>" } }, // C++11
+{ "std::atomic_int_fast8_t", { "<atomic>" } }, // C++11
+{ "std::atomic_int_fast16_t", { "<atomic>" } }, // C++11
+{ "std::atomic_int_fast32_t", { "<atomic>" } }, // C++11
+{ "std::atomic_int_fast64_t", { "<atomic>" } }, // C++11
+{ "std::atomic_intmax_t", { "<atomic>" } }, // C++11
+{ "std::atomic_intptr_t", { "<atomic>" } }, // C++11
+{ "std::atomic_llong", { "<atomic>" } }, // C++11
+{ "std::atomic_long", { "<atomic>" } }, // C++11
+{ "std::atomic_ptrdiff_t", { "<atomic>" } }, // C++11
+{ "std::atomic_schar", { "<atomic>" } }, // C++11
+{ "std::atomic_short", { "<atomic>" } }, // C++11
+{ "std::atomic_size_t", { "<atomic>" } }, // C++11
+{ "std::atomic_uchar", { "<atomic>" } }, // C++11
+{ "std::atomic_uint", { "<atomic>" } }, // C++11
+{ "std::atomic_uint8_t", { "<atomic>" } }, // C++11
+{ "std::atomic_uint16_t", { "<atomic>" } }, // C++11
+{ "std::atomic_uint32_t", { "<atomic>" } }, // C++11
+{ "std::atomic_uint64_t", { "<atomic>" } }, // C++11
+{ "std::atomic_uint_fast8_t", { "<atomic>" } }, // C++11
+{ "std::atomic_uint_fast16_t", { "<atomic>" } }, // C++11
+{ "std::atomic_uint_fast32_t", { "<atomic>" } }, // C++11
+{ "std::atomic_uint_fast64_t", { "<atomic>" } }, // C++11
+{ "std::atomic_uint_least8_t", { "<atomic>" } }, // C++11
+{ "std::atomic_uint_least16_t", { "<atomic>" } }, // C++11
+{ "std::atomic_uint_least32_t", { "<atomic>" } }, // C++11
+{ "std::atomic_uint_least64_t", { "<atomic>" } }, // C++11
+{ "std::atomic_uintmax_t", { "<atomic>" } }, // C++11
+{ "std::atomic_uintptr_t", { "<atomic>" } }, // C++11
+{ "std::atomic_ullong", { "<atomic>" } }, // C++11
+{ "std::atomic_ulong", { "<atomic>" } }, // C++11
+{ "std::atomic_ushort", { "<atomic>" } }, // C++11
+{ "std::atomic_wchar_t", { "<atomic>" } }, // C++11
+{ "std::atomic_compare_exchange_strong", { "<atomic>" } }, // C++11
+{ "std::atomic_compare_exchange_strong_explicit", { "<atomic>" } }, // C++11
+{ "std::atomic_compare_exchange_weak", { "<atomic>" } }, // C++11
+{ "std::atomic_compare_exchange_weak_explicit", { "<atomic>" } }, // C++11
+{ "std::atomic_exchange", { "<atomic>" } }, // C++11
+{ "std::atomic_exchange_explicit", { "<atomic>" } }, // C++11
+{ "std::atomic_fetch_add", { "<atomic>" } }, // C++11
+{ "std::atomic_fetch_add_explicit", { "<atomic>" } }, // C++11
+{ "std::atomic_fetch_and", { "<atomic>" } }, // C++11
+{ "std::atomic_fetch_and_explicit", { "<atomic>" } }, // C++11
+{ "std::atomic_fetch_or", { "<atomic>" } }, // C++11
+{ "std::atomic_fetch_or_explicit", { "<atomic>" } }, // C++11
+{ "std::atomic_fetch_sub", { "<atomic>" } }, // C++11
+{ "std::atomic_fetch_sub_explicit", { "<atomic>" } }, // C++11
+{ "std::atomic_fetch_xor", { "<atomic>" } }, // C++11
+{ "std::atomic_fetch_xor_explicit", { "<atomic>" } }, // C++11
+{ "std::atomic_flag", { "<atomic>" } }, // C++11
+{ "std::atomic_flag_clear", { "<atomic>" } }, // C++11
+{ "std::atomic_flag_clear_explicit", { "<atomic>" } }, // C++11
+{ "std::atomic_flag_test_and_set", { "<atomic>" } }, // C++11
+{ "std::atomic_flag_test_and_set_explicit", { "<atomic>" } }, // C++11
+{ "std::atomic_init", { "<atomic>" } }, // C++11
+{ "std::atomic_is_lockfree", { "<atomic>" } }, // C++11
+{ "std::atomic_load", { "<atomic>" } }, // C++11
+{ "std::atomic_load_explicit", { "<atomic>" } }, // C++11
+{ "std::atomic_signal_fence", { "<atomic>" } }, // C++11
+{ "std::atomic_store", { "<atomic>" } }, // C++11
+{ "std::atomic_store_explicit", { "<atomic>" } }, // C++11
+{ "std::atomic_thread_fence", { "<atomic>" } }, // C++11
+{ "std::atto", { "<ratio>" } }, // C++11
+{ "std::auto_ptr", { "<memory>" } },
+{ "std::back_inserter", { "<iterator>" } },
+{ "std::back_insert_iterator", { "<iterator>" } },
+{ "std::bad_alloc", { "<new>" } },
+{ "std::bad_any_cast", { "<any>" } }, // C++17
+{ "std::bad_array_new_length", { "<new>" } }, // C++11
+{ "std::bad_cast", { "<typeinfo>" } },
+{ "std::bad_exception", { "<exception>" } },
+{ "std::bad_function_call", { "<functional>" } }, // C++11
+{ "std::bad_optional_access", { "<optional>" } }, // C++17
+{ "std::bad_typeid", { "<typeinfo>" } },
+{ "std::bad_variant_access", { "<variant>" } }, // C++17
+{ "std::bad_weak_ptr", { "<memory>" } }, // C++11
+{ "std::basic_fstream", { "<fstream>" } },
+{ "std::basic_ifstream", { "<fstream>" } },
+{ "std::basic_istream", { "<istream>" } },
+{ "std::basic_ios", { "<ios>" } },
+{ "std::basic_iostream", { "<istream>" } },
+{ "std::basic_istringstream", { "<sstream>" } },
+{ "std::basic_ofstream", { "<fstream>" } },
+{ "std::basic_ostream", { "<ostream>" } },
+{ "std::basic_ostringstream", { "<sstream>" } },
+{ "std::basic_regex", { "<regex>" } }, // C++11
+{ "std::basic_streambuf", { "<streambuf>" } },
+{ "std::basic_string", { "<string>" } },
+{ "std::basic_stringbuf", { "<sstream>" } },
+{ "std::basic_stringstream", { "<sstream>" } },
+{ "std::basic_string_view", { "<string_view>" } }, // C++17
+{ "std::begin", { "<iterator>" } }, // C++11
+{ "std::bernoulli_distribution", { "<random>" } }, // C++11
+{ "std::bidirectional_iterator_tag", { "<iterator>" } },
+{ "std::binary_search", { "<algorithm>" } },
+{ "std::bind", { "<functional>" } }, // C++11
+{ "std::binomial_distribution", { "<random>" } }, // C++11
+{ "std::bit_and", { "<functional>" } },
+{ "std::bit_or", { "<functional>" } },
+{ "std::bit_not", { "<functional>" } }, // C++14
+{ "std::bit_xor", { "<functional>" } },
+{ "std::bitset", { "<bitset>" } },
+{ "std::bool_constant", { "<type_traits>" } }, // C++17
+{ "std::boolalpha", { "<ios>" } },
+{ "std::boyer_moore_horspool_searcher", { "<functional>" } }, // C++17
+{ "std::boyer_moore_searcher", { "<functional>" } }, // C++17
+{ "std::bsearch", { "<cstdlib>" } },
+{ "std::btowc", { "<cwchar>" } },
+{ "std::byte", { "<cstddef>" } }, // C++17
+{ "std::c16rtomb", { "<cuchar>" } }, // C++11
+{ "std::c32rtomb", { "<cuchar>" } }, // C++11
+{ "std::call_once", { "<mutex>" } }, // C++11
+{ "std::calloc", { "<cstdlib>" } },
+{ "std::cauchy_distribution", { "<random>" } }, // C++11
+{ "std::cbegin", { "<iterator>" } }, // C++14
+{ "std::cbrt", { "<cmath>" } }, // C++11
+{ "std::ceil", { "<cmath>" } },
+{ "std::cend", { "<iterator>" } }, // C++14
+{ "std::centi", { "<ratio>" } }, // C++11
+{ "std::cerr", { "<iostream>" } },
+{ "std::char_traits", { "<string>" } },
+{ "std::chars_format", { "<charconv>" } }, // C++17
+{ "std::chi_squared_distribution", { "<random>" } }, // C++11
+{ "std::cin", { "<iostream>" } },
+{ "std::clamp", { "<algorithm>" } }, // C++17
+{ "std::clearerr", { "<cstdio>" } },
+{ "std::clock", { "<ctime>" } },
+{ "std::clock_t", { "<ctime>" } },
+{ "std::clog", { "<iostream>" } },
+{ "std::cmatch", { "<regex>" } }, // C++11
+{ "std::codecvt", { "<locale>" } },
+{ "std::codecvt_base", { "<locale>" } },
+{ "std::codecvt_byname", { "<locale>" } },
+{ "std::codecvt_mode", { "<codecvt>" } }, // C++11
+{ "std::codecvt_utf16", { "<codecvt>" } }, // C++11
+{ "std::codecvt_utf8", { "<codecvt>" } }, // C++11
+{ "std::codecvt_utf8_utf16", { "<codecvt>" } }, // C++11
+{ "std::collate", { "<locale>" } },
+{ "std::collate_byname", { "<locale>" } },
+{ "std::common_type", { "<type_traits>" } }, // C++11
+{ "std::common_type_t", { "<type_traits>" } }, // C++14
+{ "std::complex", { "<complex>" } },
+{ "std::conditional", { "<type_traits>" } }, // C++11
+{ "std::conditional_t", { "<type_traits>" } }, // C++14
+{ "std::condition_variable", { "<condition_variable>" } }, // C++11
+{ "std::condition_variable_any", { "<condition_variable>" } }, // C++11
+{ "std::conjunction", { "<type_traits>" } }, // C++17
+{ "std::conjunction_v", { "<type_traits>" } }, // C++17
+{ "std::conj", { "<complex>" } },
+{ "std::copy", { "<algorithm>" } },
+{ "std::copy_backward", { "<algorithm>" } },
+{ "std::copy_if", { "<algorithm>" } }, // C++11
+{ "std::copy_n", { "<algorithm>" } }, // C++11
+{ "std::copysign", { "<cmath>" } }, // C++11
+{ "std::const_pointer_cast", { "<memory>" } }, // C++11
+{ "std::count", { "<algorithm>" } },
+{ "std::count_if", { "<algorithm>" } },
+{ "std::cout", { "<iostream>" } },
+{ "std::crbegin", { "<iterator>" } }, // C++14
+{ "std::cref", { "<functional>" } }, // C++11
+{ "std::cregex_iterator", { "<regex>" } }, // C++11
+{ "std::cregex_token_iterator", { "<regex>" } }, // C++11
+{ "std::crend", { "<iterator>" } }, // C++14
+{ "std::csub_match", { "<regex>" } }, // C++11
+{ "std::ctime", { "<ctime>" } },
+{ "std::ctype", { "<locale>" } },
+{ "std::ctype_base", { "<locale>" } },
+{ "std::ctype_byname", { "<locale>" } },
+{ "std::current_exception", { "<exception>" } }, // C++11
+{ "std::cv_status", { "<condition_variable>" } }, // C++11
+{ "std::data", { "<iterator>" } }, // C++17
+{ "std::dec", { "<ios>" } },
+{ "std::deca", { "<ratio>" } }, // C++11
+{ "std::decay", { "<type_traits>" } }, // C++11
+{ "std::decay_t", { "<type_traits>" } }, // C++14
+{ "std::deci", { "<ratio>" } }, // C++11
+{ "std::declare_no_pointers", { "<memory>" } }, // C++11
+{ "std::declare_reachable", { "<memory>" } }, // C++11
+{ "std::declval", { "<utility>" } }, // C++11
+{ "std::default_delete", { "<memory>" } }, // C++11
+{ "std::default_random_engine", { "<random>" } }, // C++11
+{ "std::default_searcher", { "<functional>" } }, // C++17
+{ "std::defaultfloat", { "<ios>" } }, // C++11
+{ "std::defer_lock", { "<mutex>" } }, // C++11
+{ "std::defer_lock_t", { "<mutex>" } }, // C++11
+{ "std::denorm_absent", { "<limits>" } },
+{ "std::denorm_indeterminate", { "<limits>" } },
+{ "std::denorm_present", { "<limits>" } },
+{ "std::deque", { "<deque>" } },
+{ "std::destroy", { "<memory>" } }, // C++17
+{ "std::destroy_at", { "<memory>" } }, // C++17
+{ "std::destroy_n", { "<memory>" } }, // C++17
+{ "std::difftime", { "<ctime>" } },
+{ "std::discrete_distribution", { "<random>" } }, // C++11
+{ "std::discard_block_engine", { "<random>" } }, // C++11
+{ "std::disjunction", { "<type_traits>" } }, // C++17
+{ "std::disjunction_v", { "<type_traits>" } }, // C++17
+{ "std::distance", { "<iterator>" } },
+{ "std::div", { "<cstdlib>" } },
+{ "std::div_t", { "<cstdlib>" } },
+{ "std::divides", { "<functional>" } },
+{ "std::domain_error", { "<stdexcept>" } },
+{ "std::double_t", { "<cmath>" } }, // C++11
+{ "std::dynamic_pointer_cast", { "<memory>" } }, // C++11
+{ "std::empty", { "<iterator>" } }, // C++17
+{ "std::enable_if", { "<type_traits>" } }, // C++11
+{ "std::enable_if_t", { "<type_traits>" } }, // C++14
+{ "std::enable_shared_from_this", { "<memory>" } }, // C++11
+{ "std::end", { "<iterator>" } }, // C++11
+{ "std::endl", { "<ostream>" } },
+{ "std::ends", { "<ostream>" } },
+{ "std::equal", { "<algorithm>" } },
+{ "std::equal_range", { "<algorithm>" } },
+{ "std::equal_to", { "<functional>" } },
+{ "std::erf", { "<cmath>" } }, // C++11
+{ "std::erfc", { "<cmath>" } }, // C++11
+{ "std::errc", { "<system_error>" } }, // C++11
+{ "std::error_category", { "<system_error>" } }, // C++11
+{ "std::error_code", { "<system_error>" } }, // C++11
+{ "std::error_condition", { "<system_error>" } }, // C++11
+{ "std::exa", { "<ratio>" } }, // C++11
+{ "std::exception", { "<exception>" } },
+{ "std::exception_ptr", { "<exception>" } }, // C++11
+{ "std::exchange", { "<utility>" } }, // C++14
+{ "std::exclusive_scan", { "<numeric>" } }, // C++17
+{ "std::exit", { "<cstdlib>" } },
+{ "std::exp2", { "<cmath>" } }, // C++11
+{ "std::expm1", { "<cmath>" } }, // C++11
+{ "std::exponential_distribution", { "<random>" } }, // C++11
+{ "std::extent", { "<type_traits>" } }, // C++11
+{ "std::extent_v", { "<type_traits>" } }, // C++17
+{ "std::extreme_value_distribution", { "<random>" } }, // C++11
+{ "std::fclose", { "<cstdio>" } },
+{ "std::false_type", { "<type_traits>" } }, // C++11
+{ "std::fdim", { "<cmath>" } }, // C++11
+{ "std::feclearexcept", { "<cfenv>" } }, // C++11
+{ "std::fegetenv", { "<cfenv>" } }, // C++11
+{ "std::fegetexceptflag", { "<cfenv>" } }, // C++11
+{ "std::fegetround", { "<cfenv>" } }, // C++11
+{ "std::feholdexcept", { "<cfenv>" } }, // C++11
+{ "std::fenv_t", { "<cfenv>" } }, // C++11
+{ "std::femto", { "<ratio>" } }, // C++11
+{ "std::feof", { "<cstdio>" } },
+{ "std::feraiseexcept", { "<cfenv>" } }, // C++11
+{ "std::ferror", { "<cstdio>" } },
+{ "std::fesetenv", { "<cfenv>" } }, // C++11
+{ "std::fesetexceptflag", { "<cfenv>" } }, // C++11
+{ "std::fesetround", { "<cfenv>" } }, // C++11
+{ "std::fetestexcept", { "<cfenv>" } }, // C++11
+{ "std::feupdateenv", { "<cfenv>" } }, // C++11
+{ "std::fexcept_t", { "<cfenv>" } }, // C++11
+{ "std::fflush", { "<cstdio>" } },
+{ "std::fgetc", { "<cstdio>" } },
+{ "std::fgetpos", { "<cstdio>" } },
+{ "std::fgets", { "<cstdio>" } },
+{ "std::fgetwc", { "<cwchar>" } },
+{ "std::fgetws", { "<cwchar>" } },
+{ "std::FILE", { "<cstdio>" } },
+{ "std::fill", { "<algorithm>" } },
+{ "std::fill_n", { "<algorithm>" } },
+{ "std::find", { "<algorithm>" } },
+{ "std::find_end", { "<algorithm>" } },
+{ "std::find_first_of", { "<algorithm>" } },
+{ "std::find_if", { "<algorithm>" } },
+{ "std::find_if_not", { "<algorithm>" } }, // C++17
+{ "std::fisher_f_distribution", { "<random>" } }, // C++11
+{ "std::fixed", { "<ios>" } },
+{ "std::float_denorm_style", { "<limits>" } },
+{ "std::float_round_style", { "<limits>" } },
+{ "std::floor", { "<cmath>" } },
+{ "std::flush", { "<ostream>" } },
+{ "std::fma", { "<cmath>" } }, // C++11
+{ "std::fmax", { "<cmath>" } }, // C++11
+{ "std::fmin", { "<cmath>" } }, // C++11
+{ "std::fmod", { "<cmath>" } },
+{ "std::float_t", { "<cmath>" } }, // C++11
+{ "std::fopen", { "<cstdio>" } },
+{ "std::for_each", { "<algorithm>" } },
+{ "std::for_each_n", { "<algorithm>" } }, // C++17
+{ "std::forward", { "<utility>" } }, // C++11
+{ "std::forward_as_tuple", { "<tuple>" } }, // C++11
+{ "std::forward_iterator_tag", { "<iterator>" } },
+{ "std::forward_list", { "<forward_list>" } }, // C++11
+{ "std::fpclassify", { "<cmath>" } }, // C++11
+{ "std::fpos", { "<ios>" } },
+{ "std::fpos_t", { "<cstdio>" } },
+{ "std::fprintf", { "<cstdio>" } },
+{ "std::fputc", { "<cstdio>" } },
+{ "std::fputs", { "<cstdio>" } },
+{ "std::fputwc", { "<cwchar>" } },
+{ "std::fputws", { "<cwchar>" } },
+{ "std::fread", { "<cstdio>" } },
+{ "std::free", { "<cstdlib>" } },
+{ "std::freopen", { "<cstdio>" } },
+{ "std::frexp", { "<cmath>" } },
+{ "std::front_inserter", { "<iterator>" } },
+{ "std::front_insert_iterator", { "<iterator>" } },
+{ "std::from_chars", { "<charconv>" } }, // C++17
+{ "std::fscanf", { "<cstdio>" } },
+{ "std::fseek", { "<cstdio>" } },
+{ "std::fsetpos", { "<cstdio>" } },
+{ "std::fstream", { "<fstream>" } },
+{ "std::ftell", { "<cstdio>" } },
+{ "std::function", { "<functional>" } }, // C++11
+{ "std::future", { "<future>" } }, // C++11
+{ "std::future_category", { "<future>" } }, // C++11
+{ "std::future_errc", { "<future>" } }, // C++11
+{ "std::future_error", { "<future>" } }, // C++11
+{ "std::future_status", { "<future>" } }, // C++11
+{ "std::fwide", { "<cwchar>" } },
+{ "std::fwprintf", { "<cwchar>" } },
+{ "std::fwrite", { "<cstdio>" } },
+{ "std::fwscanf", { "<cwchar>" } },
+{ "std::gamma_distribution", { "<random>" } }, // C++11
+{ "std::gcd", { "<numeric>" } }, // C++17
+{ "std::generate", { "<algorithm>" } },
+{ "std::generate_canonical", { "<random>" } }, // C++11
+{ "std::generate_n", { "<algorithm>" } },
+{ "std::generic_category", { "<system_error>" } }, // C++11
+{ "std::geometric_distribution", { "<random>" } }, // C++11
+{ "std::get_if", { "<variant>" } }, // C++17
+{ "std::get_money", { "<iomanip>" } }, // C++11
+{ "std::get_new_handler", { "<new>" } }, // C++11
+{ "std::get_pointer_safety", { "<memory>" } }, // C++11
+{ "std::get_terminate", { "<exception>" } }, // C++11
+{ "std::get_time", { "<iomanip>" } }, // C++11
+{ "std::getc", { "<cstdio>" } },
+{ "std::getchar", { "<cstdio>" } },
+{ "std::getenv", { "<cstdlib>" } },
+{ "std::gets", { "<cstdio>" } },
+{ "std::getwc", { "<cwchar>" } },
+{ "std::getwchar", { "<cwchar>" } },
+{ "std::giga", { "<ratio>" } }, // C++11
+{ "std::gmtime", { "<ctime>" } },
+{ "std::greater", { "<functional>" } },
+{ "std::greater_equal", { "<functional>" } },
+{ "std::gslice", { "<valarray>" } },
+{ "std::gslice_array", { "<valarray>" } },
+{ "std::hardware_constructive_interference_size", { "<new>" } }, // C++11
+{ "std::hardware_destructive_interference_size", { "<new>" } }, // C++11
+{ "std::has_facet", { "<locale>" } },
+{ "std::hash", { "<functional>" } }, // C++11
+{ "std::has_unique_object_representations", { "<type_traits>" } }, // C++17
+{ "std::has_unique_object_representations_v", { "<type_traits>" } }, // C++17
+{ "std::has_virtual_destructor", { "<type_traits>" } }, // C++11
+{ "std::has_virtual_destructor_v", { "<type_traits>" } }, // C++17
+{ "std::hecto", { "<ratio>" } }, // C++11
+{ "std::hex", { "<ios>" } },
+{ "std::hexfloat", { "<ios>" } }, // C++11
+{ "std::holds_alternative", { "<variant>" } }, // C++17
+{ "std::hypot", { "<cmath>" } }, // C++11
+{ "std::ifstream", { "<fstream>" } },
+{ "std::ignore", { "<tuple>" } }, // C++11
+{ "std::ilogb", { "<cmath>" } }, // C++11
+{ "std::imag", { "<complex>" } },
+{ "std::imaxdiv", { "<cstdlib>" } }, // C++11
+{ "std::imaxdiv_t", { "<cstdlib>" } }, // C++11
+{ "std::includes", { "<algorithm>" } },
+{ "std::inclusive_scan", { "<numeric>" } }, // C++17
+{ "std::independent_bits_engine", { "<random>" } }, // C++11
+{ "std::indirect_array", { "<valarray>" } },
+{ "std::initializer_list", { "<initializer_list>" } }, // C++11
+{ "std::inner_product", { "<numeric>" } },
+{ "std::in_place", { "<utility>" } }, // C++17
+{ "std::in_place_index", { "<utility>" } }, // C++17
+{ "std::in_place_index_t", { "<utility>" } }, // C++17
+{ "std::in_place_t", { "<utility>" } }, // C++17
+{ "std::inplace_merge", { "<algorithm>" } },
+{ "std::in_place_type", { "<utility>" } }, // C++17
+{ "std::in_place_type_t", { "<utility>" } }, // C++17
+{ "std::input_iterator_tag", { "<iterator>" } },
+{ "std::inserter", { "<iterator>" } },
+{ "std::insert_iterator", { "<iterator>" } },
+{ "std::int_fast16_t", { "<cstdint>" } }, // C++11
+{ "std::int_fast32_t", { "<cstdint>" } }, // C++11
+{ "std::int_fast64_t", { "<cstdint>" } }, // C++11
+{ "std::int_fast8_t", { "<cstdint>" } }, // C++11
+{ "std::int_least16_t", { "<cstdint>" } }, // C++11
+{ "std::int_least32_t", { "<cstdint>" } }, // C++11
+{ "std::int_least64_t", { "<cstdint>" } }, // C++11
+{ "std::int_least8_t", { "<cstdint>" } }, // C++11
+{ "std::int16_t", { "<cstdint>" } }, // C++11
+{ "std::int32_t", { "<cstdint>" } }, // C++11
+{ "std::int64_t", { "<cstdint>" } }, // C++11
+{ "std::int8_t", { "<cstdint>" } }, // C++11
+{ "std::integer_sequence", { "<utility>" } }, // C++14
+{ "std::integral_constant", { "<type_traits>" } }, // C++11
+{ "std::internal", { "<ios>" } },
+{ "std::intmax_t", { "<cstdint>" } }, // C++11
+{ "std::intptr_t", { "<cstdint>" } }, // C++11
+{ "std::invalid_argument", { "<stdexcept>" } },
+{ "std::invoke", { "<functional>" } }, // C++17
+{ "std::invoke_result", { "<type_traits>" } }, // C++17
+{ "std::invoke_result_t", { "<type_traits>" } }, // C++17
+{ "std::ios", { "<ios>" } },
+{ "std::io_errc", { "<ios>" } }, // C++11
+{ "std::ios_base", { "<ios>" } },
+{ "std::iostream", { "<istream>" } },
+{ "std::iostream_category", { "<ios>" } }, // C++11
+{ "std::iota", { "<numeric>" } }, // C++11
+{ "std::is_abstract", { "<type_traits>" } }, // C++11
+{ "std::is_abstract_v", { "<type_traits>" } }, // C++17
+{ "std::is_aggregate", { "<type_traits>" } }, // C++17
+{ "std::is_aggregate_v", { "<type_traits>" } }, // C++17
+{ "std::is_arithmetic", { "<type_traits>" } }, // C++11
+{ "std::is_arithmetic_v", { "<type_traits>" } }, // C++17
+{ "std::is_array", { "<type_traits>" } }, // C++11
+{ "std::is_array_v", { "<type_traits>" } }, // C++17
+{ "std::is_assignable", { "<type_traits>" } }, // C++11
+{ "std::is_assignable_v", { "<type_traits>" } }, // C++17
+{ "std::is_base_of", { "<type_traits>" } }, // C++11
+{ "std::is_base_of_v", { "<type_traits>" } }, // C++17
+{ "std::is_bind_expression", { "<functional>" } }, // C++11
+{ "std::is_bind_expression_v", { "<functional>" } }, // C++17
+{ "std::is_class", { "<type_traits>" } }, // C++11
+{ "std::is_class_v", { "<type_traits>" } }, // C++17
+{ "std::is_compound", { "<type_traits>" } }, // C++11
+{ "std::is_compound_v", { "<type_traits>" } }, // C++17
+{ "std::is_const", { "<type_traits>" } }, // C++11
+{ "std::is_constructible", { "<type_traits>" } }, // C++11
+{ "std::is_constructible_v", { "<type_traits>" } }, // C++17
+{ "std::is_const_v", { "<type_traits>" } }, // C++17
+{ "std::is_convertible", { "<type_traits>" } }, // C++11
+{ "std::is_convertible_v", { "<type_traits>" } }, // C++17
+{ "std::is_copy_assignable", { "<type_traits>" } }, // C++11
+{ "std::is_copy_assignable_v", { "<type_traits>" } }, // C++17
+{ "std::is_copy_constructible", { "<type_traits>" } }, // C++11
+{ "std::is_copy_constructible_v", { "<type_traits>" } }, // C++17
+{ "std::is_default_constructible", { "<type_traits>" } }, // C++11
+{ "std::is_default_constructible_v", { "<type_traits>" } }, // C++17
+{ "std::is_destructible", { "<type_traits>" } }, // C++11
+{ "std::is_destructible_v", { "<type_traits>" } }, // C++17
+{ "std::is_empty", { "<type_traits>" } }, // C++11
+{ "std::is_empty_v", { "<type_traits>" } }, // C++17
+{ "std::is_enum", { "<type_traits>" } }, // C++11
+{ "std::is_enum_v", { "<type_traits>" } }, // C++17
+{ "std::is_error_code_enum", { "<system_error>" } }, // C++11
+{ "std::is_error_condition_enum", { "<system_error>" } }, // C++11
+{ "std::is_error_condition_enum_v", { "<system_error>" } }, // C++17
+{ "std::is_execution_policy", { "<execution>" } }, // C++17
+{ "std::is_execution_policy_v", { "<execution>" } }, // C++17
+{ "std::is_final", { "<type_traits>" } }, // C++14
+{ "std::is_final_v", { "<type_traits>" } }, // C++17
+{ "std::is_floating_point", { "<type_traits>" } }, // C++11
+{ "std::is_floating_point_v", { "<type_traits>" } }, // C++17
+{ "std::is_function", { "<type_traits>" } }, // C++11
+{ "std::is_function_v", { "<type_traits>" } }, // C++17
+{ "std::is_fundamental", { "<type_traits>" } }, // C++11
+{ "std::is_fundamental_v", { "<type_traits>" } }, // C++17
+{ "std::is_heap", { "<algorithm>" } }, // C++11
+{ "std::is_heap_until", { "<algorithm>" } }, // C++11
+{ "std::is_integral", { "<type_traits>" } }, // C++11
+{ "std::is_integral_v", { "<type_traits>" } }, // C++17
+{ "std::is_invocable", { "<type_traits>" } }, // C++17
+{ "std::is_invocable_r", { "<type_traits>" } }, // C++17
+{ "std::is_invocable_r_v", { "<type_traits>" } }, // C++17
+{ "std::is_invocable_v", { "<type_traits>" } }, // C++17
+{ "std::is_lvalue_reference", { "<type_traits>" } }, // C++11
+{ "std::is_lvalue_reference_v", { "<type_traits>" } }, // C++17
+{ "std::is_member_function_pointer", { "<type_traits>" } }, // C++11
+{ "std::is_member_function_pointer_v", { "<type_traits>" } }, // C++17
+{ "std::is_member_object_pointer", { "<type_traits>" } }, // C++11
+{ "std::is_member_object_pointer_v", { "<type_traits>" } }, // C++17
+{ "std::is_member_pointer", { "<type_traits>" } }, // C++11
+{ "std::is_member_pointer_v", { "<type_traits>" } }, // C++17
+{ "std::is_move_assignable", { "<type_traits>" } }, // C++11
+{ "std::is_move_assignable_v", { "<type_traits>" } }, // C++17
+{ "std::is_move_constructible", { "<type_traits>" } }, // C++11
+{ "std::is_move_constructible_v", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_assignable", { "<type_traits>" } }, // C++11
+{ "std::is_nothrow_assignable_v", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_constructible", { "<type_traits>" } }, // C++11
+{ "std::is_nothrow_constructible_v", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_copy_assignable", { "<type_traits>" } }, // C++11
+{ "std::is_nothrow_copy_assignable_v", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_copy_constructible", { "<type_traits>" } }, // C++11
+{ "std::is_nothrow_copy_constructible_v", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_default_constructible", { "<type_traits>" } }, // C++11
+{ "std::is_nothrow_default_constructible_v", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_destructible", { "<type_traits>" } }, // C++11
+{ "std::is_nothrow_destructible_v", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_invocable", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_invocable_r", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_invocable_v", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_invocable_r_v", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_move_assignable", { "<type_traits>" } }, // C++11
+{ "std::is_nothrow_move_assignable_v", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_move_constructible", { "<type_traits>" } }, // C++11
+{ "std::is_nothrow_move_constructible_v", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_swappable", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_swappable_v", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_swappable_with", { "<type_traits>" } }, // C++17
+{ "std::is_nothrow_swappable_with_v", { "<type_traits>" } }, // C++17
+{ "std::is_null_pointer", { "<type_traits>" } }, // C++11
+{ "std::is_null_pointer_v", { "<type_traits>" } }, // C++17
+{ "std::is_object", { "<type_traits>" } }, // C++11
+{ "std::is_object_v", { "<type_traits>" } }, // C++17
+{ "std::is_partitioned", { "<algorithm>" } }, // C++11
+{ "std::is_permutation", { "<algorithm>" } }, // C++11
+{ "std::is_placeholder", { "<functional>" } }, // C++11
+{ "std::is_placeholder_v", { "<functional>" } }, // C++17
+{ "std::is_pod", { "<type_traits>" } }, // C++11
+{ "std::is_pod_v", { "<type_traits>" } }, // C++17
+{ "std::is_pointer", { "<type_traits>" } }, // C++11
+{ "std::is_pointer_v", { "<type_traits>" } }, // C++17
+{ "std::is_polymorphic", { "<type_traits>" } }, // C++11
+{ "std::is_polymorphic_v", { "<type_traits>" } }, // C++17
+{ "std::is_reference", { "<type_traits>" } }, // C++11
+{ "std::is_reference_v", { "<type_traits>" } }, // C++17
+{ "std::is_rvalue_reference", { "<type_traits>" } }, // C++11
+{ "std::is_rvalue_reference_v", { "<type_traits>" } }, // C++17
+{ "std::is_same", { "<type_traits>" } }, // C++11
+{ "std::is_same_v", { "<type_traits>" } }, // C++17
+{ "std::is_scalar", { "<type_traits>" } }, // C++11
+{ "std::is_scalar_v", { "<type_traits>" } }, // C++17
+{ "std::is_signed", { "<type_traits>" } }, // C++11
+{ "std::is_signed_v", { "<type_traits>" } }, // C++17
+{ "std::is_sorted", { "<algorithm>" } }, // C++11
+{ "std::is_sorted_until", { "<algorithm>" } }, // C++11
+{ "std::is_standard_layout", { "<type_traits>" } }, // C++11
+{ "std::is_standard_layout_v", { "<type_traits>" } }, // C++17
+{ "std::is_swappable", { "<type_traits>" } }, // C++17
+{ "std::is_swappable_v", { "<type_traits>" } }, // C++17
+{ "std::is_swappable_with", { "<type_traits>" } }, // C++17
+{ "std::is_swappable_with_v", { "<type_traits>" } }, // C++17
+{ "std::is_trivial", { "<type_traits>" } }, // C++11
+{ "std::is_trivially_assignable", { "<type_traits>" } }, // C++11
+{ "std::is_trivially_assignable_v", { "<type_traits>" } }, // C++17
+{ "std::is_trivially_constructible", { "<type_traits>" } }, // C++11
+{ "std::is_trivially_constructible_v", { "<type_traits>" } }, // C++17
+{ "std::is_trivially_copyable", { "<type_traits>" } }, // C++11
+{ "std::is_trivially_copyable_v", { "<type_traits>" } }, // C++17
+{ "std::is_trivially_copy_assignable", { "<type_traits>" } }, // C++11
+{ "std::is_trivially_copy_assignable_v", { "<type_traits>" } }, // C++17
+{ "std::is_trivially_copy_constructible", { "<type_traits>" } }, // C++11
+{ "std::is_trivially_copy_constructible_v", { "<type_traits>" } }, // C++17
+{ "std::is_trivially_default_constructible", { "<type_traits>" } }, // C++11
+{ "std::is_trivially_default_constructible_v", { "<type_traits>" } }, // C++17
+{ "std::is_trivially_destructible", { "<type_traits>" } }, // C++11
+{ "std::is_trivially_destructible_v", { "<type_traits>" } }, // C++17
+{ "std::is_trivially_move_assignable", { "<type_traits>" } }, // C++11
+{ "std::is_trivially_move_assignable_v", { "<type_traits>" } }, // C++17
+{ "std::is_trivially_move_constructible", { "<type_traits>" } }, // C++11
+{ "std::is_trivially_move_constructible_v", { "<type_traits>" } }, // C++17
+{ "std::is_trivial_v", { "<type_traits>" } }, // C++17
+{ "std::is_union", { "<type_traits>" } }, // C++11
+{ "std::is_union_v", { "<type_traits>" } }, // C++17
+{ "std::is_unsigned", { "<type_traits>" } }, // C++11
+{ "std::is_unsigned_v", { "<type_traits>" } }, // C++17
+{ "std::is_void", { "<type_traits>" } }, // C++11
+{ "std::is_void_v", { "<type_traits>" } }, // C++17
+{ "std::is_volatile", { "<type_traits>" } }, // C++11
+{ "std::is_volatile_v", { "<type_traits>" } }, // C++17
+{ "std::isfinite", { "<cmath>" } }, // C++11
+{ "std::isgreater", { "<cmath>" } }, // C++11
+{ "std::isgreaterequal", { "<cmath>" } }, // C++11
+{ "std::isinf", { "<cmath>" } }, // C++11
+{ "std::isless", { "<cmath>" } }, // C++11
+{ "std::islessequal", { "<cmath>" } }, // C++11
+{ "std::islessgreater", { "<cmath>" } }, // C++11
+{ "std::isnan", { "<cmath>" } }, // C++11
+{ "std::isnormal", { "<cmath>" } }, // C++11
+{ "std::istream", { "<istream>" } },
+{ "std::istreambuf_iterator", { "<iterator>" } },
+{ "std::istream_iterator", { "<iterator>" } },
+{ "std::istringstream", { "<sstream>" } },
+{ "std::isunordered", { "<cmath>" } }, // C++11
+{ "std::iswalnum", { "<cwctype>" } },
+{ "std::iswalpha", { "<cwctype>" } },
+{ "std::iswblank", { "<cwctype>" } }, // C++11
+{ "std::iswcntrl", { "<cwctype>" } },
+{ "std::iswctype", { "<cwctype>" } },
+{ "std::iswdigit", { "<cwctype>" } },
+{ "std::iswgraph", { "<cwctype>" } },
+{ "std::iswlower", { "<cwctype>" } },
+{ "std::iswprint", { "<cwctype>" } },
+{ "std::iswpunct", { "<cwctype>" } },
+{ "std::iswspace", { "<cwctype>" } },
+{ "std::iswupper", { "<cwctype>" } },
+{ "std::iswxdigit", { "<cwctype>" } },
+{ "std::iterator", { "<iterator>" } },
+{ "std::iterator_traits", { "<iterator>" } },
+{ "std::iter_swap", { "<algorithm>" } },
+{ "std::jmp_buf", { "<csetjmp>" } },
+{ "std::kill_dependency", { "<atomic>" } }, // C++11
+{ "std::kilo", { "<ratio>" } }, // C++11
+{ "std::knuth_b", { "<random>" } }, // C++11
+{ "std::launch", { "<future>" } }, // C++11
+{ "std::launder", { "<new>" } }, // C++17
+{ "std::lcm", { "<numeric>" } }, // C++17
+{ "std::lconv", { "<clocale>" } },
+{ "std::ldexp", { "<cmath>" } },
+{ "std::ldiv", { "<cstdlib>" } },
+{ "std::ldiv_t", { "<cstdlib>" } },
+{ "std::left", { "<ios>" } },
+{ "std::length_error", { "<stdexcept>" } },
+{ "std::less", { "<functional>" } },
+{ "std::less_equal", { "<functional>" } },
+{ "std::lexicographical_compare", { "<algorithm>" } },
+{ "std::lgamma", { "<cmath>" } }, // C++11
+{ "std::linear_congruential_engine", { "<random>" } }, // C++11
+{ "std::list", { "<list>" } },
+{ "std::lldiv", { "<cstdlib>" } }, // C++11
+{ "std::lldiv_t", { "<cstdlib>" } }, // C++11
+{ "std::llrint", { "<cmath>" } }, // C++11
+{ "std::llround", { "<cmath>" } }, // C++11
+{ "std::locale", { "<locale>" } },
+{ "std::localeconv", { "<clocale>" } },
+{ "std::localtime", { "<ctime>" } },
+{ "std::lock", { "<mutex>" } }, // C++11
+{ "std::lock_guard", { "<mutex>" } }, // C++11
+{ "std::logb", { "<cmath>" } }, // C++11
+{ "std::log1p", { "<cmath>" } }, // C++11
+{ "std::log2", { "<cmath>" } }, // C++11
+{ "std::logical_and", { "<functional>" } },
+{ "std::logic_error", { "<stdexcept>" } },
+{ "std::lognormal_distribution", { "<random>" } }, // C++11
+{ "std::logical_not", { "<functional>" } },
+{ "std::logical_or", { "<functional>" } },
+{ "std::longjmp", { "<csetjmp>" } },
+{ "std::lower_bound", { "<algorithm>" } },
+{ "std::lrint", { "<cmath>" } }, // C++11
+{ "std::lround", { "<cmath>" } }, // C++11
+{ "std::make_exception_ptr", { "<exception>" } }, // C++11
+{ "std::make_from_tuple", { "<tuple>" } }, // C++17
+{ "std::make_heap", { "<algorithm>" } },
+{ "std::make_move_iterator", { "<iterator>" } }, // C++11
+{ "std::make_optional", { "<optional>" } }, // C++17
+{ "std::make_pair", { "<utility>" } },
+{ "std::make_reverse_iterator", { "<iterator>" } }, // C++14
+{ "std::make_shared", { "<memory>" } }, // C++11
+{ "std::make_signed", { "<type_traits>" } }, // C++11
+{ "std::make_signed_t", { "<type_traits>" } }, // C++14
+{ "std::make_tuple", { "<tuple>" } }, // C++11
+{ "std::make_unique", { "<memory>" } }, // C++14
+{ "std::make_unsigned", { "<type_traits>" } }, // C++11
+{ "std::make_unsigned_t", { "<type_traits>" } }, // C++14
+{ "std::malloc", { "<cstdlib>" } },
+{ "std::map", { "<map>" } },
+{ "std::mask_array", { "<valarray>" } },
+{ "std::match_results", { "<regex>" } }, // C++11
+{ "std::max", { "<algorithm>" } },
+{ "std::max_align_t", { "<cstddef>" } }, // C++11
+{ "std::max_element", { "<algorithm>" } },
+{ "std::mblen", { "<cstdlib>" } },
+{ "std::mbrlen", { "<cwchar>" } },
+{ "std::mbrtoc16", { "<cuchar>" } }, // C++11
+{ "std::mbrtoc32", { "<cuchar>" } }, // C++11
+{ "std::mbrtowc", { "<cwchar>" } },
+{ "std::mbsinit", { "<cwchar>" } },
+{ "std::mbsrtowcs", { "<cwchar>" } },
+{ "std::mbstowcs", { "<cstdlib>" } },
+{ "std::mbtowc", { "<cstdlib>" } },
+{ "std::mega", { "<ratio>" } }, // C++11
+{ "std::mem_fn", { "<functional>" } }, // C++11
+{ "std::memchr", { "<cstring>" } },
+{ "std::memcmp", { "<cstring>" } },
+{ "std::memcpy", { "<cstring>" } },
+{ "std::memmove", { "<cstring>" } },
+{ "std::memory_order", { "<atomic>" } }, // C++11
+{ "std::memory_order_acq_rel", { "<atomic>" } }, // C++11
+{ "std::memory_order_acquire", { "<atomic>" } }, // C++11
+{ "std::memory_order_consume", { "<atomic>" } }, // C++11
+{ "std::memory_order_relaxed", { "<atomic>" } }, // C++11
+{ "std::memory_order_release", { "<atomic>" } }, // C++11
+{ "std::memory_order_seq_cst", { "<atomic>" } }, // C++11
+{ "std::memset", { "<cstring>" } },
+{ "std::merge", { "<algorithm>" } },
+{ "std::mersenne_twister_engine", { "<random>" } }, // C++11
+{ "std::messages", { "<locale>" } },
+{ "std::messages_base", { "<locale>" } },
+{ "std::messages_byname", { "<locale>" } },
+{ "std::micro", { "<ratio>" } }, // C++11
+{ "std::milli", { "<ratio>" } }, // C++11
+{ "std::min", { "<algorithm>" } },
+{ "std::min_element", { "<algorithm>" } },
+{ "std::minmax", { "<algorithm>" } }, // C++11
+{ "std::minmax_element", { "<algorithm>" } }, // C++11
+{ "std::minstd_rand", { "<random>" } }, // C++11
+{ "std::minstd_rand0", { "<random>" } }, // C++11
+{ "std::minus", { "<functional>" } },
+{ "std::mismatch", { "<algorithm>" } },
+{ "std::mktime", { "<ctime>" } },
+{ "std::modf", { "<cmath>" } },
+{ "std::modulus", { "<functional>" } },
+{ "std::money_base", { "<locale>" } },
+{ "std::money_get", { "<locale>" } },
+{ "std::moneypunct", { "<locale>" } },
+{ "std::moneypunct_byname", { "<locale>" } },
+{ "std::money_put", { "<locale>" } },
+{ "std::monostate", { "<variant>" } }, // C++17
+{ "std::move_backward", { "<algorithm>" } }, // C++11
+{ "std::move_if_noexcept", { "<utility>" } }, // C++11
+{ "std::move_iterator", { "<iterator>" } }, // C++11
+{ "std::mt19937", { "<random>" } }, // C++11
+{ "std::mt19937_64", { "<random>" } }, // C++11
+{ "std::multimap", { "<map>" } },
+{ "std::multiplies", { "<functional>" } },
+{ "std::multiset", { "<set>" } },
+{ "std::mutex", { "<mutex>" } }, // C++11
+{ "std::nan", { "<cmath>" } }, // C++11
+{ "std::nanf", { "<cmath>" } }, // C++11
+{ "std::nanl", { "<cmath>" } }, // C++11
+{ "std::nano", { "<ratio>" } }, // C++11
+{ "std::nearbyint", { "<cmath>" } }, // C++11
+{ "std::negate", { "<functional>" } },
+{ "std::negation", { "<type_traits>" } }, // C++17
+{ "std::negation_v", { "<type_traits>" } }, // C++17
+{ "std::negative_binomial_distribution", { "<random>" } }, // C++11
+{ "std::nested_exception", { "<exception>" } }, // C++11
+{ "std::new_handler", { "<new>" } },
+{ "std::next", { "<iterator>" } }, // C++11
+{ "std::nextafter", { "<cmath>" } }, // C++11
+{ "std::next_permutation", { "<algorithm>" } },
+{ "std::nexttoward", { "<cmath>" } }, // C++11
+{ "std::noboolalpha", { "<ios>" } },
+{ "std::none_of", { "<algorithm>" } }, // C++11
+{ "std::norm", { "<complex>" } },
+{ "std::normal_distribution", { "<random>" } }, // C++11
+{ "std::noshowbase", { "<ios>" } },
+{ "std::noshowpoint", { "<ios>" } },
+{ "std::noshowpos", { "<ios>" } },
+{ "std::noskipws", { "<ios>" } },
+{ "std::not_equal_to", { "<functional>" } },
+{ "std::not_fn", { "<functional>" } }, // C++17
+{ "std::nothrow", { "<new>" } },
+{ "std::nothrow_t", { "<new>" } },
+{ "std::notify_all_at_thread_exit", { "<condition_variable>" } }, // C++11
+{ "std::nounitbuf", { "<ios>" } },
+{ "std::nouppercase", { "<ios>" } },
+{ "std::nth_element", { "<algorithm>" } },
+{ "std::nullopt", { "<optional>" } }, // C++17
+{ "std::nullopt_t", { "<optional>" } }, // C++17
+{ "std::nullptr_t", { "<cstddef>" } }, // C++11
+{ "std::numeric_limits", { "<limits>" } },
+{ "std::num_get", { "<locale>" } },
+{ "std::numpunct", { "<locale>" } },
+{ "std::numpunct_byname", { "<locale>" } },
+{ "std::num_put", { "<locale>" } },
+{ "std::oct", { "<ios>" } },
+{ "std::once_flag", { "<mutex>" } }, // C++11
+{ "std::ofstream", { "<fstream>" } },
+{ "std::optional", { "<optional>" } }, // C++17
+{ "std::ostream", { "<ostream>" } },
+{ "std::ostreambuf_iterator", { "<iterator>" } },
+{ "std::ostream_iterator", { "<iterator>" } },
+{ "std::ostringstream", { "<sstream>" } },
+{ "std::out_of_range", { "<stdexcept>" } },
+{ "std::output_iterator_tag", { "<iterator>" } },
+{ "std::overflow_error", { "<stdexcept>" } },
+{ "std::owner_less", { "<memory>" } }, // C++11
+{ "std::packaged_task", { "<future>" } }, // C++11
+{ "std::pair", { "<utility>" } },
+{ "std::partial_sort", { "<algorithm>" } },
+{ "std::partial_sort_copy", { "<algorithm>" } },
+{ "std::partial_sum", { "<numeric>" } },
+{ "std::partition", { "<algorithm>" } },
+{ "std::partition_copy", { "<algorithm>" } }, // C++11
+{ "std::partition_point", { "<algorithm>" } }, // C++11
+{ "std::perror", { "<cstdio>" } },
+{ "std::peta", { "<ratio>" } }, // C++11
+{ "std::pico", { "<ratio>" } }, // C++11
+{ "std::piecewise_constant_distribution", { "<random>" } }, // C++11
+{ "std::piecewise_construct_t", { "<utility>" } }, // C++11
+{ "std::piecewise_linear_distribution", { "<random>" } }, // C++11
+{ "std::plus", { "<functional>" } },
+{ "std::pointer_safety", { "<memory>" } }, // C++11
+{ "std::pointer_traits", { "<memory>" } }, // C++11
+{ "std::poisson_distribution", { "<random>" } }, // C++11
+{ "std::polymorphic_allocator", { "<memory_resource>" } }, // C++17
+{ "std::polar", { "<complex>" } },
+{ "std::pop_heap", { "<algorithm>" } },
+{ "std::prev", { "<iterator>" } }, // C++11
+{ "std::prev_permutation", { "<algorithm>" } },
+{ "std::printf", { "<cstdio>" } },
+{ "std::priority_queue", { "<queue>" } },
+{ "std::proj", { "<complex>" } }, // C++11
+{ "std::promise", { "<future>" } }, // C++11
+{ "std::ptrdiff_t", { "<cstddef>" } },
+{ "std::push_heap", { "<algorithm>" } },
+{ "std::put_money", { "<iomanip>" } }, // C++11
+{ "std::put_time", { "<iomanip>" } }, // C++11
+{ "std::putc", { "<cstdio>" } },
+{ "std::putchar", { "<cstdio>" } },
+{ "std::puts", { "<cstdio>" } },
+{ "std::putwc", { "<cwchar>" } },
+{ "std::putwchar", { "<cwchar>" } },
+{ "std::qsort", { "<cstdlib>" } },
+{ "std::queue", { "<queue>" } },
+{ "std::quick_exit", { "<cstdlib>" } }, // C++11
+{ "std::quoted", { "<iomanip>" } }, // C++14
+{ "std::raise", { "<csignal>" } },
+{ "std::rand", { "<cstdlib>" } },
+{ "std::random_access_iterator_tag", { "<iterator>" } },
+{ "std::random_device", { "<random>" } }, // C++11
+{ "std::random_shuffle", { "<algorithm>" } },
+{ "std::range_error", { "<stdexcept>" } },
+{ "std::ranlux24", { "<random>" } }, // C++11
+{ "std::ranlux24_base", { "<random>" } }, // C++11
+{ "std::ranlux48", { "<random>" } }, // C++11
+{ "std::ranlux48_base", { "<random>" } }, // C++11
+{ "std::rank", { "<type_traits>" } }, // C++11
+{ "std::rank_v", { "<type_traits>" } }, // C++17
+{ "std::ratio", { "<ratio>" } }, // C++11
+{ "std::ratio_add", { "<ratio>" } }, // C++11
+{ "std::ratio_divide", { "<ratio>" } }, // C++11
+{ "std::ratio_equal", { "<ratio>" } }, // C++11
+{ "std::ratio_equal_v", { "<ratio>" } }, // C++17
+{ "std::ratio_greater", { "<ratio>" } }, // C++11
+{ "std::ratio_greater_equal", { "<ratio>" } }, // C++11
+{ "std::ratio_greater_equal_v", { "<ratio>" } }, // C++17
+{ "std::ratio_greater_v", { "<ratio>" } }, // C++17
+{ "std::ratio_less", { "<ratio>" } }, // C++11
+{ "std::ratio_less_equal", { "<ratio>" } }, // C++11
+{ "std::ratio_less_equal_v", { "<ratio>" } }, // C++17
+{ "std::ratio_less_v", { "<ratio>" } }, // C++17
+{ "std::ratio_multiply", { "<ratio>" } }, // C++11
+{ "std::ratio_not_equal", { "<ratio>" } }, // C++11
+{ "std::ratio_not_equal_v", { "<ratio>" } }, // C++17
+{ "std::ratio_subtract", { "<ratio>" } }, // C++11
+{ "std::rbegin", { "<iterator>" } }, // C++14
+{ "std::real", { "<complex>" } },
+{ "std::realloc", { "<cstdlib>" } },
+{ "std::recursive_mutex", { "<mutex>" } }, // C++11
+{ "std::recursive_timed_mutex", { "<mutex>" } }, // C++11
+{ "std::reduce", { "<numeric>" } }, // C++17
+{ "std::ref", { "<functional>" } }, // C++11
+{ "std::reference_wrapper", { "<functional>" } }, // C++11
+{ "std::regex", { "<regex>" } }, // C++11
+{ "std::regex_error", { "<regex>" } }, // C++11
+{ "std::regex_iterator", { "<regex>" } }, // C++11
+{ "std::regex_match", { "<regex>" } }, // C++11
+{ "std::regex_replace", { "<regex>" } }, // C++11
+{ "std::regex_search", { "<regex>" } }, // C++11
+{ "std::regex_token_iterator", { "<regex>" } }, // C++11
+{ "std::regex_traits", { "<regex>" } }, // C++11
+{ "std::reinterpret_pointer_cast", { "<memory>" } }, // C++11
+{ "std::remainder", { "<cmath>" } }, // C++11
+{ "std::remove_all_extents", { "<type_traits>" } }, // C++11
+{ "std::remove_all_extents_t", { "<type_traits>" } }, // C++14
+{ "std::remove_const", { "<type_traits>" } }, // C++11
+{ "std::remove_const_t", { "<type_traits>" } }, // C++14
+{ "std::remove_copy", { "<algorithm>" } },
+{ "std::remove_copy_if", { "<algorithm>" } },
+{ "std::remove_cv", { "<type_traits>" } }, // C++11
+{ "std::remove_cv_t", { "<type_traits>" } }, // C++14
+{ "std::remove_extent", { "<type_traits>" } }, // C++11
+{ "std::remove_extent_t", { "<type_traits>" } }, // C++14
+{ "std::remove_pointer", { "<type_traits>" } }, // C++11
+{ "std::remove_pointer_t", { "<type_traits>" } }, // C++14
+{ "std::remove_reference", { "<type_traits>" } }, // C++11
+{ "std::remove_reference_t", { "<type_traits>" } }, // C++14
+{ "std::remove_volatile", { "<type_traits>" } }, // C++11
+{ "std::remove_volatile_t", { "<type_traits>" } }, // C++14
+{ "std::remquo", { "<cmath>" } }, // C++11
+{ "std::rend", { "<iterator>" } }, // C++14
+{ "std::rename", { "<cstdio>" } },
+{ "std::replace", { "<algorithm>" } },
+{ "std::replace_copy", { "<algorithm>" } },
+{ "std::replace_copy_if", { "<algorithm>" } },
+{ "std::replace_if", { "<algorithm>" } },
+{ "std::resetiosflags", { "<iomanip>" } },
+{ "std::result_of", { "<type_traits>" } }, // C++11
+{ "std::result_of_t", { "<type_traits>" } }, // C++14
+{ "std::rethrow_exception", { "<exception>" } }, // C++11
+{ "std::rethrow_if_nested", { "<exception>" } }, // C++11
+{ "std::reverse", { "<algorithm>" } },
+{ "std::reverse_copy", { "<algorithm>" } },
+{ "std::reverse_iterator", { "<iterator>" } },
+{ "std::rewind", { "<cstdio>" } },
+{ "std::right", { "<ios>" } },
+{ "std::rint", { "<cmath>" } }, // C++11
+{ "std::rotate", { "<algorithm>" } },
+{ "std::rotate_copy", { "<algorithm>" } },
+{ "std::round", { "<cmath>" } }, // C++11
+{ "std::round_indeterminate", { "<limits>" } },
+{ "std::round_to_nearest", { "<limits>" } },
+{ "std::round_toward_infinity", { "<limits>" } },
+{ "std::round_toward_neg_infinity", { "<limits>" } },
+{ "std::round_toward_zero", { "<limits>" } },
+{ "std::runtime_error", { "<stdexcept>" } },
+{ "std::sample", { "<algorithm>" } }, // C++17
+{ "std::scalbln", { "<cmath>" } }, // C++11
+{ "std::scalbn", { "<cmath>" } }, // C++11
+{ "std::scanf", { "<cstdio>" } },
+{ "std::scientific", { "<ios>" } },
+{ "std::scoped_allocator_adaptor", { "<scoped_allocator>" } }, // C++11
+{ "std::search", { "<algorithm>" } },
+{ "std::search_n", { "<algorithm>" } },
+{ "std::seed_seq", { "<random>" } }, // C++11
+{ "std::set", { "<set>" } },
+{ "std::set_difference", { "<algorithm>" } },
+{ "std::set_intersection", { "<algorithm>" } },
+{ "std::set_new_handler", { "<new>" } },
+{ "std::set_symmetric_difference", { "<algorithm>" } },
+{ "std::set_terminate", { "<exception>" } },
+{ "std::set_union", { "<algorithm>" } },
+{ "std::setbase", { "<iomanip>" } },
+{ "std::setbuf", { "<cstdio>" } },
+{ "std::setfill", { "<iomanip>" } },
+{ "std::setiosflags", { "<iomanip>" } },
+{ "std::setlocale", { "<clocale>" } },
+{ "std::setprecision", { "<iomanip>" } },
+{ "std::setvbuf", { "<cstdio>" } },
+{ "std::setw", { "<iomanip>" } },
+{ "std::shared_future", { "<future>" } }, // C++11
+{ "std::shared_lock", { "<shared_mutex>" } }, // C++14
+{ "std::shared_mutex", { "<shared_mutex>" } }, // C++17
+{ "std::shared_ptr", { "<memory>" } }, // C++11
+{ "std::shared_timed_mutex", { "<shared_mutex>" } }, // C++14
+{ "std::showbase", { "<ios>" } },
+{ "std::showpoint", { "<ios>" } },
+{ "std::showpos", { "<ios>" } },
+{ "std::shuffle", { "<algorithm>" } }, // C++11
+{ "std::shuffle_order_engine", { "<random>" } }, // C++11
+{ "std::sig_atomic_t", { "<csignal>" } },
+{ "std::signal", { "<csignal>" } },
+{ "std::signbit", { "<cmath>" } }, // C++11
+{ "std::size", { "<iterator>" } }, // C++17
+{ "std::skipws", { "<ios>" } },
+{ "std::slice", { "<valarray>" } },
+{ "std::slice_array", { "<valarray>" } },
+{ "std::smatch", { "<regex>" } }, // C++11
+{ "std::snprintf", { "<cstdio>" } }, // C++11
+{ "std::sort", { "<algorithm>" } },
+{ "std::sort_heap", { "<algorithm>" } },
+{ "std::sprintf", { "<cstdio>" } },
+{ "std::srand", { "<cstdlib>" } },
+{ "std::sregex_iterator", { "<regex>" } }, // C++11
+{ "std::sregex_token_iterator", { "<regex>" } }, // C++11
+{ "std::sscanf", { "<cstdio>" } },
+{ "std::ssub_match", { "<regex>" } }, // C++11
+{ "std::stable_partition", { "<algorithm>" } },
+{ "std::stable_sort", { "<algorithm>" } },
+{ "std::stack", { "<stack>" } },
+{ "std::static_pointer_cast", { "<memory>" } }, // C++11
+{ "std::strcat", { "<cstring>" } },
+{ "std::strchr", { "<cstring>" } },
+{ "std::strcmp", { "<cstring>" } },
+{ "std::strcoll", { "<cstring>" } },
+{ "std::strcpy", { "<cstring>" } },
+{ "std::strcspn", { "<cstring>" } },
+{ "std::streambuf", { "<streambuf>" } },
+{ "std::streamoff", { "<ios>" } },
+{ "std::streampos", { "<ios>" } },
+{ "std::streamsize", { "<ios>" } },
+{ "std::strerror", { "<cstring>" } },
+{ "std::strftime", { "<ctime>" } },
+{ "std::string", { "<string>" } },
+{ "std::string_view", { "<string_view>" } }, // C++17
+{ "std::stringbuf", { "<sstream>" } },
+{ "std::stringstream", { "<sstream>" } },
+{ "std::strlen", { "<cstring>" } },
+{ "std::strncat", { "<cstring>" } },
+{ "std::strncmp", { "<cstring>" } },
+{ "std::strncpy", { "<cstring>" } },
+{ "std::strpbrk", { "<cstring>" } },
+{ "std::strrchr", { "<cstring>" } },
+{ "std::strspn", { "<cstring>" } },
+{ "std::strstr", { "<cstring>" } },
+{ "std::strtod", { "<cstdlib>" } },
+{ "std::strtof", { "<cstdlib>" } }, // C++11
+{ "std::strtoimax", { "<cinttypes>" } }, // C++11
+{ "std::strtok", { "<cstring>" } },
+{ "std::strtol", { "<cstdlib>" } },
+{ "std::strtold", { "<cstdlib>" } },
+{ "std::strtoll", { "<cstdlib>" } }, // C++11
+{ "std::strtoul", { "<cstdlib>" } },
+{ "std::strtoull", { "<cstdlib>" } }, // C++11
+{ "std::strtoumax", { "<cinttypes>" } }, // C++11
+{ "std::strxfrm", { "<cstring>" } },
+{ "std::student_t_distribution", { "<random>" } }, // C++11
+{ "std::sub_match", { "<regex>" } }, // C++11
+{ "std::subtract_with_carry_engine", { "<random>" } }, // C++11
+{ "std::swap", { "<algorithm><utility>" } },
+{ "std::swap_ranges", { "<algorithm>" } },
+{ "std::swprintf", { "<cwchar>" } },
+{ "std::swscanf", { "<cwchar>" } },
+{ "std::system", { "<cstdlib>" } },
+{ "std::system_category", { "<system_error>" } }, // C++11
+{ "std::system_error", { "<system_error>" } }, // C++11
+{ "std::tera", { "<ratio>" } }, // C++11
+{ "std::terminate", { "<exception>" } },
+{ "std::terminate_handler", { "<exception>" } },
+{ "std::tgamma", { "<cmath>" } }, // C++11
+{ "std::thread", { "<thread>" } }, // C++11
+{ "std::throw_with_nested", { "<exception>" } }, // C++11
+{ "std::tie", { "<tuple>" } }, // C++11
+{ "std::time", { "<ctime>" } },
+{ "std::time_base", { "<locale>" } },
+{ "std::time_get", { "<locale>" } },
+{ "std::time_get_byname", { "<locale>" } },
+{ "std::time_put", { "<locale>" } },
+{ "std::time_put_byname", { "<locale>" } },
+{ "std::time_t", { "<ctime>" } },
+{ "std::timed_mutex", { "<mutex>" } }, // C++11
+{ "std::timespec", { "<ctime>" } }, // C++17
+{ "std::timespec_get", { "<ctime>" } }, // C++17
+{ "std::tm", { "<ctime>" } },
+{ "std::tmpfile", { "<cstdio>" } },
+{ "std::tmpnam", { "<cstdio>" } },
+{ "std::to_integer", { "<cstddef>" } }, // C++17
+{ "std::to_chars", { "<charconv>" } }, // C++17
+{ "std::to_string", { "<string>" } }, // C++11
+{ "std::towctrans", { "<cwctype>" } },
+{ "std::towlower", { "<cwctype>" } },
+{ "std::towupper", { "<cwctype>" } },
+{ "std::transform", { "<algorithm>" } },
+{ "std::transform_exclusive_scan", { "<numeric>" } }, // C++17
+{ "std::transform_inclusive_scan", { "<numeric>" } }, // C++17
+{ "std::transform_reduce", { "<numeric>" } }, // C++17
+{ "std::true_type", { "<type_traits>" } }, // C++11
+{ "std::trunc", { "<cmath>" } }, // C++11
+{ "std::try_lock", { "<mutex>" } }, // C++11
+{ "std::try_to_lock", { "<mutex>" } }, // C++11
+{ "std::try_to_lock_t", { "<mutex>" } }, // C++11
+{ "std::tuple", { "<tuple>" } }, // C++11
+{ "std::tuple_cat", { "<tuple>" } }, // C++11
+{ "std::type_index", { "<typeindex>" } }, // C++11
+{ "std::type_info", { "<typeinfo>" } },
+{ "std::u16streampos", { "<ios>" } }, // C++11
+{ "std::u16string", { "<string>" } }, // C++11
+{ "std::u16string_view", { "<string_view>" } }, // C++17
+{ "std::u32streampos", { "<ios>" } }, // C++11
+{ "std::u32string", { "<string>" } }, // C++11
+{ "std::u32string_view", { "<string_view>" } }, // C++17
+{ "std::uint_fast16_t", { "<cstdint>" } }, // C++11
+{ "std::uint_fast32_t", { "<cstdint>" } }, // C++11
+{ "std::uint_fast64_t", { "<cstdint>" } }, // C++11
+{ "std::uint_fast8_t", { "<cstdint>" } }, // C++11
+{ "std::uint_least16_t", { "<cstdint>" } }, // C++11
+{ "std::uint_least32_t", { "<cstdint>" } }, // C++11
+{ "std::uint_least64_t", { "<cstdint>" } }, // C++11
+{ "std::uint_least8_t", { "<cstdint>" } }, // C++11
+{ "std::uint16_t", { "<cstdint>" } }, // C++11
+{ "std::uint32_t", { "<cstdint>" } }, // C++11
+{ "std::uint64_t", { "<cstdint>" } }, // C++11
+{ "std::uint8_t", { "<cstdint>" } }, // C++11
+{ "std::uintmax_t", { "<cstdint>" } }, // C++11
+{ "std::uintptr_t", { "<cstdint>" } }, // C++11
+{ "std::uncaught_exceptions", { "<exception>" } }, // C++17
+{ "std::undeclare_no_pointers", { "<memory>" } }, // C++11
+{ "std::undeclare_reachable", { "<memory>" } }, // C++11
+{ "std::underflow_error", { "<stdexcept>" } },
+{ "std::underlying_type", { "<type_traits>" } }, // C++11
+{ "std::underlying_type_t", { "<type_traits>" } }, // C++14
+{ "std::ungetc", { "<cstdio>" } },
+{ "std::ungetwc", { "<cwchar>" } },
+{ "std::uniform_int_distribution", { "<random>" } }, // C++11
+{ "std::uniform_real_distribution", { "<random>" } }, // C++11
+{ "std::uninitialized_copy", { "<memory>" } },
+{ "std::uninitialized_copy_n", { "<memory>" } }, // C++11
+{ "std::uninitialized_default_construct", { "<memory>" } }, // C++17
+{ "std::uninitialized_default_construct_n", { "<memory>" } }, // C++17
+{ "std::uninitialized_fill", { "<memory>" } },
+{ "std::uninitialized_fill_n", { "<memory>" } },
+{ "std::uninitialized_move", { "<memory>" } }, // C++17
+{ "std::uninitialized_move_n", { "<memory>" } }, // C++17
+{ "std::uninitialized_value_construct", { "<memory>" } }, // C++17
+{ "std::uninitialized_value_construct_n", { "<memory>" } }, // C++17
+{ "std::unique", { "<algorithm>" } },
+{ "std::unique_copy", { "<algorithm>" } },
+{ "std::unique_lock", { "<mutex>" } }, // C++11
+{ "std::unique_ptr", { "<memory>" } }, // C++11
+{ "std::unitbuf", { "<ios>" } },
+{ "std::unordered_map", { "<unordered_map>" } }, // C++11
+{ "std::unordered_multimap", { "<unordered_map>" } }, // C++11
+{ "std::unordered_multiset", { "<unordered_set>" } }, // C++11
+{ "std::unordered_set", { "<unordered_set>" } }, // C++11
+{ "std::upper_bound", { "<algorithm>" } },
+{ "std::uppercase", { "<ios>" } },
+{ "std::use_facet", { "<locale>" } },
+{ "std::uses_allocator_v", { "<memory>" } }, // C++17
+{ "std::va_list", { "<cstdarg>" } },
+{ "std::valarray", { "<valarray>" } },
+{ "std::variant", { "<variant>" } }, // C++17
+{ "std::variant_alternative", { "<variant>" } }, // C++17
+{ "std::variant_alternative_t", { "<variant>" } }, // C++17
+{ "std::variant_npos", { "<variant>" } }, // C++17
+{ "std::variant_size", { "<variant>" } }, // C++17
+{ "std::variant_size_v", { "<variant>" } }, // C++17
+{ "std::vector", { "<vector>" } },
+{ "std::vfprintf", { "<cstdio>" } },
+{ "std::vfscanf", { "<cstdio>" } }, // C++11
+{ "std::vfwprintf", { "<cwchar>" } },
+{ "std::vfwscanf", { "<cwchar>" } }, // C++11
+{ "std::visit", { "<variant>" } }, // C++17
+{ "std::void_t", { "<type_traits>" } }, // C++17
+{ "std::vprintf", { "<cstdio>" } },
+{ "std::vscanf", { "<cstdio>" } }, // C++11
+{ "std::vsnprintf", { "<cstdio>" } }, // C++11
+{ "std::vsprintf", { "<cstdio>" } },
+{ "std::vsscanf", { "<cstdio>" } }, // C++11
+{ "std::vswprintf", { "<cwchar>" } },
+{ "std::vswscanf", { "<cwchar>" } }, // C++11
+{ "std::vwprintf", { "<cwchar>" } },
+{ "std::vwscanf", { "<cwchar>" } }, // C++11
+{ "std::wbuffer_convert", { "<locale>" } }, // C++11
+{ "std::wcerr", { "<iostream>" } },
+{ "std::wcin", { "<iostream>" } },
+{ "std::wclog", { "<iostream>" } },
+{ "std::wcmatch", { "<regex>" } }, // C++11
+{ "std::wcout", { "<iostream>" } },
+{ "std::wcregex_iterator", { "<regex>" } }, // C++11
+{ "std::wcregex_token_iterator", { "<regex>" } }, // C++11
+{ "std::wcrtomb", { "<cwchar>" } },
+{ "std::wcscat", { "<cwchar>" } },
+{ "std::wcschr", { "<cwchar>" } },
+{ "std::wcscmp", { "<cwchar>" } },
+{ "std::wcscoll", { "<cwchar>" } },
+{ "std::wcscpy", { "<cwchar>" } },
+{ "std::wcscspn", { "<cwchar>" } },
+{ "std::wcsftime", { "<cwchar>" } },
+{ "std::wcslen", { "<cwchar>" } },
+{ "std::wcsncat", { "<cwchar>" } },
+{ "std::wcsncmp", { "<cwchar>" } },
+{ "std::wcsncpy", { "<cwchar>" } },
+{ "std::wcspbrk", { "<cwchar>" } },
+{ "std::wcsrchr", { "<cwchar>" } },
+{ "std::wcsrtombs", { "<cwchar>" } },
+{ "std::wcsspn", { "<cwchar>" } },
+{ "std::wcsstr", { "<cwchar>" } },
+{ "std::wcstod", { "<cwchar>" } },
+{ "std::wcstof", { "<cwchar>" } }, // C++11
+{ "std::wcstoimax", { "<cinttypes>" } }, // C++11
+{ "std::wcstok", { "<cwchar>" } },
+{ "std::wcstol", { "<cwchar>" } },
+{ "std::wcstold", { "<cwchar>" } }, // C++11
+{ "std::wcstoll", { "<cwchar>" } }, // C++11
+{ "std::wcstombs", { "<cstdlib>" } },
+{ "std::wcstoul", { "<cwchar>" } },
+{ "std::wcstoull", { "<cwchar>" } }, // C++11
+{ "std::wcstoumax", { "<cinttypes>" } }, // C++11
+{ "std::wcsub_match", { "<regex>" } }, // C++11
+{ "std::wcsxfrm", { "<cwchar>" } },
+{ "std::wctob", { "<cwchar>" } },
+{ "std::wctomb", { "<cstdlib>" } },
+{ "std::wctrans", { "<cwctype>" } },
+{ "std::wctrans_t", { "<cwctype>" } },
+{ "std::wctype", { "<cwctype>" } },
+{ "std::wctype_t", { "<cwctype>" } },
+{ "std::weak_ptr", { "<memory>" } }, // C++11
+{ "std::weibull_distribution", { "<random>" } }, // C++11
+{ "std::wfstream", { "<fstream>" } },
+{ "std::wifstream", { "<fstream>" } },
+{ "std::wios", { "<ios>" } },
+{ "std::wiostream", { "<istream>" } },
+{ "std::wistream", { "<istream>" } },
+{ "std::wistringstream", { "<sstream>" } },
+{ "std::wmemchr", { "<cwchar>" } },
+{ "std::wmemcmp", { "<cwchar>" } },
+{ "std::wmemcpy", { "<cwchar>" } },
+{ "std::wmemmove", { "<cwchar>" } },
+{ "std::wmemset", { "<cwchar>" } },
+{ "std::wofstream", { "<fstream>" } },
+{ "std::wostream", { "<ostream>" } },
+{ "std::wstreambuf", { "<streambuf>" } },
+{ "std::ws", { "<istream>" } },
+{ "std::wstreampos", { "<ios>" } },
+{ "std::wostringstream", { "<sstream>" } },
+{ "std::wprintf", { "<cwchar>" } },
+{ "std::wregex", { "<regex>" } }, // C++11
+{ "std::wscanf", { "<cwchar>" } },
+{ "std::wsmatch", { "<regex>" } }, // C++11
+{ "std::wsregex_iterator", { "<regex>" } }, // C++11
+{ "std::wsregex_token_iterator", { "<regex>" } }, // C++11
+{ "std::wssub_match", { "<regex>" } }, // C++11
+{ "std::wstring", { "<string>" } },
+{ "std::wstring_convert", { "<locale>" } }, // C++11
+{ "std::wstring_view", { "<string_view>" } }, // C++17
+{ "std::wstringbuf", { "<sstream>" } },
+{ "std::wstringstream", { "<sstream>" } },
+{ "std::yocto", { "<ratio>" } }, // C++11
+{ "std::yotta", { "<ratio>" } }, // C++11
+{ "std::zepto", { "<ratio>" } }, // C++11
+{ "std::zetta", { "<ratio>" } }, // C++11
+{ "std::abs", { "<cmath>", "<cstdlib>", "<complex>", "<valarray>" } },
+{ "std::acos", { "<cmath>", "<complex>", "<valarray>" } },
+{ "std::acosh", { "<cmath>", "<complex>" } }, // C++11
+{ "std::asin", { "<cmath>", "<complex>", "<valarray>" } },
+{ "std::asinh", { "<cmath>", "<complex>" } }, // C++11
+{ "std::atan", { "<cmath>", "<complex>", "<valarray>" } },
+{ "std::atan2", { "<cmath>", "<valarray>" } },
+{ "std::atanh", { "<cmath>", "<complex>" } }, // C++11
+{ "std::basic_filebuf", { "<fstream>", "<streambuf>" } },
+{ "std::consume_header", { "<codecvt>", "<locale>" } }, // C++11
+{ "std::cos", { "<cmath>", "<complex>", "<valarray>" } },
+{ "std::cosh", { "<cmath>", "<complex>", "<valarray>" } },
+{ "std::exp", { "<cmath>", "<complex>", "<valarray>" } },
+{ "std::fabs", { "<cstdlib>", "<cmath>" } },
+{ "std::filebuf", { "<fstream>", "<streambuf>" } },
+{ "std::generate_header", { "<codecvt>", "<locale>" } }, // C++11
+{ "std::get", { "<utility>", "<variant>" } }, // C++11
+{ "std::imaxabs", { "<cmath>", "<cstdlib>" } }, // C++11
+{ "std::isalnum", { "<cctype>", "<locale>" } },
+{ "std::isalpha", { "<cctype>", "<locale>" } },
+{ "std::isblank", { "<cctype>", "<locale>" } }, // C++11
+{ "std::iscntrl", { "<cctype>", "<locale>" } },
+{ "std::isdigit", { "<cctype>", "<locale>" } },
+{ "std::isgraph", { "<cctype>", "<locale>" } },
+{ "std::islower", { "<cctype>", "<locale>" } },
+{ "std::isprint", { "<cctype>", "<locale>" } },
+{ "std::ispunct", { "<cctype>", "<locale>" } },
+{ "std::isspace", { "<cctype>", "<locale>" } },
+{ "std::isupper", { "<cctype>", "<locale>" } },
+{ "std::isxdigit", { "<cctype>", "<locale>" } },
+{ "std::labs", { "<cmath>", "<cstdlib>" } },
+{ "std::little_endian", { "<codecvt>", "<locale>" } }, // C++11
+{ "std::llabs", { "<cmath>", "<cstdlib>" } }, // C++11
+{ "std::log", { "<cmath>", "<complex>", "<valarray>" } },
+{ "std::log10", { "<cmath>", "<complex>", "<valarray>" } },
+{ "std::make_error_code", { "<system_error>", "<ios>" } }, // C++11
+{ "std::make_error_condition", { "<system_error>", "<ios>" } }, // C++11
+{ "std::mbstate_t", { "<cwchar>", "<cuchar>" } },
+{ "std::move", { "<algorithm>", "<utility>" } }, // C++11
+{ "std::pow", { "<cmath>", "<complex>", "<valarray>" } },
+{ "std::remove", { "<cstdio>", "<algorithm>" } },
+{ "std::sin", { "<cmath>", "<complex>", "<valarray>" } },
+{ "std::sinh", { "<cmath>", "<complex>", "<valarray>" } },
+{ "std::size_t", { "<cwchar>", "<ctime>", "<cstring>", "<cstdlib>", "<cstdio>", "<cstddef>" } },
+{ "std::sqrt", { "<cmath>", "<complex>", "<valarray>" } },
+{ "std::tan", { "<cmath>", "<complex>", "<valarray>" } },
+{ "std::tanh", { "<cmath>", "<complex>", "<valarray>" } },
+{ "std::tolower", { "<cctype>", "<locale>" } },
+{ "std::toupper", { "<cctype>", "<locale>" } },
+{ "std::tuple_element", { "<array>", "<utility>", "<tuple>" } }, // C++11
+{ "std::tuple_size", { "<array>", "<utility>", "<tuple>" } }, // C++11
+{ "std::uses_allocator", { "<memory>", "<tuple>" } }, // C++11
+{ "std::wfilebuf", { "<fstream>", "<streambuf>" } },
+{ "std::wint_t", { "<cwchar>", "<cwctype>" } },
\ No newline at end of file
Index: clangd/index/CanonicalIncludes.h
===================================================================
--- clangd/index/CanonicalIncludes.h
+++ clangd/index/CanonicalIncludes.h
@@ -44,10 +44,10 @@
   void addPathSuffixMapping(llvm::StringRef Suffix,
                             llvm::StringRef CanonicalPath);
 
-  /// Sets the canonical include for any symbol with \p QualifiedName.
+  /// Sets the canonical includes for any symbol with \p QualifiedName.
   /// Symbol mappings take precedence over header mappings.
   void addSymbolMapping(llvm::StringRef QualifiedName,
-                        llvm::StringRef CanonicalPath);
+                        llvm::SmallVector<llvm::StringRef, 2> CanonicalPaths);
 
   /// Returns the canonical include for symbol with \p QualifiedName.
   /// \p Headers is the include stack: Headers.front() is the file declaring the
@@ -64,7 +64,8 @@
   /// Used to reduce the number of lookups into SuffixHeaderMapping.
   int MaxSuffixComponents = 0;
   /// A map from fully qualified symbol names to header names.
-  llvm::StringMap<std::string> SymbolMapping;
+  llvm::DenseMap<llvm::StringRef, llvm::SmallVector<llvm::StringRef, 2>>
+      SymbolMapping;
 };
 
 /// Returns a CommentHandler that parses pragma comment on include files to
Index: clangd/index/CanonicalIncludes.cpp
===================================================================
--- clangd/index/CanonicalIncludes.cpp
+++ clangd/index/CanonicalIncludes.cpp
@@ -31,9 +31,10 @@
   FullPathMapping[Path] = CanonicalPath;
 }
 
-void CanonicalIncludes::addSymbolMapping(llvm::StringRef QualifiedName,
-                                         llvm::StringRef CanonicalPath) {
-  this->SymbolMapping[QualifiedName] = CanonicalPath;
+void CanonicalIncludes::addSymbolMapping(
+    llvm::StringRef QualifiedName,
+    llvm::SmallVector<llvm::StringRef, 2> CanonicalPaths) {
+  this->SymbolMapping[QualifiedName] = std::move(CanonicalPaths);
 }
 
 llvm::StringRef
@@ -41,8 +42,13 @@
                              llvm::StringRef QualifiedName) const {
   assert(!Headers.empty());
   auto SE = SymbolMapping.find(QualifiedName);
+  // FIXME: support multple-header cases. STL symbols may come from different
+  // headers (e.g. std::move from <utility> and <algorithm>), using
+  // qualified name can not disambiguate headers. Instead we should return all
+  // headers and do the disambiguation in clangd side.
   if (SE != SymbolMapping.end())
-    return SE->second;
+    return SE->second.front();
+
   // Find the first header such that the extension is not '.inc', and isn't a
   // recognized non-header file
   auto I = llvm::find_if(Headers, [](llvm::StringRef Include) {
@@ -106,55 +112,11 @@
 }
 
 void addSystemHeadersMapping(CanonicalIncludes *Includes) {
-  static const std::vector<std::pair<const char *, const char *>> SymbolMap = {
-      {"std::addressof", "<memory>"},
-      // Map symbols in <iosfwd> to their preferred includes.
-      {"std::basic_filebuf", "<fstream>"},
-      {"std::basic_fstream", "<fstream>"},
-      {"std::basic_ifstream", "<fstream>"},
-      {"std::basic_ofstream", "<fstream>"},
-      {"std::filebuf", "<fstream>"},
-      {"std::fstream", "<fstream>"},
-      {"std::ifstream", "<fstream>"},
-      {"std::ofstream", "<fstream>"},
-      {"std::wfilebuf", "<fstream>"},
-      {"std::wfstream", "<fstream>"},
-      {"std::wifstream", "<fstream>"},
-      {"std::wofstream", "<fstream>"},
-      {"std::basic_ios", "<ios>"},
-      {"std::ios", "<ios>"},
-      {"std::wios", "<ios>"},
-      {"std::basic_iostream", "<iostream>"},
-      {"std::iostream", "<iostream>"},
-      {"std::wiostream", "<iostream>"},
-      {"std::basic_istream", "<istream>"},
-      {"std::istream", "<istream>"},
-      {"std::wistream", "<istream>"},
-      {"std::istreambuf_iterator", "<iterator>"},
-      {"std::ostreambuf_iterator", "<iterator>"},
-      {"std::basic_ostream", "<ostream>"},
-      {"std::ostream", "<ostream>"},
-      {"std::wostream", "<ostream>"},
-      {"std::basic_istringstream", "<sstream>"},
-      {"std::basic_ostringstream", "<sstream>"},
-      {"std::basic_stringbuf", "<sstream>"},
-      {"std::basic_stringstream", "<sstream>"},
-      {"std::istringstream", "<sstream>"},
-      {"std::ostringstream", "<sstream>"},
-      {"std::string", "<string>"},
-      {"std::stringbuf", "<sstream>"},
-      {"std::stringstream", "<sstream>"},
-      {"std::wistringstream", "<sstream>"},
-      {"std::wostringstream", "<sstream>"},
-      {"std::wstringbuf", "<sstream>"},
-      {"std::wstringstream", "<sstream>"},
-      {"std::basic_streambuf", "<streambuf>"},
-      {"std::streambuf", "<streambuf>"},
-      {"std::wstreambuf", "<streambuf>"},
-      {"std::uint_least16_t", "<cstdint>"}, // <type_traits> redeclares these
-      {"std::uint_least32_t", "<cstdint>"},
-      {"std::declval", "<utility>"},
-  };
+  static const std::vector<
+      std::pair<llvm::StringRef, llvm::SmallVector<llvm::StringRef, 2>>>
+      SymbolMap = {
+#include "StdSymbolMap.imp"
+      };
   for (const auto &Pair : SymbolMap)
     Includes->addSymbolMapping(Pair.first, Pair.second);