This is an archive of the discontinued LLVM Phabricator instance.

Differential D51088

[clangd] Get rid of regexes in CanonicalIncludes
ClosedPublic

Authored by ilya-biryukov on Aug 22 2018, 1:13 AM.

Details

Reviewers
ioeric
kbobyrev
Commits
rG22abe49fffe0: [clangd] Get rid of regexes in CanonicalIncludes
rL340410: [clangd] Get rid of regexes in CanonicalIncludes
rCTE340410: [clangd] Get rid of regexes in CanonicalIncludes
Summary

Replace them with suffix mappings.

Diff Detail

Event Timeline

ilya-biryukov created this revision.Aug 22 2018, 1:13 AM
Herald added subscribers: kadircet, jfb, arphaman and 2 others. · View Herald TranscriptAug 22 2018, 1:13 AM
Harbormaster completed remote builds in B21769: Diff 161895.Aug 22 2018, 1:14 AM
ioeric added inline comments.Aug 22 2018, 4:17 AM
clangd/index/CanonicalIncludes.h
43–46

It seems that this is only file path suffix matching (by components) now. We should probably rename the function to be explicit.

64

It might be worth documenting why this is useful (i.e. the optimization).

ilya-biryukov marked 2 inline comments as done.Aug 22 2018, 5:52 AM
ilya-biryukov added inline comments.
clangd/index/CanonicalIncludes.h
43–46

Renamed to addPathSuffixMapping, updated the doc.

ilya-biryukov updated this revision to Diff 161932.Aug 22 2018, 5:52 AM
ilya-biryukov marked 2 inline comments as done.
  • s/addSuffixMapping/addFileSuffixMapping
  • Document the intention of MaxSuffixComponents
Harbormaster completed remote builds in B21778: Diff 161932.Aug 22 2018, 5:52 AM
ioeric accepted this revision.Aug 22 2018, 6:17 AM
ioeric added inline comments.
clangd/index/CanonicalIncludes.cpp
24

Would int Components = begin(Suffix) - end(Suffix); work here?

79

Maybe merge Components and break condition into for loop condition?

This revision is now accepted and ready to land.Aug 22 2018, 6:17 AM
ilya-biryukov updated this revision to Diff 161945.Aug 22 2018, 6:46 AM
ilya-biryukov marked 2 inline comments as done.
  • Use std::distance instead of an explicit loop
  • Merge break into loop condition
clangd/index/CanonicalIncludes.cpp
24

Surprisingly, operator - gives byte difference.
But std::distance gives the expected result, added that.

Thanks!

Closed by commit rCTE340410: [clangd] Get rid of regexes in CanonicalIncludes (authored by ibiryukov). · Explain WhyAug 22 2018, 6:52 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
clangd/
index/
24 lines
1349 lines

Diff 161932

clangd/index/CanonicalIncludes.h

Show All 34 Lines
/// Only const methods (i.e. mapHeader) in this class are thread safe. /// Only const methods (i.e. mapHeader) in this class are thread safe.
class CanonicalIncludes { class CanonicalIncludes {
public: public:
CanonicalIncludes() = default; CanonicalIncludes() = default;
/// Adds a string-to-string mapping from \p Path to \p CanonicalPath. /// Adds a string-to-string mapping from \p Path to \p CanonicalPath.
void addMapping(llvm::StringRef Path, llvm::StringRef CanonicalPath); void addMapping(llvm::StringRef Path, llvm::StringRef CanonicalPath);
/// Maps all files matching \p RE to \p CanonicalPath /// Maps files with last path components matching \p Suffix to \p
void addRegexMapping(llvm::StringRef RE, llvm::StringRef CanonicalPath); /// CanonicalPath.
void addPathSuffixMapping(llvm::StringRef Suffix,
llvm::StringRef CanonicalPath);
ioericUnsubmitted
Done
ReplyInline Actions

It seems that this is only file path suffix matching (by components) now. We should probably rename the function to be explicit.

ioeric: It seems that this is only file path suffix matching (by components) now. We should probably…
ilya-biryukovAuthorUnsubmitted
Not Done
ReplyInline Actions

Renamed to addPathSuffixMapping, updated the doc.

ilya-biryukov: Renamed to addPathSuffixMapping, updated the doc.
/// Sets the canonical include for any symbol with \p QualifiedName. /// Sets the canonical include for any symbol with \p QualifiedName.
/// Symbol mappings take precedence over header mappings. /// Symbol mappings take precedence over header mappings.
void addSymbolMapping(llvm::StringRef QualifiedName, void addSymbolMapping(llvm::StringRef QualifiedName,
llvm::StringRef CanonicalPath); llvm::StringRef CanonicalPath);
/// Returns the canonical include for symbol with \p QualifiedName. /// Returns the canonical include for symbol with \p QualifiedName.
/// \p Headers is the include stack: Headers.front() is the file declaring the /// \p Headers is the include stack: Headers.front() is the file declaring the
/// symbol, and Headers.back() is the main file. /// symbol, and Headers.back() is the main file.
llvm::StringRef mapHeader(llvm::ArrayRef<std::string> Headers, llvm::StringRef mapHeader(llvm::ArrayRef<std::string> Headers,
llvm::StringRef QualifiedName) const; llvm::StringRef QualifiedName) const;
private: private:
// A map from header patterns to header names. This needs to be mutable so /// A map from full include path to a canonical path.
// that we can match again a Regex in a const function member. llvm::StringMap<std::string> FullPathMapping;
// FIXME(ioeric): All the regexes we have so far are suffix matches. The /// A map from a suffix (one or components of a path) to a canonical path.
// performance could be improved by allowing only suffix matches instead of llvm::StringMap<std::string> SuffixHeaderMapping;
// arbitrary regexes. /// Maximum number of path components stored in a key of SuffixHeaderMapping.
ioericUnsubmitted
Done
ReplyInline Actions

It might be worth documenting why this is useful (i.e. the optimization).

ioeric: It might be worth documenting why this is useful (i.e. the optimization).
mutable std::vector<std::pair<llvm::Regex, std::string>> /// Used to reduce the number of lookups into SuffixHeaderMapping.
RegexHeaderMappingTable; int MaxSuffixComponents = 0;
// A map from fully qualified symbol names to header names. /// A map from fully qualified symbol names to header names.
llvm::StringMap<std::string> SymbolMapping; llvm::StringMap<std::string> SymbolMapping;
// Guards Regex matching as it's not thread-safe.
mutable std::mutex RegexMutex;
}; };
/// Returns a CommentHandler that parses pragma comment on include files to /// Returns a CommentHandler that parses pragma comment on include files to
/// determine when we should include a different header from the header that /// determine when we should include a different header from the header that
/// directly defines a symbol. Mappinps are registered with \p Includes. /// directly defines a symbol. Mappinps are registered with \p Includes.
/// ///
/// Currently it only supports IWYU private pragma: /// Currently it only supports IWYU private pragma:
/// https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/IWYUPragmas.md#iwyu-pragma-private /// https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/IWYUPragmas.md#iwyu-pragma-private
Show All 17 Lines

clangd/index/CanonicalIncludes.cpp

