{
    "scope": "(source.c++ | source.objc++) & (meta.preprocessor.include string.quoted.other)",

    // Taken from http://en.cppreference.com/w/cpp/header
    // Update as needed.
    "completions":
    [
        // Utilities library
        {
            // General purpose utilities: program control, dynamic memory allocation, random numbers, sort and search
            "trigger": "cstdlib",
            "contents": "cstdlib",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Functions and macro constants for signal management
            "trigger": "csignal",
            "contents": "csignal",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Macro (and function) that saves (and jumps) to an execution context
            "trigger": "csetjmp",
            "contents": "csetjmp",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Handling of variable length argument lists
            "trigger": "cstdarg",
            "contents": "cstdarg",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Runtime type information utilities
            "trigger": "typeinfo",
            "contents": "typeinfo",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) std::type_index
            "trigger": "typeindex",
            "details": "Added in C++11",
            "contents": "typeindex",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) Compile-time type information
            "trigger": "type_traits",
            "details": "Added in C++11",
            "contents": "type_traits",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // std::bitset class template
            "trigger": "bitset",
            "contents": "bitset",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Function objects, designed for use with the standard algorithms
            "trigger": "functional",
            "contents": "functional",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Various utility components
            "trigger": "utility",
            "contents": "utility",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // C-style time/date utilites
            "trigger": "ctime",
            "contents": "ctime",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) C++ time utilities
            "trigger": "chrono",
            "details": "Added in C++11",
            "contents": "chrono",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // typedefs for types such as size_t, NULL and others
            "trigger": "cstddef",
            "contents": "cstddef",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) std::initializer_list class template
            "trigger": "initializer_list",
            "details": "Added in C++11",
            "contents": "initializer_list",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) std::tuple class template
            "trigger": "tuple",
            "details": "Added in C++11",
            "contents": "tuple",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++17) std::any class template
            "trigger": "any",
            "details": "Added in C++17",
            "contents": "any",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++17) std::optional class template
            "trigger": "optional",
            "details": "Added in C++17",
            "contents": "optional",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++17) std::variant class template
            "trigger": "variant",
            "details": "Added in C++17",
            "contents": "variant",
            "kind": ["namespace", "h", "Header"]
        },

        // Dynmamic memory management utilities
        {
            // Low-level memory management utilities
            "trigger": "new",
            "contents": "new",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Higher level memory management utilities
            "trigger": "memory",
            "contents": "memory",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) Nested allocator class
            "trigger": "scoped_allocator",
            "details": "Added in C++11",
            "contents": "scoped_allocator",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++17) Polymorphic allocators and memory resources
            "trigger": "memory_resource",
            "details": "Added in C++17",
            "contents": "memory_resource",
            "kind": ["namespace", "h", "Header"]
        },

        // Numeric limits
        {
            // limits of integral types
            "trigger": "climits",
            "contents": "climits",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // limits of float types
            "trigger": "cfloat",
            "contents": "cfloat",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) fixed-size types and limits of other types
            "trigger": "cstdint",
            "details": "Added in C++11",
            "contents": "cstdint",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) formatting macros , intmax_t and uintmax_t math and conversions
            "trigger": "cinttypes",
            "details": "Added in C++11",
            "contents": "cinttypes",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // standardized way to query properties of arithmetic types
            "trigger": "limits",
            "contents": "limits",
            "kind": ["namespace", "h", "Header"]
        },

        // Error handling
        {
            // Exception handling utilities
            "trigger": "exception",
            "contents": "exception",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard exception objects
            "trigger": "stdexcept",
            "contents": "stdexcept",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) defines std::error_code, a platform-dependent error code
            "trigger": "system_error",
            "details": "Added in C++11",
            "contents": "system_error",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Macro containing the last error number
            "trigger": "cerrno",
            "contents": "cerrno",
            "kind": ["namespace", "h", "Header"]
        },

        // String library
        {
            // functions to determine the type contained in character data
            "trigger": "cctype",
            "contents": "cctype",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // functions for determining the type of wide character data
            "trigger": "cwctype",
            "contents": "cwctype",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // various narrow character string handling functions
            "trigger": "cstring",
            "contents": "cstring",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // various wide and multibyte string handling functions
            "trigger": "cwchar",
            "contents": "cwchar",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) C-style Unicode character conversion functions
            "trigger": "cuchar",
            "details": "Added in C++11",
            "contents": "cuchar",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // std::basic_string class template
            "trigger": "string",
            "contents": "string",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++17) std::basic_string_view class template
            "trigger": "string_view",
            "details": "Added in C++11",
            "contents": "string_view",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++20) std::to_chars and std::from_chars
            "trigger": "charconv",
            "details": "Added in c++20",
            "contents": "charconv",
            "kind": ["namespace", "h", "Header"]
        },

        // Containers library
        {
            // (since C++11) std::array container
            "trigger": "array",
            "details": "Added in C++11",
            "contents": "array",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // std::vector container
            "trigger": "vector",
            "contents": "vector",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // std::deque container
            "trigger": "deque",
            "contents": "deque",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // std::list container
            "trigger": "list",
            "contents": "list",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) std::forward_list container
            "trigger": "forward_list",
            "details": "Added in C++11",
            "contents": "forward_list",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // std::set and std::multiset associative containers
            "trigger": "set",
            "contents": "set",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // std::map and std::multimap associative containers
            "trigger": "map",
            "contents": "map",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) std::unordered_set and std::unordered_multiset unordered associative containers
            "trigger": "unordered_set",
            "details": "Added in C++11",
            "contents": "unordered_set",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11)   std::unordered_map and std::unordered_multimap unordered associative containers
            "trigger": "unordered_map",
            "details": "Added in C++11",
            "contents": "unordered_map",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // std::stack container adaptor
            "trigger": "stack",
            "contents": "stack",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // std::queue and std::priority_queue container adaptors
            "trigger": "queue",
            "contents": "queue",
            "kind": ["namespace", "h", "Header"]
        },

        // Algorithms library
        {
            // Algorithms that operate on containers
            "trigger": "algorithm",
            "contents": "algorithm",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (C++17) Predefined execution policies for parallel versions of the algorithms
            "trigger": "execution",
            "details": "Added in C++17",
            "contents": "execution",
            "kind": ["namespace", "h", "Header"]
        },

        // Iterators library
        {
            // Container iterators
            "trigger": "iterator",
            "contents": "iterator",
            "kind": ["namespace", "h", "Header"]
        },

        // Numerics library
        {
            // Common mathematics functions
            "trigger": "cmath",
            "contents": "cmath",
            "kind": ["namespace", "h", "Header"]
        }, 
        {
            // Complex number type
            "trigger": "complex",
            "contents": "complex",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Class for representing and manipulating arrays of values
            "trigger": "valarray",
            "contents": "valarray",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) Random number generators and distributions
            "trigger": "random",
            "details": "Added in C++11",
            "contents": "random",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Numeric operations on values in containers
            "trigger": "numeric",
            "contents": "numeric",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) Compile-time rational arithmetic
            "trigger": "ratio",
            "details": "Added in C++11",
            "contents": "ratio",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) Floating-point environment access functions
            "trigger": "cfenv",
            "details": "Added in C++11",
            "contents": "cfenv",
            "kind": ["namespace", "h", "Header"]
        },

        // Input/output library
        {
            // forward declarations of all classes in the input/output library
            "trigger": "iosfwd",
            "contents": "iosfwd",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // std::ios_base class, std::basic_ios class template and several typedefs
            "trigger": "ios",
            "contents": "ios",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // std::basic_istream class template and several typedefs
            "trigger": "istream",
            "contents": "istream",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // std::basic_ostream, std::basic_iostream class templates and several typedefs
            "trigger": "ostream",
            "contents": "ostream",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // several standard stream objects
            "trigger": "iostream",
            "contents": "iostream",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // std::basic_fstream, std::basic_ifstream, std::basic_ofstream class templates and several typedefs
            "trigger": "fstream",
            "contents": "fstream",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // std::basic_stringstream, std::basic_istringstream, std::basic_ostringstream class templates and several typedefs
            "trigger": "sstream",
            "contents": "sstream",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Helper functions to control the format or input and output
            "trigger": "iomanip",
            "contents": "iomanip",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // std::basic_streambuf class template
            "trigger": "streambuf",
            "contents": "streambuf",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // C-style input-output functions
            "trigger": "cstdio",
            "contents": "cstdio",
            "kind": ["namespace", "h", "Header"]
        },

        // Localization library
        {
            // Localization utilities
            "trigger": "locale",
            "contents": "locale",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // C localization utilities
            "trigger": "clocale",
            "contents": "clocale",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) Unicode conversion facilities
            "trigger": "codecvt",
            "details": "Added in C++11",
            "contents": "codecvt",
            "kind": ["namespace", "h", "Header"]
        },

        // Regular Expressions library
        {
            // (since C++11) Classes, algorithms and iterators to support regular expression processing
            "trigger": "regex",
            "details": "Added in C++11",
            "contents": "regex",
            "kind": ["namespace", "h", "Header"]
        },

        // Atomic Operations library
        {
            // (since C++11) Atomic operations library
            "trigger": "atomic",
            "details": "Added in C++11",
            "contents": "atomic",
            "kind": ["namespace", "h", "Header"]
        },

        // Thread support library
        {
            // (since C++11) std::thread class and supporting functions
            "trigger": "thread",
            "details": "Added in C++11",
            "contents": "thread",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) mutual exclusion primitives
            "trigger": "mutex",
            "details": "Added in C++11",
            "contents": "mutex",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++14) shared mutual exclusion primitives
            "trigger": "shared_mutex",
            "details": "Added in C++14",
            "contents": "shared_mutex",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) primitives for asynchronous computations
            "trigger": "future",
            "details": "Added in C++11",
            "contents": "future",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // (since C++11) thread waiting conditions
            "trigger": "condition_variable",
            "details": "Added in C++11",
            "contents": "condition_variable",
            "kind": ["namespace", "h", "Header"]
        },

        // Filesystem library
        {
            // (since C++17) std::path class and supporting functions
            "trigger": "filesystem",
            "details": "Added in C++17",
            "contents": "filesystem",
            "kind": ["namespace", "h", "Header"]
        },

        // Experimental libraries
        {
            // Standard libraries extensions and Extensions for Parallelism
            "trigger": "experimental/algorithm",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/algorithm",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard libraries extensions
            "trigger": "experimental/any",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/any",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard libraries extensions
            "trigger": "experimental/chrono",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/chrono",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard libraries extensions
            "trigger": "experimental/deque",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/deque",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Extensions for Parallelism
            "trigger": "experimental/execution_policy",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/execution_policy",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Extensions for Parallelism
            "trigger": "experimental/exception_list",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/exception_list",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Filesystem library
            "trigger": "experimental/filesystem",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/filesystem",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard libraries extensions
            "trigger": "experimental/forward_list",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/forward_list",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard libraries extensions
            "trigger": "experimental/future",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/future",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard libraries extensions
            "trigger": "experimental/list",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/list",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard libraries extensions
            "trigger": "experimental/functional",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/functional",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //  Standard libraries extensions
            "trigger": "experimental/map",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/map",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard libraries extensions
            "trigger": "experimental/memory",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/memory",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //  Standard libraries extensions
            "trigger": "experimental/memory_resource",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/memory_resource",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Extensions for Parallelism
            "trigger": "experimental/numeric",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/numeric",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard libraries extensions
            "trigger": "experimental/optional",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/optional",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //  Standard libraries extensions
            "trigger": "experimental/ratio",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/ratio",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //  Standard libraries extensions
            "trigger": "experimental/regex",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/regex",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //  Standard libraries extensions
            "trigger": "experimental/set",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/set",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard libraries extensions
            "trigger": "experimental/string",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/string",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //  Standard libraries extensions
            "trigger": "experimental/string_view",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/string_view",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard libraries extensions
            "trigger": "experimental/system_error",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/system_error",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard libraries extensions
            "trigger": "experimental/tuple",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/tuple",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //  Standard libraries extensions
            "trigger": "experimental/type_traits",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/type_traits",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard libraries extensions
            "trigger": "experimental/unordered_map",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/unordered_map",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard libraries extensions
            "trigger": "experimental/unordered_set",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/unordered_set",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //  Standard libraries extensions
            "trigger": "experimental/utility",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/utility",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // Standard libraries extensions
            "trigger": "experimental/vector",
            "annotation": "library fundamentals",
            "details": "From (draft) C++ Library Fundamentals TS",
            "contents": "experimental/vector",
            "kind": ["namespace", "h", "Header"]
        },

        // C compatibility headers
        //
        // For some of the C standard library headers of
        // the form xxx.h, the C++ standard library both includes an
        // identically-named header and another header of the form cxxx (all
        // meaningful cxxx headers are listed above). With the exception of
        // complex.h , each xxx.h header included in the C++ standard library
        // places in the global namespace each name that the corresponding cxxx
        // header would have placed in the std namespace. These headers are
        // allowed to also declare the same names in the std namespace, and the
        // corresponding cxxx headers are allowed to also declare the same names
        // in the global namespace: including <cstdlib> definitely provides
        // std::malloc and may also provide ::malloc. Including <stdlib.h>
        // definitely provides ::malloc and may also provide std::malloc. This
        // applies even to functions and function overloads that are not part of
        // C standard library.
        {
            // behaves as if each name from <cassert> is placed in global namespace
            "trigger": "assert.h",
            "details": "Deprecated C header name",
            "contents": "assert.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //  behaves as if each name from <cctype> is placed in global namespace
            "trigger": "ctype.h",
            "details": "Deprecated C header name",
            "contents": "ctype.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //  behaves as if each name from <cerrno> is placed in global namespace
            "trigger": "errno.h",
            "details": "Deprecated C header name",
            "contents": "errno.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //   behaves as if each name from <cfenv> is placed in global namespace
            "trigger": "fenv.h",
            "details": "Deprecated C header name",
            "contents": "fenv.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //  behaves as if each name from <cfloat> is placed in global namespace
            "trigger": "float.h",
            "details": "Deprecated C header name",
            "contents": "float.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //   behaves as if each name from <cinttypes> is placed in global namespace
            "trigger": "inttypes.h",
            "details": "Deprecated C header name",
            "contents": "inttypes.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // behaves as if each name from <climits> is placed in global namespace
            "trigger": "limits.h",
            "details": "Deprecated C header name",
            "contents": "limits.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // behaves as if each name from <clocale> is placed in global namespace
            "trigger": "locale.h",
            "details": "Deprecated C header name",
            "contents": "locale.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //   behaves as if each name from <cmath> is placed in global namespace
            "trigger": "math.h",
            "details": "Deprecated C header name",
            "contents": "math.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // behaves as if each name from <csetjmp> is placed in global namespace
            "trigger": "setjmp.h",
            "details": "Deprecated C header name",
            "contents": "setjmp.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // behaves as if each name from <csignal> is placed in global namespace
            "trigger": "signal.h",
            "details": "Deprecated C header name",
            "contents": "signal.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // behaves as if each name from <cstdarg> is placed in global namespace
            "trigger": "stdarg.h",
            "details": "Deprecated C header name",
            "contents": "stdarg.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // behaves as if each name from <cstddef> is placed in global namespace
            "trigger": "stddef.h",
            "details": "Deprecated C header name",
            "contents": "stddef.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // behaves as if each name from <cstdint> is placed in global namespace
            "trigger": "stdint.h",
            "details": "Deprecated C header name",
            "contents": "stdint.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //  behaves as if each name from <cstdio> is placed in global namespace
            "trigger": "stdio.h",
            "details": "Deprecated C header name",
            "contents": "stdio.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // behaves as if each name from <cstdlib> is placed in global namespace
            "trigger": "stdlib.h",
            "details": "Deprecated C header name",
            "contents": "stdlib.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // behaves as if each name from <cstring> is placed in global namespace
            "trigger": "string.h",
            "details": "Deprecated C header name",
            "contents": "string.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //   behaves as if each name from <ctime> is placed in global namespace
            "trigger": "time.h",
            "details": "Deprecated C header name",
            "contents": "time.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //  behaves as if each name from <cuchar> is placed in global namespace
            "trigger": "uchar.h",
            "details": "Deprecated C header name",
            "contents": "uchar.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            //  behaves as if each name from <cwchar> is placed in global namespace
            "trigger": "wchar.h",
            "details": "Deprecated C header name",
            "contents": "wchar.h",
            "kind": ["namespace", "h", "Header"]
        },
        {
            // behaves as if each name from <cwctype> is placed in global namespace
            "trigger": "wctype.h",
            "details": "Deprecated C header name",
            "contents": "wctype.h",
            "kind": ["namespace", "h", "Header"]
        },

        // Unsupported C headers
        //
        // The C headers <stdatomic.h>, <stdnoreturn.h>,
        // and <threads.h> are not included in C++ and have no cxxx equivalents.

        // Empty C headers
        //
        // The headers <complex.h>, <ccomplex>, <tgmath.h>, and <ctgmath> do not
        // contain any content from the C standard library and instead merely
        // include other headers from the C++ standard library. The use of all
        // these headers is deprecated in C++.
        //
        // <ccomplex> (since C++11)(deprecated in C++17)   simply includes the header <complex>
        // <complex.h> (deprecated)    simply includes the header <complex>
        // <ctgmath> (since C++11)(deprecated in C++17)    simply includes the headers <complex> and <cmath>: the overloads equivalent to the contents of the C header tgmath.h are already provided by those headers
        // <tgmath.h> (deprecated) simply includes the header <ctgmath>

        // Meaningless C headers
        //
        // The headers <ciso646>, <cstdalign>, and <cstdbool> are meaningless in
        // C++ because the macros they provide in C are language keywords in
        // C++.
        //
        // <ciso646>   empty header. The macros that appear in iso646.h in C are keywords in C++
        // <iso646.h> (deprecated) behaves as if each name from <ciso646> is placed in global namespace
        // <cstdalign> (since C++11)(deprecated in C++17)  defines one compatibility macro constant
        // <stdalign.h> (deprecated)   behaves as if each name from <cstdalign> is placed in global namespace
        // <cstdbool> (since C++11)(deprecated in C++17)   defines one compatibility macro constant
        // <stdbool.h> (deprecated)    behaves as if each name from <cstdbool> is placed in global namespace

    ]
}