    #pragma once

    #include <cassert>
    #include <assert.h>
    #include "assert.h"
    #include "assert.hpp" // abc
    #include "path/assert.hpp"
    #include "assert.h"a
    #include "assert.h" a
    #include <cassert>a
    #include <cassert> a
    #include FOO() error
    #include_next <cassert> a
    #include_next <cassert> /* a
     */ b
    #include PATH_IN_MACRO
    #include PATH_IN_MACRO()
    #include PATH_IN_MACRO(a, b)

    #define SOME_VAR 1
    #ifdef SOME_VAR

    #define MULTILINE_MACRO one \
    two \
    three

    # define MULTILINE_MACRO_TEXT                        \
        /* NOTE The contents of macro is too green :D */ \
        char const s[] = "a\\b"                          \
        "c\nd"

    # define VARIADIC(a, ...)          \
        f(a##a)                        \
        f(__VA_ARGS__)                 \
        f(#__VA_ARGS__)                \
        f(__VA_ARGS__)                 \
        f(0 __VA_OPT__(,) __VA_ARGS__) \
        x __VA_OPT__(= { __VA_ARGS__ })

    # define MACRO() BAD \ ESCAPED

    # error dds
    # warning dds
    # line 2 "file.cpp"
    # define A(x, y) x##y x#y
    // OK(L, a) -> L"a"
    # define OK(x, y) x###y
    # define BAD(x, y) x####y
    # define A /* multi line
    with comment */ expr
    # define A /* multi line
    with comment */
    23
    #else // x
    #42 // gcc extension = #line 42

    // error
    #wrong
    # wrong
    #endif x
    #if DS()
    #else x
    #else /* */x
    #else /* x
    y */ z
    #endif

    // check that _XXX defines work, bug 397766
    #ifndef _HEADER_GUARD
    #define _HEADER_GUARD 1
    #endif
    #ifdef _HEADER_GUARD
    #if (_HEADER_GUARD >= 1)
    #endif
    #endif

    static int g_global;

    template<class T, typename U, template<class> class = std::is_pointer>
    struct class1
      : private std::vector<T>, public U
    {
        class1()
            try
            : _member1(xxx)
        {}
            catch(...)
        {}

        class1(class1&&) = default;

        ~class1()
        {}

        void foo() { return; }
        void foo() const { return; }
        void foo() noexcept { return; }
        void foo() const noexcept { return; }
        virtual void foo() const noexcept { return; }
        static void foo() { return; }
        constexpr static void foo() const
            noexcept(noexcept(std::is_pointer<U>::value)) override
        {
            xxx::template ttt<U>::type {};
            xxx.template get<U>();
            xxx.std::rdbuf();
            auto x = C<'a'> + y;
        }

        int operator->*(T (C::*m)(int));
        operator value_t ();

    private:
    protected:
    public:
        value_type _member1; // NOTE internal ?
        value_type __internal;
        value_type internal__;
        value_type _M_internal;
        value_t member2_;
        value_type m_member3;

        static int s_static;
        static constexpr int s_static;
        static inline int s_static;
        static inline constexpr int s_static;
    };

    constexpr struct : xyz
    {
        using xyz::xyz;
        using xyz::operator=;

        int a : 1;
        int b : 7;
    } x {};

    template<class T>
    using is_pointer = std::is_pointer<T>::type;

    template<class T>
    constexpr auto is_pointer_v = std::is_pointer<T>::value;

    uint64_t namespaces()
    {
        std::vector<T>;
        boost::vector<T>;
        detail::vector<T>;
        details::vector<T>;
        aux::vector<T>;
        internals::vector<T>;
        other::vector<T>;
    }

    #if 1
        double foo(const A);
    #else // else
        double foo(const A);
    #endif // end

    #if 0
        double foo(const A);
    #else // else
        double foo(const A);
    #endif // end

    #if 1
        double foo(const A);
    #elif 1
        double foo(const A);
    #elif 0
        double foo(const A);
    #endif // end

    #if 0
        double foo(const A);
    #elif 1
        double foo(const A);
    #elif 0
        double foo(const A);
    #endif // end

    #if 0
        double foo(const A);
    #elif a
        double foo(const A);
    #elif 0
        double foo(const A);
    #elif a
        double foo(const A);
    #else // else
        double foo(const A);
    #endif // end

    #if 0 // blah blah
        double foo(const A);
    #elif 1 // blah blah
        double foo(const A);
    #else // else
        double foo(const A);
    #endif // end

    #if 0 || a
        double foo(const A);
    #else // else
        double foo(const A);
    #endif // end

    #if 1 || a
        double foo(const A);
    #else // else
        double foo(const A);
    #endif // end

    #if 0 && a
        double foo(const A);
    #else // else
        double foo(const A);
    #endif // end

    #if 1 && a
        double foo(const A);
    #else // else
        double foo(const A);
    #endif // end

    #if a
        double foo(const A);
    #elif 0
        double foo(const A);
    #endif // end

    #if a
        double foo(const A);
    #elif 1
        double foo(const A);
    #endif // end

    #if a
        double foo(const A);
    #elif a
        double foo(const A);
    #endif // end

    int bar(void*p, void * pp)
    {
    # if 0
        double foo();
    # else // else
        double foo();
    # endif // end
    }

    #if abc 0
        double foo();
    #endif // end

    #if xxx
        double foo();
    #else
        double foo();
    #endif // end

    #if xxx
        double foo();
    #elif xxx // elseif
        double foo();
    #elif xxx // elseif
        double foo();
    #endif // end

    // error
    #
    #d
    # d
    #if
    #elif
    #endif
    #ifndef
    #endif
    #ifdef 0
    #endif // end

    static uint64_t intWithSuffix = 42ull;
    static long intWithSuffixAndPrefix = 0b0101L;
    static int octNum = 07232;
    static int invalidOctNum = 09231;
    static uint64_t hexNum = 0xDEADBEEF42;
    static uint64_t invalidHexNum = 0xGLDFKG;
    static char binNum = 0b0101010;

    static int64_t intWithSuffix = -42LL;
    static long intWithSuffixAndPrefix = -0b0101L;
    static int octNum = -07232;
    static int invalidOctNum = -09231;
    static int64_t hexNum = -0xDEADBEEF42;
    static int64_t invalidHexNum = -0xGLDFKG;
    static char binNum = -0b0101010;

    static uint64_t intWithSuffixWithSep = 4'2ull;
    static long intWithSuffixAndPrefixWithSep = 0b0'10'1L;
    static int octNumWithSep = 07'232;
    static int invalidOctNumWithSep = 09'23'1;
    static uint64_t hexNumWithSep = 0xD'EAD'BE'EF'42;
    static uint64_t invalidHexNumWithSep = 0xGLD'FKG;
    static char binNumWithSep = 0b0'1010'10;

    static uint64_t invalidSep = 42'ull;
    static uint64_t invalidSep = 42';

    static double d1 = 42.;
    static double d2 = .42;
    static double d2a = -0.49;
    static double d2b = -0.09;
    static double d3 = 42.3e1;
    static double d4 = .2e-12;
    static double d5 = 32.e+12;
    static double invalidD1 = 32.e+a12;
    static float floatQualifier = 23.123f;
    // Hexadecimal floating point (c++17)
    static double d6 = 0x1ffp10;
    static double d7 = 0X0p-1;
    static double d8 = 0x1.p0;
    static double d9 = 0xf.p-1L;
    static double d10 = 0x0.123p-1;
    static double d11 = 0xa.bp10l;
    static double invalidD2 = 0x0.123p-a;
    static float floatQualifier = 0xf.p-1f;

    60min; // c++17
    60.min;
    60.3min;
    0x1ffp10min;
    2d; // c++20
    23._f
    23._fd
    2.3_f
    2.3_fd
    2._f
    2._fd
    2e4_f
    2e4_fd

    // error
    23.fd
    2e_fd
    2e
    1.y
    1.0_E+2.0
    1.0_E +2.0 // ok
    1_p+2
    1_p +2 // ok
    4s.count()
    4s. count()
    4s .count() // ok

    static bool yes = true;
    static bool no = false;

    // *char*
    static const char     c1 = 'c';
    static const char     c1a = u8'c'; // utf-8 char (c++17)
    static const char16_t c1b = u'c';
    static const char32_t c1c = U'c';
    static const wchar_t  c1d = L'c';
    static const char c2 = '\n';
    static const char c2a = '\120'; // octal
    static const char c2b = '\x1f'; // hex
    static const char c2c = '\'';
    static const char c2d = '\\';
    static const wchar_t c2e = L'\x1ff'; // hex
    static const wchar_t c2e = U'\x1fffffff'; // hex
    // error
    '\x123';
    '\u1234';
    '\U12345678';
    U'\u12345';
    u'\u123';
    U'\U1234567';
    U'\U123456789';
    U'\x123456789';

    // string
    static const char* c3 = "string";
    static const char* c4 = "\"string\n\t\012\x12\"";
    static const char* c5 = "multiline \
        string";
    static const char* c6 = "multifragment" "other""string";
    static const char*      c6a = u8"string";
    static const char16_t*  c6b = u"string";
    static const char32_t*  c6c = U"string";
    static const wchar_t*   c6d = L"string";
    static const char* rawString1 = R"(string)";
    static const char*      rawString1a = u8R"(string)";
    static const char16_t*  rawString1b = uR"(string)";
    static const char32_t*  rawString1c = UR"(string)";
    static const wchar_t*   rawString1d = LR"(string\nstring)";
    static const char* rawString2 = R"ab(string\nstring)ab";
    static const char* rawString3 = R"ab(string
    string)ab";
    " %d %df fd" U"ds %d" R"(a%d)";
      "\x123xsk";
     u"\x123xsk";
    // error
    u8"\x123xsk";

    // UDL (c++11)

    operator""_a(const char*);
    operator ""_a(const char*);
    operator "" _a(const char*);
    // invalid suffix
    operator "" a(const char*);
    operator ""a(const char*);
    operator""a(const char*);

    "string"_s; // user
    "string"s; // standard
    "string"_s-b; // -b is not part of the string

    // Macro

    MY_XXX;
    BOOST_XXX;
    __STDC_VERSION__;
    __TIME__;
    __cplusplus;

    // Attributes

    [[noreturn]] void foo();
    [[deprecated]] void foo();
    [[deprecated("because")]] void foo();
    void foo([[carries_dependency]] int);

    [[opt(1), debug]]
    [[using CC: opt(1), debug]] // c++17
    [[using CC: CC::opt(1)]] // c++17

    [[gnu::assume_aligned(3'2l,2)]] void* f();
    [[using gnu: assume_aligned(3)]]
    [[clang::assume_aligned(3)]]

    void f([[maybe_unused]] int val)
    {
        [[maybe_unused]] int x;
        switch (x = foo(); x) {
            case 1:
                [[fallthrough]];
            case XXX:
            case Class::foo():
                [[fallthrough]];
            default:
                ;
        }

        // c++17: fold expression
        (args + ... + (1 * 2));
        (v.push_back(args), ...);

        [[omp::parallel]] for (auto&& x : v)
            x;
        for (auto&& [first,second] : mymap) {
        }

        auto [x, y] = foo();

        [x = 1, =y](){};

        decltype((auto)) x = foo();
    }

    auto f() -> decltype(foo());

    __attribute__((pure)) void f();

    label:
    goto label;

    //BEGIN region
    // TODO comment FIXME comment ### comment BUG comment
    //END region

    // \brief blah blah
    /// \brief blah blah

    /**
     * Doxygen
     * @param p1 text
     * \brief <b>bold text</b>
     * \dot
     * a -> b
     * \enddot
     *
     * \verbatim
     * <dummy>
     * \endverbatim
     * <html>text</html>
     */

    #endif

    // Some GNU macros, cross-referenced from gcc.xml to isocpp.xml
    __GCC_ATOMIC_CHAR16_T_LOCK_FREE
    __GNUC__
    __linux__

    // Digraphs (see bug #411508)
    %:include <stdio.h>
    int main()
    <%
        [](){%>();
    }
    <:<:fallthrough]]