//===-- CanonicalIncludes.h - remap #inclue headers--------------*- C++ -*-===// //===-- CanonicalIncludes.h - remap #inclue headers--------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CanonicalIncludes.h" #include "CanonicalIncludes.h"
#include "../Headers.h" #include "../Headers.h"
#include "clang/Driver/Types.h" #include "clang/Driver/Types.h"
#include "llvm/Support/Regex.h" #include "llvm/Support/Path.h"
namespace clang { namespace clang {
namespace clangd { namespace clangd {
namespace { namespace {
const char IWYUPragma[] = "// IWYU pragma: private, include "; const char IWYUPragma[] = "// IWYU pragma: private, include ";
} // namespace } // namespace
void CanonicalIncludes::addMapping(llvm::StringRef Path, void CanonicalIncludes::addPathSuffixMapping(llvm::StringRef Suffix,
llvm::StringRef CanonicalPath) { llvm::StringRef CanonicalPath) {
addRegexMapping((llvm::Twine("^") + llvm::Regex::escape(Path) + "$").str(), int Components = 0;
CanonicalPath); for (auto It = llvm::sys::path::begin(Suffix),
ioericUnsubmitted
Done
ReplyInline Actions

Would int Components = begin(Suffix) - end(Suffix); work here?

ioeric: Would `int Components = begin(Suffix) - end(Suffix);` work here?
ilya-biryukovAuthorUnsubmitted
Not Done
ReplyInline Actions

Surprisingly, operator - gives byte difference.
But std::distance gives the expected result, added that.

Thanks!

ilya-biryukov: Surprisingly, `operator -` gives byte difference. But `std::distance` gives the expected result…
End = llvm::sys::path::end(Suffix);
It != End; ++It)
++Components;
MaxSuffixComponents = std::max(MaxSuffixComponents, Components);
SuffixHeaderMapping[Suffix] = CanonicalPath;
} }
void CanonicalIncludes::addRegexMapping(llvm::StringRef RE, void CanonicalIncludes::addMapping(llvm::StringRef Path,
llvm::StringRef CanonicalPath) { llvm::StringRef CanonicalPath) {
this->RegexHeaderMappingTable.emplace_back(llvm::Regex(RE), CanonicalPath); FullPathMapping[Path] = CanonicalPath;
} }
void CanonicalIncludes::addSymbolMapping(llvm::StringRef QualifiedName, void CanonicalIncludes::addSymbolMapping(llvm::StringRef QualifiedName,
llvm::StringRef CanonicalPath) { llvm::StringRef CanonicalPath) {
this->SymbolMapping[QualifiedName] = CanonicalPath; this->SymbolMapping[QualifiedName] = CanonicalPath;
} }
llvm::StringRef llvm::StringRef
CanonicalIncludes::mapHeader(llvm::ArrayRef<std::string> Headers, CanonicalIncludes::mapHeader(llvm::ArrayRef<std::string> Headers,
llvm::StringRef QualifiedName) const { llvm::StringRef QualifiedName) const {
assert(!Headers.empty()); assert(!Headers.empty());
auto SE = SymbolMapping.find(QualifiedName); auto SE = SymbolMapping.find(QualifiedName);
if (SE != SymbolMapping.end()) if (SE != SymbolMapping.end())
return SE->second; return SE->second;
std::lock_guard<std::mutex> Lock(RegexMutex);
// Find the first header such that the extension is not '.inc', and isn't a // Find the first header such that the extension is not '.inc', and isn't a
// recognized non-header file // recognized non-header file
auto I = auto I =
std::find_if(Headers.begin(), Headers.end(), [](llvm::StringRef Include) { std::find_if(Headers.begin(), Headers.end(), [](llvm::StringRef Include) {
// Skip .inc file whose including header file should // Skip .inc file whose including header file should
// be #included instead. // be #included instead.
return !Include.endswith(".inc"); return !Include.endswith(".inc");
}); });
if (I == Headers.end()) if (I == Headers.end())
return Headers[0]; // Fallback to the declaring header. return Headers[0]; // Fallback to the declaring header.
StringRef Header = *I; StringRef Header = *I;
// If Header is not expected be included (e.g. .cc file), we fall back to // If Header is not expected be included (e.g. .cc file), we fall back to
// the declaring header. // the declaring header.
StringRef Ext = llvm::sys::path::extension(Header).trim('.'); StringRef Ext = llvm::sys::path::extension(Header).trim('.');
// Include-able headers must have precompile type. Treat files with // Include-able headers must have precompile type. Treat files with
// non-recognized extenstions (TY_INVALID) as headers. // non-recognized extenstions (TY_INVALID) as headers.
auto ExtType = driver::types::lookupTypeForExtension(Ext); auto ExtType = driver::types::lookupTypeForExtension(Ext);
if ((ExtType != driver::types::TY_INVALID) && if ((ExtType != driver::types::TY_INVALID) &&
!driver::types::onlyPrecompileType(ExtType)) !driver::types::onlyPrecompileType(ExtType))
return Headers[0]; return Headers[0];
for (auto &Entry : RegexHeaderMappingTable) {
#ifndef NDEBUG auto MapIt = FullPathMapping.find(Header);
std::string Dummy; if (MapIt != FullPathMapping.end())
assert(Entry.first.isValid(Dummy) && "Regex should never be invalid!"); return MapIt->second;
#endif
if (Entry.first.match(Header)) int Components = 0;
return Entry.second; for (auto It = llvm::sys::path::rbegin(Header),
End = llvm::sys::path::rend(Header);
It != End; ++It) {
++Components;
ioericUnsubmitted
Done
ReplyInline Actions

Maybe merge Components and break condition into for loop condition?

ioeric: Maybe merge `Components` and break condition into `for loop` condition?
if (MaxSuffixComponents < Components)
break;
auto SubPath = Header.substr(It->data() - Header.begin());
auto MappingIt = SuffixHeaderMapping.find(SubPath);
if (MappingIt != SuffixHeaderMapping.end())
return MappingIt->second;
} }
return Header; return Header;
} }
std::unique_ptr<CommentHandler> std::unique_ptr<CommentHandler>
collectIWYUHeaderMaps(CanonicalIncludes *Includes) { collectIWYUHeaderMaps(CanonicalIncludes *Includes) {
class PragmaCommentHandler : public clang::CommentHandler { class PragmaCommentHandler : public clang::CommentHandler {
public: public:
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines static const std::vector<std::pair<const char *, const char *>> SymbolMap = {
{"std::uint_least32_t", "<cstdint>"}, {"std::uint_least32_t", "<cstdint>"},
{"std::declval", "<utility>"}, {"std::declval", "<utility>"},
}; };
for (const auto &Pair : SymbolMap) for (const auto &Pair : SymbolMap)
Includes->addSymbolMapping(Pair.first, Pair.second); Includes->addSymbolMapping(Pair.first, Pair.second);
static const std::vector<std::pair<const char *, const char *>> static const std::vector<std::pair<const char *, const char *>>
SystemHeaderMap = { SystemHeaderMap = {
{"include/__stddef_max_align_t.h$", "<cstddef>"}, {"include/__stddef_max_align_t.h", "<cstddef>"},
{"include/__wmmintrin_aes.h$", "<wmmintrin.h>"}, {"include/__wmmintrin_aes.h", "<wmmintrin.h>"},
{"include/__wmmintrin_pclmul.h$", "<wmmintrin.h>"}, {"include/__wmmintrin_pclmul.h", "<wmmintrin.h>"},
{"include/adxintrin.h$", "<immintrin.h>"}, {"include/adxintrin.h", "<immintrin.h>"},
{"include/ammintrin.h$", "<ammintrin.h>"}, {"include/ammintrin.h", "<ammintrin.h>"},
{"include/avx2intrin.h$", "<immintrin.h>"}, {"include/avx2intrin.h", "<immintrin.h>"},
{"include/avx512bwintrin.h$", "<immintrin.h>"}, {"include/avx512bwintrin.h", "<immintrin.h>"},
{"include/avx512cdintrin.h$", "<immintrin.h>"}, {"include/avx512cdintrin.h", "<immintrin.h>"},
{"include/avx512dqintrin.h$", "<immintrin.h>"}, {"include/avx512dqintrin.h", "<immintrin.h>"},
{"include/avx512erintrin.h$", "<immintrin.h>"}, {"include/avx512erintrin.h", "<immintrin.h>"},
{"include/avx512fintrin.h$", "<immintrin.h>"}, {"include/avx512fintrin.h", "<immintrin.h>"},
{"include/avx512ifmaintrin.h$", "<immintrin.h>"}, {"include/avx512ifmaintrin.h", "<immintrin.h>"},
{"include/avx512ifmavlintrin.h$", "<immintrin.h>"}, {"include/avx512ifmavlintrin.h", "<immintrin.h>"},
{"include/avx512pfintrin.h$", "<immintrin.h>"}, {"include/avx512pfintrin.h", "<immintrin.h>"},
{"include/avx512vbmiintrin.h$", "<immintrin.h>"}, {"include/avx512vbmiintrin.h", "<immintrin.h>"},
{"include/avx512vbmivlintrin.h$", "<immintrin.h>"}, {"include/avx512vbmivlintrin.h", "<immintrin.h>"},
{"include/avx512vlbwintrin.h$", "<immintrin.h>"}, {"include/avx512vlbwintrin.h", "<immintrin.h>"},
{"include/avx512vlcdintrin.h$", "<immintrin.h>"}, {"include/avx512vlcdintrin.h", "<immintrin.h>"},
{"include/avx512vldqintrin.h$", "<immintrin.h>"}, {"include/avx512vldqintrin.h", "<immintrin.h>"},
{"include/avx512vlintrin.h$", "<immintrin.h>"}, {"include/avx512vlintrin.h", "<immintrin.h>"},
{"include/avxintrin.h$", "<immintrin.h>"}, {"include/avxintrin.h", "<immintrin.h>"},
{"include/bmi2intrin.h$", "<x86intrin.h>"}, {"include/bmi2intrin.h", "<x86intrin.h>"},
{"include/bmiintrin.h$", "<x86intrin.h>"}, {"include/bmiintrin.h", "<x86intrin.h>"},
{"include/emmintrin.h$", "<emmintrin.h>"}, {"include/emmintrin.h", "<emmintrin.h>"},
{"include/f16cintrin.h$", "<emmintrin.h>"}, {"include/f16cintrin.h", "<emmintrin.h>"},
{"include/float.h$", "<cfloat>"}, {"include/float.h", "<cfloat>"},
{"include/fma4intrin.h$", "<x86intrin.h>"}, {"include/fma4intrin.h", "<x86intrin.h>"},
{"include/fmaintrin.h$", "<immintrin.h>"}, {"include/fmaintrin.h", "<immintrin.h>"},
{"include/fxsrintrin.h$", "<immintrin.h>"}, {"include/fxsrintrin.h", "<immintrin.h>"},
{"include/ia32intrin.h$", "<x86intrin.h>"}, {"include/ia32intrin.h", "<x86intrin.h>"},
{"include/immintrin.h$", "<immintrin.h>"}, {"include/immintrin.h", "<immintrin.h>"},
{"include/inttypes.h$", "<cinttypes>"}, {"include/inttypes.h", "<cinttypes>"},
{"include/limits.h$", "<climits>"}, {"include/limits.h", "<climits>"},
{"include/lzcntintrin.h$", "<x86intrin.h>"}, {"include/lzcntintrin.h", "<x86intrin.h>"},
{"include/mm3dnow.h$", "<mm3dnow.h>"}, {"include/mm3dnow.h", "<mm3dnow.h>"},
{"include/mm_malloc.h$", "<mm_malloc.h>"}, {"include/mm_malloc.h", "<mm_malloc.h>"},
{"include/mmintrin.h$", "<mmintrin>"}, {"include/mmintrin.h", "<mmintrin>"},
{"include/mwaitxintrin.h$", "<x86intrin.h>"}, {"include/mwaitxintrin.h", "<x86intrin.h>"},
{"include/pkuintrin.h$", "<immintrin.h>"}, {"include/pkuintrin.h", "<immintrin.h>"},
{"include/pmmintrin.h$", "<pmmintrin.h>"}, {"include/pmmintrin.h", "<pmmintrin.h>"},
{"include/popcntintrin.h$", "<popcntintrin.h>"}, {"include/popcntintrin.h", "<popcntintrin.h>"},
{"include/prfchwintrin.h$", "<x86intrin.h>"}, {"include/prfchwintrin.h", "<x86intrin.h>"},
{"include/rdseedintrin.h$", "<x86intrin.h>"}, {"include/rdseedintrin.h", "<x86intrin.h>"},
{"include/rtmintrin.h$", "<immintrin.h>"}, {"include/rtmintrin.h", "<immintrin.h>"},
{"include/shaintrin.h$", "<immintrin.h>"}, {"include/shaintrin.h", "<immintrin.h>"},
{"include/smmintrin.h$", "<smmintrin.h>"}, {"include/smmintrin.h", "<smmintrin.h>"},
{"include/stdalign.h$", "<cstdalign>"}, {"include/stdalign.h", "<cstdalign>"},
{"include/stdarg.h$", "<cstdarg>"}, {"include/stdarg.h", "<cstdarg>"},
{"include/stdbool.h$", "<cstdbool>"}, {"include/stdbool.h", "<cstdbool>"},
{"include/stddef.h$", "<cstddef>"}, {"include/stddef.h", "<cstddef>"},
{"include/stdint.h$", "<cstdint>"}, {"include/stdint.h", "<cstdint>"},
{"include/tbmintrin.h$", "<x86intrin.h>"}, {"include/tbmintrin.h", "<x86intrin.h>"},
{"include/tmmintrin.h$", "<tmmintrin.h>"}, {"include/tmmintrin.h", "<tmmintrin.h>"},
{"include/wmmintrin.h$", "<wmmintrin.h>"}, {"include/wmmintrin.h", "<wmmintrin.h>"},
{"include/x86intrin.h$", "<x86intrin.h>"}, {"include/x86intrin.h", "<x86intrin.h>"},
{"include/xmmintrin.h$", "<xmmintrin.h>"}, {"include/xmmintrin.h", "<xmmintrin.h>"},
{"include/xopintrin.h$", "<x86intrin.h>"}, {"include/xopintrin.h", "<x86intrin.h>"},
{"include/xsavecintrin.h$", "<immintrin.h>"}, {"include/xsavecintrin.h", "<immintrin.h>"},
{"include/xsaveintrin.h$", "<immintrin.h>"}, {"include/xsaveintrin.h", "<immintrin.h>"},
{"include/xsaveoptintrin.h$", "<immintrin.h>"}, {"include/xsaveoptintrin.h", "<immintrin.h>"},
{"include/xsavesintrin.h$", "<immintrin.h>"}, {"include/xsavesintrin.h", "<immintrin.h>"},
{"include/xtestintrin.h$", "<immintrin.h>"}, {"include/xtestintrin.h", "<immintrin.h>"},
{"include/_G_config.h$", "<cstdio>"}, {"include/_G_config.h", "<cstdio>"},
{"include/assert.h$", "<cassert>"}, {"include/assert.h", "<cassert>"},
{"algorithm$", "<algorithm>"}, {"algorithm", "<algorithm>"},
{"valarray$", "<valarray>"}, {"valarray", "<valarray>"},
{"array$", "<array>"}, {"array", "<array>"},
{"atomic$", "<atomic>"}, {"atomic", "<atomic>"},
{"backward/auto_ptr.h$", "<memory>"}, {"backward/auto_ptr.h", "<memory>"},
{"backward/binders.h$", "<string>"}, {"backward/binders.h", "<string>"},
{"bits/algorithmfwd.h$", "<algorithm>"}, {"bits/algorithmfwd.h", "<algorithm>"},
{"bits/alloc_traits.h$", "<memory>"}, {"bits/alloc_traits.h", "<memory>"},
{"bits/allocated_ptr.h$", "<memory>"}, {"bits/allocated_ptr.h", "<memory>"},
{"bits/allocator.h$", "<allocator>"}, {"bits/allocator.h", "<allocator>"},
{"bits/atomic_base.h$", "<atomic>"}, {"bits/atomic_base.h", "<atomic>"},
{"bits/atomic_lockfree_defines.h$", "<exception>"}, {"bits/atomic_lockfree_defines.h", "<exception>"},
{"bits/atomic_futex.h$", "<atomic>"}, {"bits/atomic_futex.h", "<atomic>"},
{"bits/basic_ios.h$", "<ios>"}, {"bits/basic_ios.h", "<ios>"},
{"bits/basic_ios.tcc$", "<ios>"}, {"bits/basic_ios.tcc", "<ios>"},
{"bits/basic_string.h$", "<string>"}, {"bits/basic_string.h", "<string>"},
{"bits/basic_string.tcc$", "<string>"}, {"bits/basic_string.tcc", "<string>"},
{"bits/char_traits.h$", "<string>"}, {"bits/char_traits.h", "<string>"},
{"bits/codecvt.h$", "<locale>"}, {"bits/codecvt.h", "<locale>"},
{"bits/concept_check.h$", "<numeric>"}, {"bits/concept_check.h", "<numeric>"},
{"bits/cpp_type_traits.h$", "<cmath>"}, {"bits/cpp_type_traits.h", "<cmath>"},
{"bits/cxxabi_forced.h$", "<cxxabi.h>"}, {"bits/cxxabi_forced.h", "<cxxabi.h>"},
{"bits/deque.tcc$", "<deque>"}, {"bits/deque.tcc", "<deque>"},
{"bits/exception.h$", "<exception>"}, {"bits/exception.h", "<exception>"},
{"bits/exception_defines.h$", "<exception>"}, {"bits/exception_defines.h", "<exception>"},
{"bits/exception_ptr.h$", "<exception>"}, {"bits/exception_ptr.h", "<exception>"},
{"bits/forward_list.h$", "<forward_list>"}, {"bits/forward_list.h", "<forward_list>"},
{"bits/forward_list.tcc$", "<forward_list>"}, {"bits/forward_list.tcc", "<forward_list>"},
{"bits/fstream.tcc$", "<fstream>"}, {"bits/fstream.tcc", "<fstream>"},
{"bits/functexcept.h$", "<list>"}, {"bits/functexcept.h", "<list>"},
{"bits/functional_hash.h$", "<functional>"}, {"bits/functional_hash.h", "<functional>"},
{"bits/gslice.h$", "<valarray>"}, {"bits/gslice.h", "<valarray>"},
{"bits/gslice_array.h$", "<valarray>"}, {"bits/gslice_array.h", "<valarray>"},
{"bits/hash_bytes.h$", "<typeinfo>"}, {"bits/hash_bytes.h", "<typeinfo>"},
{"bits/hashtable.h$", "<unordered_set>"}, {"bits/hashtable.h", "<unordered_set>"},
{"bits/hashtable_policy.h$", "<unordered_set>"}, {"bits/hashtable_policy.h", "<unordered_set>"},
{"bits/indirect_array.h$", "<valarray>"}, {"bits/indirect_array.h", "<valarray>"},
{"bits/invoke.h$", "<functional>"}, {"bits/invoke.h", "<functional>"},
{"bits/ios_base.h$", "<ios>"}, {"bits/ios_base.h", "<ios>"},
{"bits/istream.tcc$", "<istream>"}, {"bits/istream.tcc", "<istream>"},
{"bits/list.tcc$", "<list>"}, {"bits/list.tcc", "<list>"},
{"bits/locale_classes.h$", "<locale>"}, {"bits/locale_classes.h", "<locale>"},
{"bits/locale_classes.tcc$", "<locale>"}, {"bits/locale_classes.tcc", "<locale>"},
{"bits/locale_conv.h$", "<locale>"}, {"bits/locale_conv.h", "<locale>"},
{"bits/locale_facets.h$", "<locale>"}, {"bits/locale_facets.h", "<locale>"},
{"bits/locale_facets.tcc$", "<locale>"}, {"bits/locale_facets.tcc", "<locale>"},
{"bits/locale_facets_nonio.h$", "<locale>"}, {"bits/locale_facets_nonio.h", "<locale>"},
{"bits/locale_facets_nonio.tcc$", "<locale>"}, {"bits/locale_facets_nonio.tcc", "<locale>"},
{"bits/localefwd.h$", "<locale>"}, {"bits/localefwd.h", "<locale>"},
{"bits/mask_array.h$", "<valarray>"}, {"bits/mask_array.h", "<valarray>"},
{"bits/memoryfwd.h$", "<memory>"}, {"bits/memoryfwd.h", "<memory>"},
{"bits/move.h$", "<utility>"}, {"bits/move.h", "<utility>"},
{"bits/nested_exception.h$", "<exception>"}, {"bits/nested_exception.h", "<exception>"},
{"bits/ostream.tcc$", "<ostream>"}, {"bits/ostream.tcc", "<ostream>"},
{"bits/ostream_insert.h$", "<ostream>"}, {"bits/ostream_insert.h", "<ostream>"},
{"bits/parse_numbers.h$", "<chrono>"}, {"bits/parse_numbers.h", "<chrono>"},
{"bits/postypes.h$", "<ios>"}, {"bits/postypes.h", "<ios>"},
{"bits/predefined_ops.h$", "<algorithm>"}, {"bits/predefined_ops.h", "<algorithm>"},
{"bits/ptr_traits.h$", "<memory>"}, {"bits/ptr_traits.h", "<memory>"},
{"bits/quoted_string.h$", "<iomanip>"}, {"bits/quoted_string.h", "<iomanip>"},
{"bits/random.h$", "<random>"}, {"bits/random.h", "<random>"},
{"bits/random.tcc$", "<random>"}, {"bits/random.tcc", "<random>"},
{"bits/range_access.h$", "<iterator>"}, {"bits/range_access.h", "<iterator>"},
{"bits/refwrap.h$", "<functional>"}, {"bits/refwrap.h", "<functional>"},
{"bits/regex.h$", "<regex>"}, {"bits/regex.h", "<regex>"},
{"bits/regex_automaton.h$", "<regex>"}, {"bits/regex_automaton.h", "<regex>"},
{"bits/regex_compiler.h$", "<regex>"}, {"bits/regex_compiler.h", "<regex>"},
{"bits/regex_constants.h$", "<regex>"}, {"bits/regex_constants.h", "<regex>"},
{"bits/regex_cursor.h$", "<regex>"}, {"bits/regex_cursor.h", "<regex>"},
{"bits/regex_error.h$", "<regex>"}, {"bits/regex_error.h", "<regex>"},
{"bits/regex_executor.h$", "<regex>"}, {"bits/regex_executor.h", "<regex>"},
{"bits/regex_grep_matcher.h$", "<regex>"}, {"bits/regex_grep_matcher.h", "<regex>"},
{"bits/regex_grep_matcher.tcc$", "<regex>"}, {"bits/regex_grep_matcher.tcc", "<regex>"},
{"bits/regex_nfa.h$", "<regex>"}, {"bits/regex_nfa.h", "<regex>"},
{"bits/regex_scanner.h$", "<regex>"}, {"bits/regex_scanner.h", "<regex>"},
{"bits/shared_ptr.h$", "<memory>"}, {"bits/shared_ptr.h", "<memory>"},
{"bits/shared_ptr_base.h$", "<memory>"}, {"bits/shared_ptr_base.h", "<memory>"},
{"bits/shared_ptr_atomic.h$", "<atomic>"}, {"bits/shared_ptr_atomic.h", "<atomic>"},
{"bits/slice_array.h$", "<valarray>"}, {"bits/slice_array.h", "<valarray>"},
{"bits/sstream.tcc$", "<sstream>"}, {"bits/sstream.tcc", "<sstream>"},
{"bits/std_abs.h$", "<cmath>"}, {"bits/std_abs.h", "<cmath>"},
{"bits/std_function.h$", "<functional>"}, {"bits/std_function.h", "<functional>"},
{"bits/std_mutex.h$", "<mutex>"}, {"bits/std_mutex.h", "<mutex>"},
{"bits/stl_algo.h$", "<algorithm>"}, {"bits/stl_algo.h", "<algorithm>"},
{"bits/stl_algobase.h$", "<algorithm>"}, {"bits/stl_algobase.h", "<algorithm>"},
{"bits/stl_bvector.h$", "<vector>"}, {"bits/stl_bvector.h", "<vector>"},
{"bits/stl_construct.h$", "<deque>"}, {"bits/stl_construct.h", "<deque>"},
{"bits/stl_deque.h$", "<deque>"}, {"bits/stl_deque.h", "<deque>"},
{"bits/stl_function.h$", "<functional>"}, {"bits/stl_function.h", "<functional>"},
{"bits/stl_heap.h$", "<heap>"}, {"bits/stl_heap.h", "<heap>"},
{"bits/stl_iterator.h$", "<iterator>"}, {"bits/stl_iterator.h", "<iterator>"},
{"bits/stl_iterator_base_funcs.h$", "<iterator>"}, {"bits/stl_iterator_base_funcs.h", "<iterator>"},
{"bits/stl_iterator_base_types.h$", "<iterator>"}, {"bits/stl_iterator_base_types.h", "<iterator>"},
{"bits/stl_list.h$", "<list>"}, {"bits/stl_list.h", "<list>"},
{"bits/stl_map.h$", "<map>"}, {"bits/stl_map.h", "<map>"},
{"bits/stl_multimap.h$", "<map>"}, {"bits/stl_multimap.h", "<map>"},
{"bits/stl_multiset.h$", "<set>"}, {"bits/stl_multiset.h", "<set>"},
{"bits/stl_numeric.h$", "<numeric>"}, {"bits/stl_numeric.h", "<numeric>"},
{"bits/stl_pair.h$", "<utility>"}, {"bits/stl_pair.h", "<utility>"},
{"bits/stl_queue.h$", "<queue>"}, {"bits/stl_queue.h", "<queue>"},
{"bits/stl_raw_storage_iter.h$", "<memory>"}, {"bits/stl_raw_storage_iter.h", "<memory>"},
{"bits/stl_relops.h$", "<utility>"}, {"bits/stl_relops.h", "<utility>"},
{"bits/stl_set.h$", "<set>"}, {"bits/stl_set.h", "<set>"},
{"bits/stl_stack.h$", "<stack>"}, {"bits/stl_stack.h", "<stack>"},
{"bits/stl_tempbuf.h$", "<memory>"}, {"bits/stl_tempbuf.h", "<memory>"},
{"bits/stl_tree.h$", "<map>"}, {"bits/stl_tree.h", "<map>"},
{"bits/stl_uninitialized.h$", "<memory>"}, {"bits/stl_uninitialized.h", "<memory>"},
{"bits/stl_vector.h$", "<vector>"}, {"bits/stl_vector.h", "<vector>"},
{"bits/stream_iterator.h$", "<iterator>"}, {"bits/stream_iterator.h", "<iterator>"},
{"bits/streambuf.tcc$", "<streambuf>"}, {"bits/streambuf.tcc", "<streambuf>"},
{"bits/streambuf_iterator.h$", "<iterator>"}, {"bits/streambuf_iterator.h", "<iterator>"},
{"bits/stringfwd.h$", "<string>"}, {"bits/stringfwd.h", "<string>"},
{"bits/uniform_int_dist.h$", "<random>"}, {"bits/uniform_int_dist.h", "<random>"},
{"bits/unique_ptr.h$", "<memory>"}, {"bits/unique_ptr.h", "<memory>"},
{"bits/unordered_map.h$", "<unordered_map>"}, {"bits/unordered_map.h", "<unordered_map>"},
{"bits/unordered_set.h$", "<unordered_set>"}, {"bits/unordered_set.h", "<unordered_set>"},
{"bits/uses_allocator.h$", "<memory>"}, {"bits/uses_allocator.h", "<memory>"},
{"bits/valarray_after.h$", "<valarray>"}, {"bits/valarray_after.h", "<valarray>"},
{"bits/valarray_array.h$", "<valarray>"}, {"bits/valarray_array.h", "<valarray>"},
{"bits/valarray_array.tcc$", "<valarray>"}, {"bits/valarray_array.tcc", "<valarray>"},
{"bits/valarray_before.h$", "<valarray>"}, {"bits/valarray_before.h", "<valarray>"},
{"bits/vector.tcc$", "<vector>"}, {"bits/vector.tcc", "<vector>"},
{"bitset$", "<bitset>"}, {"bitset", "<bitset>"},
{"ccomplex$", "<ccomplex>"}, {"ccomplex", "<ccomplex>"},
{"cctype$", "<cctype>"}, {"cctype", "<cctype>"},
{"cerrno$", "<cerrno>"}, {"cerrno", "<cerrno>"},
{"cfenv$", "<cfenv>"}, {"cfenv", "<cfenv>"},
{"cfloat$", "<cfloat>"}, {"cfloat", "<cfloat>"},
{"chrono$", "<chrono>"}, {"chrono", "<chrono>"},
{"cinttypes$", "<cinttypes>"}, {"cinttypes", "<cinttypes>"},
{"climits$", "<climits>"}, {"climits", "<climits>"},
{"clocale$", "<clocale>"}, {"clocale", "<clocale>"},
{"cmath$", "<cmath>"}, {"cmath", "<cmath>"},
{"complex$", "<complex>"}, {"complex", "<complex>"},
{"complex.h$", "<complex.h>"}, {"complex.h", "<complex.h>"},
{"condition_variable$", "<condition_variable>"}, {"condition_variable", "<condition_variable>"},
{"csetjmp$", "<csetjmp>"}, {"csetjmp", "<csetjmp>"},
{"csignal$", "<csignal>"}, {"csignal", "<csignal>"},
{"cstdalign$", "<cstdalign>"}, {"cstdalign", "<cstdalign>"},
{"cstdarg$", "<cstdarg>"}, {"cstdarg", "<cstdarg>"},
{"cstdbool$", "<cstdbool>"}, {"cstdbool", "<cstdbool>"},
{"cstdint$", "<cstdint>"}, {"cstdint", "<cstdint>"},
{"cstdio$", "<cstdio>"}, {"cstdio", "<cstdio>"},
{"cstdlib$", "<cstdlib>"}, {"cstdlib", "<cstdlib>"},
{"cstring$", "<cstring>"}, {"cstring", "<cstring>"},
{"ctgmath$", "<ctgmath>"}, {"ctgmath", "<ctgmath>"},
{"ctime$", "<ctime>"}, {"ctime", "<ctime>"},
{"cwchar$", "<cwchar>"}, {"cwchar", "<cwchar>"},
{"cwctype$", "<cwctype>"}, {"cwctype", "<cwctype>"},
{"cxxabi.h$", "<cxxabi.h>"}, {"cxxabi.h", "<cxxabi.h>"},
{"debug/debug.h$", "<numeric>"}, {"debug/debug.h", "<numeric>"},
{"debug/map.h$", "<map>"}, {"debug/map.h", "<map>"},
{"debug/multimap.h$", "<multimap>"}, {"debug/multimap.h", "<multimap>"},
{"debug/multiset.h$", "<multiset>"}, {"debug/multiset.h", "<multiset>"},
{"debug/set.h$", "<set>"}, {"debug/set.h", "<set>"},
{"deque$", "<deque>"}, {"deque", "<deque>"},
{"exception$", "<exception>"}, {"exception", "<exception>"},
{"ext/alloc_traits.h$", "<deque>"}, {"ext/alloc_traits.h", "<deque>"},
{"ext/atomicity.h$", "<memory>"}, {"ext/atomicity.h", "<memory>"},
{"ext/concurrence.h$", "<memory>"}, {"ext/concurrence.h", "<memory>"},
{"ext/new_allocator.h$", "<string>"}, {"ext/new_allocator.h", "<string>"},
{"ext/numeric_traits.h$", "<list>"}, {"ext/numeric_traits.h", "<list>"},
{"ext/string_conversions.h$", "<string>"}, {"ext/string_conversions.h", "<string>"},
{"ext/type_traits.h$", "<cmath>"}, {"ext/type_traits.h", "<cmath>"},
{"fenv.h$", "<fenv.h>"}, {"fenv.h", "<fenv.h>"},
{"forward_list$", "<forward_list>"}, {"forward_list", "<forward_list>"},
{"fstream$", "<fstream>"}, {"fstream", "<fstream>"},
{"functional$", "<functional>"}, {"functional", "<functional>"},
{"future$", "<future>"}, {"future", "<future>"},
{"initializer_list$", "<initializer_list>"}, {"initializer_list", "<initializer_list>"},
{"iomanip$", "<iomanip>"}, {"iomanip", "<iomanip>"},
{"ios$", "<ios>"}, {"ios", "<ios>"},
{"iosfwd$", "<iosfwd>"}, {"iosfwd", "<iosfwd>"},
{"iostream$", "<iostream>"}, {"iostream", "<iostream>"},
{"istream$", "<istream>"}, {"istream", "<istream>"},
{"iterator$", "<iterator>"}, {"iterator", "<iterator>"},
{"limits$", "<limits>"}, {"limits", "<limits>"},
{"list$", "<list>"}, {"list", "<list>"},
{"locale$", "<locale>"}, {"locale", "<locale>"},
{"map$", "<map>"}, {"map", "<map>"},
{"memory$", "<memory>"}, {"memory", "<memory>"},
{"shared_mutex$", "<shared_mutex>"}, {"shared_mutex", "<shared_mutex>"},
{"mutex$", "<mutex>"}, {"mutex", "<mutex>"},
{"new$", "<new>"}, {"new", "<new>"},
{"numeric$", "<numeric>"}, {"numeric", "<numeric>"},
{"ostream$", "<ostream>"}, {"ostream", "<ostream>"},
{"queue$", "<queue>"}, {"queue", "<queue>"},
{"random$", "<random>"}, {"random", "<random>"},
{"ratio$", "<ratio>"}, {"ratio", "<ratio>"},
{"regex$", "<regex>"}, {"regex", "<regex>"},
{"scoped_allocator$", "<scoped_allocator>"}, {"scoped_allocator", "<scoped_allocator>"},
{"set$", "<set>"}, {"set", "<set>"},
{"sstream$", "<sstream>"}, {"sstream", "<sstream>"},
{"stack$", "<stack>"}, {"stack", "<stack>"},
{"stdexcept$", "<stdexcept>"}, {"stdexcept", "<stdexcept>"},
{"streambuf$", "<streambuf>"}, {"streambuf", "<streambuf>"},
{"string$", "<string>"}, {"string", "<string>"},
{"system_error$", "<system_error>"}, {"system_error", "<system_error>"},
{"tgmath.h$", "<tgmath.h>"}, {"tgmath.h", "<tgmath.h>"},
{"thread$", "<thread>"}, {"thread", "<thread>"},
{"tuple$", "<tuple>"}, {"tuple", "<tuple>"},
{"type_traits$", "<type_traits>"}, {"type_traits", "<type_traits>"},
{"typeindex$", "<typeindex>"}, {"typeindex", "<typeindex>"},
{"typeinfo$", "<typeinfo>"}, {"typeinfo", "<typeinfo>"},
{"unordered_map$", "<unordered_map>"}, {"unordered_map", "<unordered_map>"},
{"unordered_set$", "<unordered_set>"}, {"unordered_set", "<unordered_set>"},
{"utility$", "<utility>"}, {"utility", "<utility>"},
{"valarray$", "<valarray>"}, {"valarray", "<valarray>"},
{"vector$", "<vector>"}, {"vector", "<vector>"},
{"include/complex.h$", "<complex.h>"}, {"include/complex.h", "<complex.h>"},
{"include/ctype.h$", "<cctype>"}, {"include/ctype.h", "<cctype>"},
{"include/errno.h$", "<cerrno>"}, {"include/errno.h", "<cerrno>"},
{"include/fenv.h$", "<fenv.h>"}, {"include/fenv.h", "<fenv.h>"},
{"include/inttypes.h$", "<cinttypes>"}, {"include/inttypes.h", "<cinttypes>"},
{"include/libio.h$", "<cstdio>"}, {"include/libio.h", "<cstdio>"},
{"include/limits.h$", "<climits>"}, {"include/limits.h", "<climits>"},
{"include/locale.h$", "<clocale>"}, {"include/locale.h", "<clocale>"},
{"include/math.h$", "<cmath>"}, {"include/math.h", "<cmath>"},
{"include/setjmp.h$", "<csetjmp>"}, {"include/setjmp.h", "<csetjmp>"},
{"include/signal.h$", "<csignal>"}, {"include/signal.h", "<csignal>"},
{"include/stdint.h$", "<cstdint>"}, {"include/stdint.h", "<cstdint>"},
{"include/stdio.h$", "<cstdio>"}, {"include/stdio.h", "<cstdio>"},
{"include/stdlib.h$", "<cstdlib>"}, {"include/stdlib.h", "<cstdlib>"},
{"include/string.h$", "<cstring>"}, {"include/string.h", "<cstring>"},
{"include/time.h$", "<ctime>"}, {"include/time.h", "<ctime>"},
{"include/wchar.h$", "<cwchar>"}, {"include/wchar.h", "<cwchar>"},
{"include/wctype.h$", "<cwctype>"}, {"include/wctype.h", "<cwctype>"},
{"bits/cmathcalls.h$", "<complex.h>"}, {"bits/cmathcalls.h", "<complex.h>"},
{"bits/errno.h$", "<cerrno>"}, {"bits/errno.h", "<cerrno>"},
{"bits/fenv.h$", "<fenv.h>"}, {"bits/fenv.h", "<fenv.h>"},
{"bits/huge_val.h$", "<cmath>"}, {"bits/huge_val.h", "<cmath>"},
{"bits/huge_valf.h$", "<cmath>"}, {"bits/huge_valf.h", "<cmath>"},
{"bits/huge_vall.h$", "<cmath>"}, {"bits/huge_vall.h", "<cmath>"},
{"bits/inf.h$", "<cmath>"}, {"bits/inf.h", "<cmath>"},
{"bits/local_lim.h$", "<climits>"}, {"bits/local_lim.h", "<climits>"},
{"bits/locale.h$", "<clocale>"}, {"bits/locale.h", "<clocale>"},
{"bits/mathcalls.h$", "<math.h>"}, {"bits/mathcalls.h", "<math.h>"},
{"bits/mathdef.h$", "<cmath>"}, {"bits/mathdef.h", "<cmath>"},
{"bits/nan.h$", "<cmath>"}, {"bits/nan.h", "<cmath>"},
{"bits/posix1_lim.h$", "<climits>"}, {"bits/posix1_lim.h", "<climits>"},
{"bits/posix2_lim.h$", "<climits>"}, {"bits/posix2_lim.h", "<climits>"},
{"bits/setjmp.h$", "<csetjmp>"}, {"bits/setjmp.h", "<csetjmp>"},
{"bits/sigaction.h$", "<csignal>"}, {"bits/sigaction.h", "<csignal>"},
{"bits/sigcontext.h$", "<csignal>"}, {"bits/sigcontext.h", "<csignal>"},
{"bits/siginfo.h$", "<csignal>"}, {"bits/siginfo.h", "<csignal>"},
{"bits/signum.h$", "<csignal>"}, {"bits/signum.h", "<csignal>"},
{"bits/sigset.h$", "<csignal>"}, {"bits/sigset.h", "<csignal>"},
{"bits/sigstack.h$", "<csignal>"}, {"bits/sigstack.h", "<csignal>"},
{"bits/stdio_lim.h$", "<cstdio>"}, {"bits/stdio_lim.h", "<cstdio>"},
{"bits/sys_errlist.h$", "<cstdio>"}, {"bits/sys_errlist.h", "<cstdio>"},
{"bits/time.h$", "<ctime>"}, {"bits/time.h", "<ctime>"},
{"bits/timex.h$", "<ctime>"}, {"bits/timex.h", "<ctime>"},
{"bits/typesizes.h$", "<cstdio>"}, {"bits/typesizes.h", "<cstdio>"},
{"bits/wchar.h$", "<cwchar>"}, {"bits/wchar.h", "<cwchar>"},
{"bits/wordsize.h$", "<csetjmp>"}, {"bits/wordsize.h", "<csetjmp>"},
{"bits/xopen_lim.h$", "<climits>"}, {"bits/xopen_lim.h", "<climits>"},
{"include/xlocale.h$", "<cstring>"}, {"include/xlocale.h", "<cstring>"},
{"bits/atomic_word.h$", "<memory>"}, {"bits/atomic_word.h", "<memory>"},
{"bits/basic_file.h$", "<fstream>"}, {"bits/basic_file.h", "<fstream>"},
{"bits/c\\+\\+allocator.h$", "<string>"}, {"bits/c\\+\\+allocator.h", "<string>"},
{"bits/c\\+\\+config.h$", "<cstddef>"}, {"bits/c\\+\\+config.h", "<cstddef>"},
{"bits/c\\+\\+io.h$", "<ios>"}, {"bits/c\\+\\+io.h", "<ios>"},
{"bits/c\\+\\+locale.h$", "<locale>"}, {"bits/c\\+\\+locale.h", "<locale>"},
{"bits/cpu_defines.h$", "<iosfwd>"}, {"bits/cpu_defines.h", "<iosfwd>"},
{"bits/ctype_base.h$", "<locale>"}, {"bits/ctype_base.h", "<locale>"},
{"bits/cxxabi_tweaks.h$", "<cxxabi.h>"}, {"bits/cxxabi_tweaks.h", "<cxxabi.h>"},
{"bits/error_constants.h$", "<system_error>"}, {"bits/error_constants.h", "<system_error>"},
{"bits/gthr-default.h$", "<memory>"}, {"bits/gthr-default.h", "<memory>"},
{"bits/gthr.h$", "<memory>"}, {"bits/gthr.h", "<memory>"},
{"bits/opt_random.h$", "<random>"}, {"bits/opt_random.h", "<random>"},
{"bits/os_defines.h$", "<iosfwd>"}, {"bits/os_defines.h", "<iosfwd>"},
// GNU C headers // GNU C headers
{"include/aio.h$", "<aio.h>"}, {"include/aio.h", "<aio.h>"},
{"include/aliases.h$", "<aliases.h>"}, {"include/aliases.h", "<aliases.h>"},
{"include/alloca.h$", "<alloca.h>"}, {"include/alloca.h", "<alloca.h>"},
{"include/ar.h$", "<ar.h>"}, {"include/ar.h", "<ar.h>"},
{"include/argp.h$", "<argp.h>"}, {"include/argp.h", "<argp.h>"},
{"include/argz.h$", "<argz.h>"}, {"include/argz.h", "<argz.h>"},
{"include/arpa/nameser.h$", "<resolv.h>"}, {"include/arpa/nameser.h", "<resolv.h>"},
{"include/arpa/nameser_compat.h$", "<resolv.h>"}, {"include/arpa/nameser_compat.h", "<resolv.h>"},
{"include/byteswap.h$", "<byteswap.h>"}, {"include/byteswap.h", "<byteswap.h>"},
{"include/cpio.h$", "<cpio.h>"}, {"include/cpio.h", "<cpio.h>"},
{"include/crypt.h$", "<crypt.h>"}, {"include/crypt.h", "<crypt.h>"},
{"include/dirent.h$", "<dirent.h>"}, {"include/dirent.h", "<dirent.h>"},
{"include/dlfcn.h$", "<dlfcn.h>"}, {"include/dlfcn.h", "<dlfcn.h>"},
{"include/elf.h$", "<elf.h>"}, {"include/elf.h", "<elf.h>"},
{"include/endian.h$", "<endian.h>"}, {"include/endian.h", "<endian.h>"},
{"include/envz.h$", "<envz.h>"}, {"include/envz.h", "<envz.h>"},
{"include/err.h$", "<err.h>"}, {"include/err.h", "<err.h>"},
{"include/error.h$", "<error.h>"}, {"include/error.h", "<error.h>"},
{"include/execinfo.h$", "<execinfo.h>"}, {"include/execinfo.h", "<execinfo.h>"},
{"include/fcntl.h$", "<fcntl.h>"}, {"include/fcntl.h", "<fcntl.h>"},
{"include/features.h$", "<features.h>"}, {"include/features.h", "<features.h>"},
{"include/fenv.h$", "<fenv.h>"}, {"include/fenv.h", "<fenv.h>"},
{"include/fmtmsg.h$", "<fmtmsg.h>"}, {"include/fmtmsg.h", "<fmtmsg.h>"},
{"include/fnmatch.h$", "<fnmatch.h>"}, {"include/fnmatch.h", "<fnmatch.h>"},
{"include/fstab.h$", "<fstab.h>"}, {"include/fstab.h", "<fstab.h>"},
{"include/fts.h$", "<fts.h>"}, {"include/fts.h", "<fts.h>"},
{"include/ftw.h$", "<ftw.h>"}, {"include/ftw.h", "<ftw.h>"},
{"include/gconv.h$", "<gconv.h>"}, {"include/gconv.h", "<gconv.h>"},
{"include/getopt.h$", "<getopt.h>"}, {"include/getopt.h", "<getopt.h>"},
{"include/glob.h$", "<glob.h>"}, {"include/glob.h", "<glob.h>"},
{"include/grp.h$", "<grp.h>"}, {"include/grp.h", "<grp.h>"},
{"include/gshadow.h$", "<gshadow.h>"}, {"include/gshadow.h", "<gshadow.h>"},
{"include/iconv.h$", "<iconv.h>"}, {"include/iconv.h", "<iconv.h>"},
{"include/ifaddrs.h$", "<ifaddrs.h>"}, {"include/ifaddrs.h", "<ifaddrs.h>"},
{"include/kdb.h$", "<kdb.h>"}, {"include/kdb.h", "<kdb.h>"},
{"include/langinfo.h$", "<langinfo.h>"}, {"include/langinfo.h", "<langinfo.h>"},
{"include/libgen.h$", "<libgen.h>"}, {"include/libgen.h", "<libgen.h>"},
{"include/libintl.h$", "<libintl.h>"}, {"include/libintl.h", "<libintl.h>"},
{"include/link.h$", "<link.h>"}, {"include/link.h", "<link.h>"},
{"include/malloc.h$", "<malloc.h>"}, {"include/malloc.h", "<malloc.h>"},
{"include/mcheck.h$", "<mcheck.h>"}, {"include/mcheck.h", "<mcheck.h>"},
{"include/memory.h$", "<memory.h>"}, {"include/memory.h", "<memory.h>"},
{"include/mntent.h$", "<mntent.h>"}, {"include/mntent.h", "<mntent.h>"},
{"include/monetary.h$", "<monetary.h>"}, {"include/monetary.h", "<monetary.h>"},
{"include/mqueue.h$", "<mqueue.h>"}, {"include/mqueue.h", "<mqueue.h>"},
{"include/netdb.h$", "<netdb.h>"}, {"include/netdb.h", "<netdb.h>"},
{"include/netinet/in.h$", "<netinet/in.h>"}, {"include/netinet/in.h", "<netinet/in.h>"},
{"include/nl_types.h$", "<nl_types.h>"}, {"include/nl_types.h", "<nl_types.h>"},
{"include/nss.h$", "<nss.h>"}, {"include/nss.h", "<nss.h>"},
{"include/obstack.h$", "<obstack.h>"}, {"include/obstack.h", "<obstack.h>"},
{"include/panel.h$", "<panel.h>"}, {"include/panel.h", "<panel.h>"},
{"include/paths.h$", "<paths.h>"}, {"include/paths.h", "<paths.h>"},
{"include/printf.h$", "<printf.h>"}, {"include/printf.h", "<printf.h>"},
{"include/profile.h$", "<profile.h>"}, {"include/profile.h", "<profile.h>"},
{"include/pthread.h$", "<pthread.h>"}, {"include/pthread.h", "<pthread.h>"},
{"include/pty.h$", "<pty.h>"}, {"include/pty.h", "<pty.h>"},
{"include/pwd.h$", "<pwd.h>"}, {"include/pwd.h", "<pwd.h>"},
{"include/re_comp.h$", "<re_comp.h>"}, {"include/re_comp.h", "<re_comp.h>"},
{"include/regex.h$", "<regex.h>"}, {"include/regex.h", "<regex.h>"},
{"include/regexp.h$", "<regexp.h>"}, {"include/regexp.h", "<regexp.h>"},
{"include/resolv.h$", "<resolv.h>"}, {"include/resolv.h", "<resolv.h>"},
{"include/rpc/netdb.h$", "<netdb.h>"}, {"include/rpc/netdb.h", "<netdb.h>"},
{"include/sched.h$", "<sched.h>"}, {"include/sched.h", "<sched.h>"},
{"include/search.h$", "<search.h>"}, {"include/search.h", "<search.h>"},
{"include/semaphore.h$", "<semaphore.h>"}, {"include/semaphore.h", "<semaphore.h>"},
{"include/sgtty.h$", "<sgtty.h>"}, {"include/sgtty.h", "<sgtty.h>"},
{"include/shadow.h$", "<shadow.h>"}, {"include/shadow.h", "<shadow.h>"},
{"include/spawn.h$", "<spawn.h>"}, {"include/spawn.h", "<spawn.h>"},
{"include/stab.h$", "<stab.h>"}, {"include/stab.h", "<stab.h>"},
{"include/stdc-predef.h$", "<stdc-predef.h>"}, {"include/stdc-predef.h", "<stdc-predef.h>"},
{"include/stdio_ext.h$", "<stdio_ext.h>"}, {"include/stdio_ext.h", "<stdio_ext.h>"},
{"include/strings.h$", "<strings.h>"}, {"include/strings.h", "<strings.h>"},
{"include/stropts.h$", "<stropts.h>"}, {"include/stropts.h", "<stropts.h>"},
{"include/sudo_plugin.h$", "<sudo_plugin.h>"}, {"include/sudo_plugin.h", "<sudo_plugin.h>"},
{"include/sysexits.h$", "<sysexits.h>"}, {"include/sysexits.h", "<sysexits.h>"},
{"include/tar.h$", "<tar.h>"}, {"include/tar.h", "<tar.h>"},
{"include/tcpd.h$", "<tcpd.h>"}, {"include/tcpd.h", "<tcpd.h>"},
{"include/term.h$", "<term.h>"}, {"include/term.h", "<term.h>"},
{"include/term_entry.h$", "<term_entry.h>"}, {"include/term_entry.h", "<term_entry.h>"},
{"include/termcap.h$", "<termcap.h>"}, {"include/termcap.h", "<termcap.h>"},
{"include/termios.h$", "<termios.h>"}, {"include/termios.h", "<termios.h>"},
{"include/thread_db.h$", "<thread_db.h>"}, {"include/thread_db.h", "<thread_db.h>"},
{"include/tic.h$", "<tic.h>"}, {"include/tic.h", "<tic.h>"},
{"include/ttyent.h$", "<ttyent.h>"}, {"include/ttyent.h", "<ttyent.h>"},
{"include/uchar.h$", "<uchar.h>"}, {"include/uchar.h", "<uchar.h>"},
{"include/ucontext.h$", "<ucontext.h>"}, {"include/ucontext.h", "<ucontext.h>"},
{"include/ulimit.h$", "<ulimit.h>"}, {"include/ulimit.h", "<ulimit.h>"},
{"include/unctrl.h$", "<unctrl.h>"}, {"include/unctrl.h", "<unctrl.h>"},
{"include/unistd.h$", "<unistd.h>"}, {"include/unistd.h", "<unistd.h>"},
{"include/utime.h$", "<utime.h>"}, {"include/utime.h", "<utime.h>"},
{"include/utmp.h$", "<utmp.h>"}, {"include/utmp.h", "<utmp.h>"},
{"include/utmpx.h$", "<utmpx.h>"}, {"include/utmpx.h", "<utmpx.h>"},
{"include/values.h$", "<values.h>"}, {"include/values.h", "<values.h>"},
{"include/wordexp.h$", "<wordexp.h>"}, {"include/wordexp.h", "<wordexp.h>"},
{"fpu_control.h$", "<fpu_control.h>"}, {"fpu_control.h", "<fpu_control.h>"},
{"ieee754.h$", "<ieee754.h>"}, {"ieee754.h", "<ieee754.h>"},
{"include/xlocale.h$", "<xlocale.h>"}, {"include/xlocale.h", "<xlocale.h>"},
{"gnu/lib-names.h$", "<gnu/lib-names.h>"}, {"gnu/lib-names.h", "<gnu/lib-names.h>"},
{"gnu/libc-version.h$", "<gnu/libc-version.h>"}, {"gnu/libc-version.h", "<gnu/libc-version.h>"},
{"gnu/option-groups.h$", "<gnu/option-groups.h>"}, {"gnu/option-groups.h", "<gnu/option-groups.h>"},
{"gnu/stubs-32.h$", "<gnu/stubs-32.h>"}, {"gnu/stubs-32.h", "<gnu/stubs-32.h>"},
{"gnu/stubs-64.h$", "<gnu/stubs-64.h>"}, {"gnu/stubs-64.h", "<gnu/stubs-64.h>"},
{"gnu/stubs-x32.h$", "<gnu/stubs-x32.h>"}, {"gnu/stubs-x32.h", "<gnu/stubs-x32.h>"},
{"include/rpc/auth_des.h$", "<rpc/auth_des.h>"}, {"include/rpc/auth_des.h", "<rpc/auth_des.h>"},
{"include/rpc/rpc_msg.h$", "<rpc/rpc_msg.h>"}, {"include/rpc/rpc_msg.h", "<rpc/rpc_msg.h>"},
{"include/rpc/pmap_clnt.h$", "<rpc/pmap_clnt.h>"}, {"include/rpc/pmap_clnt.h", "<rpc/pmap_clnt.h>"},
{"include/rpc/rpc.h$", "<rpc/rpc.h>"}, {"include/rpc/rpc.h", "<rpc/rpc.h>"},
{"include/rpc/types.h$", "<rpc/types.h>"}, {"include/rpc/types.h", "<rpc/types.h>"},
{"include/rpc/auth_unix.h$", "<rpc/auth_unix.h>"}, {"include/rpc/auth_unix.h", "<rpc/auth_unix.h>"},
{"include/rpc/key_prot.h$", "<rpc/key_prot.h>"}, {"include/rpc/key_prot.h", "<rpc/key_prot.h>"},
{"include/rpc/pmap_prot.h$", "<rpc/pmap_prot.h>"}, {"include/rpc/pmap_prot.h", "<rpc/pmap_prot.h>"},
{"include/rpc/auth.h$", "<rpc/auth.h>"}, {"include/rpc/auth.h", "<rpc/auth.h>"},
{"include/rpc/svc_auth.h$", "<rpc/svc_auth.h>"}, {"include/rpc/svc_auth.h", "<rpc/svc_auth.h>"},
{"include/rpc/xdr.h$", "<rpc/xdr.h>"}, {"include/rpc/xdr.h", "<rpc/xdr.h>"},
{"include/rpc/pmap_rmt.h$", "<rpc/pmap_rmt.h>"}, {"include/rpc/pmap_rmt.h", "<rpc/pmap_rmt.h>"},
{"include/rpc/des_crypt.h$", "<rpc/des_crypt.h>"}, {"include/rpc/des_crypt.h", "<rpc/des_crypt.h>"},
{"include/rpc/svc.h$", "<rpc/svc.h>"}, {"include/rpc/svc.h", "<rpc/svc.h>"},
{"include/rpc/rpc_des.h$", "<rpc/rpc_des.h>"}, {"include/rpc/rpc_des.h", "<rpc/rpc_des.h>"},
{"include/rpc/clnt.h$", "<rpc/clnt.h>"}, {"include/rpc/clnt.h", "<rpc/clnt.h>"},
{"include/scsi/scsi.h$", "<scsi/scsi.h>"}, {"include/scsi/scsi.h", "<scsi/scsi.h>"},
{"include/scsi/sg.h$", "<scsi/sg.h>"}, {"include/scsi/sg.h", "<scsi/sg.h>"},
{"include/scsi/scsi_ioctl.h$", "<scsi/scsi_ioctl>"}, {"include/scsi/scsi_ioctl.h", "<scsi/scsi_ioctl>"},
{"include/netrose/rose.h$", "<netrose/rose.h>"}, {"include/netrose/rose.h", "<netrose/rose.h>"},
{"include/nfs/nfs.h$", "<nfs/nfs.h>"}, {"include/nfs/nfs.h", "<nfs/nfs.h>"},
{"include/netatalk/at.h$", "<netatalk/at.h>"}, {"include/netatalk/at.h", "<netatalk/at.h>"},
{"include/netinet/ether.h$", "<netinet/ether.h>"}, {"include/netinet/ether.h", "<netinet/ether.h>"},
{"include/netinet/icmp6.h$", "<netinet/icmp6.h>"}, {"include/netinet/icmp6.h", "<netinet/icmp6.h>"},
{"include/netinet/if_ether.h$", "<netinet/if_ether.h>"}, {"include/netinet/if_ether.h", "<netinet/if_ether.h>"},
{"include/netinet/if_fddi.h$", "<netinet/if_fddi.h>"}, {"include/netinet/if_fddi.h", "<netinet/if_fddi.h>"},
{"include/netinet/if_tr.h$", "<netinet/if_tr.h>"}, {"include/netinet/if_tr.h", "<netinet/if_tr.h>"},
{"include/netinet/igmp.h$", "<netinet/igmp.h>"}, {"include/netinet/igmp.h", "<netinet/igmp.h>"},
{"include/netinet/in.h$", "<netinet/in.h>"}, {"include/netinet/in.h", "<netinet/in.h>"},
{"include/netinet/in_systm.h$", "<netinet/in_systm.h>"}, {"include/netinet/in_systm.h", "<netinet/in_systm.h>"},
{"include/netinet/ip.h$", "<netinet/ip.h>"}, {"include/netinet/ip.h", "<netinet/ip.h>"},
{"include/netinet/ip6.h$", "<netinet/ip6.h>"}, {"include/netinet/ip6.h", "<netinet/ip6.h>"},
{"include/netinet/ip_icmp.h$", "<netinet/ip_icmp.h>"}, {"include/netinet/ip_icmp.h", "<netinet/ip_icmp.h>"},
{"include/netinet/tcp.h$", "<netinet/tcp.h>"}, {"include/netinet/tcp.h", "<netinet/tcp.h>"},
{"include/netinet/udp.h$", "<netinet/udp.h>"}, {"include/netinet/udp.h", "<netinet/udp.h>"},
{"include/netrom/netrom.h$", "<netrom/netrom.h>"}, {"include/netrom/netrom.h", "<netrom/netrom.h>"},
{"include/protocols/routed.h$", "<protocols/routed.h>"}, {"include/protocols/routed.h", "<protocols/routed.h>"},
{"include/protocols/rwhod.h$", "<protocols/rwhod.h>"}, {"include/protocols/rwhod.h", "<protocols/rwhod.h>"},
{"include/protocols/talkd.h$", "<protocols/talkd.h>"}, {"include/protocols/talkd.h", "<protocols/talkd.h>"},
{"include/protocols/timed.h$", "<protocols/timed.h>"}, {"include/protocols/timed.h", "<protocols/timed.h>"},
{"include/rpcsvc/klm_prot.x$", "<rpcsvc/klm_prot.x>"}, {"include/rpcsvc/klm_prot.x", "<rpcsvc/klm_prot.x>"},
{"include/rpcsvc/rstat.h$", "<rpcsvc/rstat.h>"}, {"include/rpcsvc/rstat.h", "<rpcsvc/rstat.h>"},
{"include/rpcsvc/spray.x$", "<rpcsvc/spray.x>"}, {"include/rpcsvc/spray.x", "<rpcsvc/spray.x>"},
{"include/rpcsvc/nlm_prot.x$", "<rpcsvc/nlm_prot.x>"}, {"include/rpcsvc/nlm_prot.x", "<rpcsvc/nlm_prot.x>"},
{"include/rpcsvc/nis_callback.x$", "<rpcsvc/nis_callback.x>"}, {"include/rpcsvc/nis_callback.x", "<rpcsvc/nis_callback.x>"},
{"include/rpcsvc/yp.h$", "<rpcsvc/yp.h>"}, {"include/rpcsvc/yp.h", "<rpcsvc/yp.h>"},
{"include/rpcsvc/yp.x$", "<rpcsvc/yp.x>"}, {"include/rpcsvc/yp.x", "<rpcsvc/yp.x>"},
{"include/rpcsvc/nfs_prot.h$", "<rpcsvc/nfs_prot.h>"}, {"include/rpcsvc/nfs_prot.h", "<rpcsvc/nfs_prot.h>"},
{"include/rpcsvc/rex.h$", "<rpcsvc/rex.h>"}, {"include/rpcsvc/rex.h", "<rpcsvc/rex.h>"},
{"include/rpcsvc/yppasswd.h$", "<rpcsvc/yppasswd.h>"}, {"include/rpcsvc/yppasswd.h", "<rpcsvc/yppasswd.h>"},
{"include/rpcsvc/rex.x$", "<rpcsvc/rex.x>"}, {"include/rpcsvc/rex.x", "<rpcsvc/rex.x>"},
{"include/rpcsvc/nis_tags.h$", "<rpcsvc/nis_tags.h>"}, {"include/rpcsvc/nis_tags.h", "<rpcsvc/nis_tags.h>"},
{"include/rpcsvc/nis_callback.h$", "<rpcsvc/nis_callback.h>"}, {"include/rpcsvc/nis_callback.h", "<rpcsvc/nis_callback.h>"},
{"include/rpcsvc/nfs_prot.x$", "<rpcsvc/nfs_prot.x>"}, {"include/rpcsvc/nfs_prot.x", "<rpcsvc/nfs_prot.x>"},
{"include/rpcsvc/bootparam_prot.x$", "<rpcsvc/bootparam_prot.x>"}, {"include/rpcsvc/bootparam_prot.x", "<rpcsvc/bootparam_prot.x>"},
{"include/rpcsvc/rusers.x$", "<rpcsvc/rusers.x>"}, {"include/rpcsvc/rusers.x", "<rpcsvc/rusers.x>"},
{"include/rpcsvc/rquota.x$", "<rpcsvc/rquota.x>"}, {"include/rpcsvc/rquota.x", "<rpcsvc/rquota.x>"},
{"include/rpcsvc/nis.h$", "<rpcsvc/nis.h>"}, {"include/rpcsvc/nis.h", "<rpcsvc/nis.h>"},
{"include/rpcsvc/nislib.h$", "<rpcsvc/nislib.h>"}, {"include/rpcsvc/nislib.h", "<rpcsvc/nislib.h>"},
{"include/rpcsvc/ypupd.h$", "<rpcsvc/ypupd.h>"}, {"include/rpcsvc/ypupd.h", "<rpcsvc/ypupd.h>"},
{"include/rpcsvc/bootparam.h$", "<rpcsvc/bootparam.h>"}, {"include/rpcsvc/bootparam.h", "<rpcsvc/bootparam.h>"},
{"include/rpcsvc/spray.h$", "<rpcsvc/spray.h>"}, {"include/rpcsvc/spray.h", "<rpcsvc/spray.h>"},
{"include/rpcsvc/key_prot.h$", "<rpcsvc/key_prot.h>"}, {"include/rpcsvc/key_prot.h", "<rpcsvc/key_prot.h>"},
{"include/rpcsvc/klm_prot.h$", "<rpcsvc/klm_prot.h>"}, {"include/rpcsvc/klm_prot.h", "<rpcsvc/klm_prot.h>"},
{"include/rpcsvc/sm_inter.h$", "<rpcsvc/sm_inter.h>"}, {"include/rpcsvc/sm_inter.h", "<rpcsvc/sm_inter.h>"},
{"include/rpcsvc/nlm_prot.h$", "<rpcsvc/nlm_prot.h>"}, {"include/rpcsvc/nlm_prot.h", "<rpcsvc/nlm_prot.h>"},
{"include/rpcsvc/yp_prot.h$", "<rpcsvc/yp_prot.h>"}, {"include/rpcsvc/yp_prot.h", "<rpcsvc/yp_prot.h>"},
{"include/rpcsvc/ypclnt.h$", "<rpcsvc/ypclnt.h>"}, {"include/rpcsvc/ypclnt.h", "<rpcsvc/ypclnt.h>"},
{"include/rpcsvc/rstat.x$", "<rpcsvc/rstat.x>"}, {"include/rpcsvc/rstat.x", "<rpcsvc/rstat.x>"},
{"include/rpcsvc/rusers.h$", "<rpcsvc/rusers.h>"}, {"include/rpcsvc/rusers.h", "<rpcsvc/rusers.h>"},
{"include/rpcsvc/key_prot.x$", "<rpcsvc/key_prot.x>"}, {"include/rpcsvc/key_prot.x", "<rpcsvc/key_prot.x>"},
{"include/rpcsvc/sm_inter.x$", "<rpcsvc/sm_inter.x>"}, {"include/rpcsvc/sm_inter.x", "<rpcsvc/sm_inter.x>"},
{"include/rpcsvc/rquota.h$", "<rpcsvc/rquota.h>"}, {"include/rpcsvc/rquota.h", "<rpcsvc/rquota.h>"},
{"include/rpcsvc/nis.x$", "<rpcsvc/nis.x>"}, {"include/rpcsvc/nis.x", "<rpcsvc/nis.x>"},
{"include/rpcsvc/bootparam_prot.h$", "<rpcsvc/bootparam_prot.h>"}, {"include/rpcsvc/bootparam_prot.h", "<rpcsvc/bootparam_prot.h>"},
{"include/rpcsvc/mount.h$", "<rpcsvc/mount.h>"}, {"include/rpcsvc/mount.h", "<rpcsvc/mount.h>"},
{"include/rpcsvc/mount.x$", "<rpcsvc/mount.x>"}, {"include/rpcsvc/mount.x", "<rpcsvc/mount.x>"},
{"include/rpcsvc/nis_object.x$", "<rpcsvc/nis_object.x>"}, {"include/rpcsvc/nis_object.x", "<rpcsvc/nis_object.x>"},
{"include/rpcsvc/yppasswd.x$", "<rpcsvc/yppasswd.x>"}, {"include/rpcsvc/yppasswd.x", "<rpcsvc/yppasswd.x>"},
{"sys/acct.h$", "<sys/acct.h>"}, {"sys/acct.h", "<sys/acct.h>"},
{"sys/auxv.h$", "<sys/auxv.h>"}, {"sys/auxv.h", "<sys/auxv.h>"},
{"sys/cdefs.h$", "<sys/cdefs.h>"}, {"sys/cdefs.h", "<sys/cdefs.h>"},
{"sys/debugreg.h$", "<sys/debugreg.h>"}, {"sys/debugreg.h", "<sys/debugreg.h>"},
{"sys/dir.h$", "<sys/dir.h>"}, {"sys/dir.h", "<sys/dir.h>"},
{"sys/elf.h$", "<sys/elf.h>"}, {"sys/elf.h", "<sys/elf.h>"},
{"sys/epoll.h$", "<sys/epoll.h>"}, {"sys/epoll.h", "<sys/epoll.h>"},
{"sys/eventfd.h$", "<sys/eventfd.h>"}, {"sys/eventfd.h", "<sys/eventfd.h>"},
{"sys/fanotify.h$", "<sys/fanotify.h>"}, {"sys/fanotify.h", "<sys/fanotify.h>"},
{"sys/file.h$", "<sys/file.h>"}, {"sys/file.h", "<sys/file.h>"},
{"sys/fsuid.h$", "<sys/fsuid.h>"}, {"sys/fsuid.h", "<sys/fsuid.h>"},
{"sys/gmon.h$", "<sys/gmon.h>"}, {"sys/gmon.h", "<sys/gmon.h>"},
{"sys/gmon_out.h$", "<sys/gmon_out.h>"}, {"sys/gmon_out.h", "<sys/gmon_out.h>"},
{"sys/inotify.h$", "<sys/inotify.h>"}, {"sys/inotify.h", "<sys/inotify.h>"},
{"sys/io.h$", "<sys/io.h>"}, {"sys/io.h", "<sys/io.h>"},
{"sys/ioctl.h$", "<sys/ioctl.h>"}, {"sys/ioctl.h", "<sys/ioctl.h>"},
{"sys/ipc.h$", "<sys/ipc.h>"}, {"sys/ipc.h", "<sys/ipc.h>"},
{"sys/kd.h$", "<sys/kd.h>"}, {"sys/kd.h", "<sys/kd.h>"},
{"sys/kdaemon.h$", "<sys/kdaemon.h>"}, {"sys/kdaemon.h", "<sys/kdaemon.h>"},
{"sys/klog.h$", "<sys/klog.h>"}, {"sys/klog.h", "<sys/klog.h>"},
{"sys/mman.h$", "<sys/mman.h>"}, {"sys/mman.h", "<sys/mman.h>"},
{"sys/mount.h$", "<sys/mount.h>"}, {"sys/mount.h", "<sys/mount.h>"},
{"sys/msg.h$", "<sys/msg.h>"}, {"sys/msg.h", "<sys/msg.h>"},
{"sys/mtio.h$", "<sys/mtio.h>"}, {"sys/mtio.h", "<sys/mtio.h>"},
{"sys/param.h$", "<sys/param.h>"}, {"sys/param.h", "<sys/param.h>"},
{"sys/pci.h$", "<sys/pci.h>"}, {"sys/pci.h", "<sys/pci.h>"},
{"sys/perm.h$", "<sys/perm.h>"}, {"sys/perm.h", "<sys/perm.h>"},
{"sys/personality.h$", "<sys/personality.h>"}, {"sys/personality.h", "<sys/personality.h>"},
{"sys/poll.h$", "<sys/poll.h>"}, {"sys/poll.h", "<sys/poll.h>"},
{"sys/prctl.h$", "<sys/prctl.h>"}, {"sys/prctl.h", "<sys/prctl.h>"},
{"sys/procfs.h$", "<sys/procfs.h>"}, {"sys/procfs.h", "<sys/procfs.h>"},
{"sys/profil.h$", "<sys/profil.h>"}, {"sys/profil.h", "<sys/profil.h>"},
{"sys/ptrace.h$", "<sys/ptrace.h>"}, {"sys/ptrace.h", "<sys/ptrace.h>"},
{"sys/queue.h$", "<sys/queue.h>"}, {"sys/queue.h", "<sys/queue.h>"},
{"sys/quota.h$", "<sys/quota.h>"}, {"sys/quota.h", "<sys/quota.h>"},
{"sys/raw.h$", "<sys/raw.h>"}, {"sys/raw.h", "<sys/raw.h>"},
{"sys/reboot.h$", "<sys/reboot.h>"}, {"sys/reboot.h", "<sys/reboot.h>"},
{"sys/reg.h$", "<sys/reg.h>"}, {"sys/reg.h", "<sys/reg.h>"},
{"sys/resource.h$", "<sys/resource.h>"}, {"sys/resource.h", "<sys/resource.h>"},
{"sys/select.h$", "<sys/select.h>"}, {"sys/select.h", "<sys/select.h>"},
{"sys/sem.h$", "<sys/sem.h>"}, {"sys/sem.h", "<sys/sem.h>"},
{"sys/sendfile.h$", "<sys/sendfile.h>"}, {"sys/sendfile.h", "<sys/sendfile.h>"},
{"sys/shm.h$", "<sys/shm.h>"}, {"sys/shm.h", "<sys/shm.h>"},
{"sys/signalfd.h$", "<sys/signalfd.h>"}, {"sys/signalfd.h", "<sys/signalfd.h>"},
{"sys/socket.h$", "<sys/socket.h>"}, {"sys/socket.h", "<sys/socket.h>"},
{"sys/stat.h$", "<sys/stat.h>"}, {"sys/stat.h", "<sys/stat.h>"},
{"sys/statfs.h$", "<sys/statfs.h>"}, {"sys/statfs.h", "<sys/statfs.h>"},
{"sys/statvfs.h$", "<sys/statvfs.h>"}, {"sys/statvfs.h", "<sys/statvfs.h>"},
{"sys/swap.h$", "<sys/swap.h>"}, {"sys/swap.h", "<sys/swap.h>"},
{"sys/syscall.h$", "<sys/syscall.h>"}, {"sys/syscall.h", "<sys/syscall.h>"},
{"sys/sysctl.h$", "<sys/sysctl.h>"}, {"sys/sysctl.h", "<sys/sysctl.h>"},
{"sys/sysinfo.h$", "<sys/sysinfo.h>"}, {"sys/sysinfo.h", "<sys/sysinfo.h>"},
{"sys/syslog.h$", "<sys/syslog.h>"}, {"sys/syslog.h", "<sys/syslog.h>"},
{"sys/sysmacros.h$", "<sys/sysmacros.h>"}, {"sys/sysmacros.h", "<sys/sysmacros.h>"},
{"sys/termios.h$", "<sys/termios.h>"}, {"sys/termios.h", "<sys/termios.h>"},
{"sys/time.h$", "<sys/select.h>"}, {"sys/time.h", "<sys/select.h>"},
{"sys/timeb.h$", "<sys/timeb.h>"}, {"sys/timeb.h", "<sys/timeb.h>"},
{"sys/timerfd.h$", "<sys/timerfd.h>"}, {"sys/timerfd.h", "<sys/timerfd.h>"},
{"sys/times.h$", "<sys/times.h>"}, {"sys/times.h", "<sys/times.h>"},
{"sys/timex.h$", "<sys/timex.h>"}, {"sys/timex.h", "<sys/timex.h>"},
{"sys/ttychars.h$", "<sys/ttychars.h>"}, {"sys/ttychars.h", "<sys/ttychars.h>"},
{"sys/ttydefaults.h$", "<sys/ttydefaults.h>"}, {"sys/ttydefaults.h", "<sys/ttydefaults.h>"},
{"sys/types.h$", "<sys/types.h>"}, {"sys/types.h", "<sys/types.h>"},
{"sys/ucontext.h$", "<sys/ucontext.h>"}, {"sys/ucontext.h", "<sys/ucontext.h>"},
{"sys/uio.h$", "<sys/uio.h>"}, {"sys/uio.h", "<sys/uio.h>"},
{"sys/un.h$", "<sys/un.h>"}, {"sys/un.h", "<sys/un.h>"},
{"sys/user.h$", "<sys/user.h>"}, {"sys/user.h", "<sys/user.h>"},
{"sys/ustat.h$", "<sys/ustat.h>"}, {"sys/ustat.h", "<sys/ustat.h>"},
{"sys/utsname.h$", "<sys/utsname.h>"}, {"sys/utsname.h", "<sys/utsname.h>"},
{"sys/vlimit.h$", "<sys/vlimit.h>"}, {"sys/vlimit.h", "<sys/vlimit.h>"},
{"sys/vm86.h$", "<sys/vm86.h>"}, {"sys/vm86.h", "<sys/vm86.h>"},
{"sys/vtimes.h$", "<sys/vtimes.h>"}, {"sys/vtimes.h", "<sys/vtimes.h>"},
{"sys/wait.h$", "<sys/wait.h>"}, {"sys/wait.h", "<sys/wait.h>"},
{"sys/xattr.h$", "<sys/xattr.h>"}, {"sys/xattr.h", "<sys/xattr.h>"},
{"bits/epoll.h$", "<sys/epoll.h>"}, {"bits/epoll.h", "<sys/epoll.h>"},
{"bits/eventfd.h$", "<sys/eventfd.h>"}, {"bits/eventfd.h", "<sys/eventfd.h>"},
{"bits/inotify.h$", "<sys/inotify.h>"}, {"bits/inotify.h", "<sys/inotify.h>"},
{"bits/ipc.h$", "<sys/ipc.h>"}, {"bits/ipc.h", "<sys/ipc.h>"},
{"bits/ipctypes.h$", "<sys/ipc.h>"}, {"bits/ipctypes.h", "<sys/ipc.h>"},
{"bits/mman-linux.h$", "<sys/mman.h>"}, {"bits/mman-linux.h", "<sys/mman.h>"},
{"bits/mman.h$", "<sys/mman.h>"}, {"bits/mman.h", "<sys/mman.h>"},
{"bits/msq.h$", "<sys/msg.h>"}, {"bits/msq.h", "<sys/msg.h>"},
{"bits/resource.h$", "<sys/resource.h>"}, {"bits/resource.h", "<sys/resource.h>"},
{"bits/sem.h$", "<sys/sem.h>"}, {"bits/sem.h", "<sys/sem.h>"},
{"bits/shm.h$", "<sys/shm.h>"}, {"bits/shm.h", "<sys/shm.h>"},
{"bits/signalfd.h$", "<sys/signalfd.h>"}, {"bits/signalfd.h", "<sys/signalfd.h>"},
{"bits/statfs.h$", "<sys/statfs.h>"}, {"bits/statfs.h", "<sys/statfs.h>"},
{"bits/statvfs.h$", "<sys/statvfs.h>"}, {"bits/statvfs.h", "<sys/statvfs.h>"},
{"bits/timerfd.h$", "<sys/timerfd.h>"}, {"bits/timerfd.h", "<sys/timerfd.h>"},
{"bits/utsname.h$", "<sys/utsname.h>"}, {"bits/utsname.h", "<sys/utsname.h>"},
{"bits/auxv.h$", "<sys/auxv.h>"}, {"bits/auxv.h", "<sys/auxv.h>"},
{"bits/byteswap-16.h$", "<byteswap.h>"}, {"bits/byteswap-16.h", "<byteswap.h>"},
{"bits/byteswap.h$", "<byteswap.h>"}, {"bits/byteswap.h", "<byteswap.h>"},
{"bits/confname.h$", "<unistd.h>"}, {"bits/confname.h", "<unistd.h>"},
{"bits/dirent.h$", "<dirent.h>"}, {"bits/dirent.h", "<dirent.h>"},
{"bits/dlfcn.h$", "<dlfcn.h>"}, {"bits/dlfcn.h", "<dlfcn.h>"},
{"bits/elfclass.h$", "<link.h>"}, {"bits/elfclass.h", "<link.h>"},
{"bits/endian.h$", "<endian.h>"}, {"bits/endian.h", "<endian.h>"},
{"bits/environments.h$", "<unistd.h>"}, {"bits/environments.h", "<unistd.h>"},
{"bits/fcntl-linux.h$", "<fcntl.h>"}, {"bits/fcntl-linux.h", "<fcntl.h>"},
{"bits/fcntl.h$", "<fcntl.h>"}, {"bits/fcntl.h", "<fcntl.h>"},
{"bits/in.h$", "<netinet/in.h>"}, {"bits/in.h", "<netinet/in.h>"},
{"bits/ioctl-types.h$", "<sys/ioctl.h>"}, {"bits/ioctl-types.h", "<sys/ioctl.h>"},
{"bits/ioctls.h$", "<sys/ioctl.h>"}, {"bits/ioctls.h", "<sys/ioctl.h>"},
{"bits/link.h$", "<link.h>"}, {"bits/link.h", "<link.h>"},
{"bits/mqueue.h$", "<mqueue.h>"}, {"bits/mqueue.h", "<mqueue.h>"},
{"bits/netdb.h$", "<netdb.h>"}, {"bits/netdb.h", "<netdb.h>"},
{"bits/param.h$", "<sys/param.h>"}, {"bits/param.h", "<sys/param.h>"},
{"bits/poll.h$", "<sys/poll.h>"}, {"bits/poll.h", "<sys/poll.h>"},
{"bits/posix_opt.h$", "<bits/posix_opt.h>"}, {"bits/posix_opt.h", "<bits/posix_opt.h>"},
{"bits/pthreadtypes.h$", "<pthread.h>"}, {"bits/pthreadtypes.h", "<pthread.h>"},
{"bits/sched.h$", "<sched.h>"}, {"bits/sched.h", "<sched.h>"},
{"bits/select.h$", "<sys/select.h>"}, {"bits/select.h", "<sys/select.h>"},
{"bits/semaphore.h$", "<semaphore.h>"}, {"bits/semaphore.h", "<semaphore.h>"},
{"bits/sigthread.h$", "<pthread.h>"}, {"bits/sigthread.h", "<pthread.h>"},
{"bits/sockaddr.h$", "<sys/socket.h>"}, {"bits/sockaddr.h", "<sys/socket.h>"},
{"bits/socket.h$", "<sys/socket.h>"}, {"bits/socket.h", "<sys/socket.h>"},
{"bits/socket_type.h$", "<sys/socket.h>"}, {"bits/socket_type.h", "<sys/socket.h>"},
{"bits/stab.def$", "<stab.h>"}, {"bits/stab.def", "<stab.h>"},
{"bits/stat.h$", "<sys/stat.h>"}, {"bits/stat.h", "<sys/stat.h>"},
{"bits/stropts.h$", "<stropts.h>"}, {"bits/stropts.h", "<stropts.h>"},
{"bits/syscall.h$", "<sys/syscall.h>"}, {"bits/syscall.h", "<sys/syscall.h>"},
{"bits/syslog-path.h$", "<sys/syslog.h>"}, {"bits/syslog-path.h", "<sys/syslog.h>"},
{"bits/termios.h$", "<termios.h>"}, {"bits/termios.h", "<termios.h>"},
{"bits/types.h$", "<sys/types.h>"}, {"bits/types.h", "<sys/types.h>"},
{"bits/typesizes.h$", "<sys/types.h>"}, {"bits/typesizes.h", "<sys/types.h>"},
{"bits/uio.h$", "<sys/uio.h>"}, {"bits/uio.h", "<sys/uio.h>"},
{"bits/ustat.h$", "<sys/ustat.h>"}, {"bits/ustat.h", "<sys/ustat.h>"},
{"bits/utmp.h$", "<utmp.h>"}, {"bits/utmp.h", "<utmp.h>"},
{"bits/utmpx.h$", "<utmpx.h>"}, {"bits/utmpx.h", "<utmpx.h>"},
{"bits/waitflags.h$", "<sys/wait.h>"}, {"bits/waitflags.h", "<sys/wait.h>"},
{"bits/waitstatus.h$", "<sys/wait.h>"}, {"bits/waitstatus.h", "<sys/wait.h>"},
{"bits/xtitypes.h$", "<stropts.h>"}, {"bits/xtitypes.h", "<stropts.h>"},
}; };
for (const auto &Pair : SystemHeaderMap) for (const auto &Pair : SystemHeaderMap)
Includes->addRegexMapping(Pair.first, Pair.second); Includes->addPathSuffixMapping(Pair.first, Pair.second);
} }
} // namespace clangd } // namespace clangd
} // namespace clang } // namespace clang