CLANG_TIDY_CONFIG = {
	groups = {
		{"abseil-*", "abseil-", [[Checks related to Abseil library.]]};
		{"altera-*", "altera-", [[Checks related to OpenCL programming for FPGAs.]]};
		{"android-*", "android-", [[Checks related to Android.]]};
		{"boost-*", "boost-", [[Checks related to Boost library.]]};
		{"bugprone-*", "bugprone-", [[Checks that target bug-prone code constructs.]]};
		{"cert-*", "cert-", [[Checks related to CERT Secure Coding Guidelines.]]};
		{"clang-analyzer-*", "clang-analyzer-", [[Clang Static Analyzer checks.]]};
		{"concurrency-*", "concurrency-", [[Checks related to concurrent programming (including threads, fibers, coroutines, etc.).]]};
		{"cppcoreguidelines-*", "cppcoreguidelines-", [[Checks related to C++ Core Guidelines.]]};
		{"darwin-*", "darwin-", [[Checks related to Darwin coding conventions.]]};
		{"fuchsia-*", "fuchsia-", [[Checks related to Fuchsia coding conventions.]]};
		{"google-*", "google-", [[Checks related to Google coding conventions.]]};
		{"hicpp-*", "hicpp-", [[Checks related to High Integrity C++ Coding Standard.]]};
		{"linuxkernel-*", "linuxkernel-", [[Checks related to the Linux Kernel coding conventions.]]};
		{"llvm-*", "llvm-", [[Checks related to the LLVM coding conventions.]]};
		{"llvmlibc-*", "llvmlibc-", [[Checks related to the LLVM-libc coding standards.]]};
		{"misc-*", "misc-", [[Checks that we didn't have a better category for.]]};
		{"modernize-*", "modernize-", [[Checks that advocate usage of modern (currently "modern" means "C++11") language constructs.]]};
		{"mpi-*", "mpi-", [[Checks related to MPI (Message Passing Interface).]]};
		{"objc-*", "objc-", [[Checks related to Objective-C coding conventions.]]};
		{"openmp-*", "openmp-", [[Checks related to OpenMP API.]]};
		{"performance-*", "performance-", [[Checks that target performance-related issues.]]};
		{"portability-*", "portability-", [[Checks that target portability-related issues that don't relate to any particular coding style.]]};
		{"readability-*", "readability-", [[Checks that target readability-related issues that don't relate to any particular coding style.]]};
		{"zircon-*", "zircon-", [[Checks related to Zircon kernel coding conventions.]]};
	};
	items = {
		{
			"abseil-cleanup-ctad";
			[[Suggests switching the initialization pattern of absl::Cleanup instances from the factory function to class template argument deduction (CTAD), in C++17 and higher.]];
		};
		{
			"abseil-duration-addition";
			[[Check for cases where addition should be performed in the absl::Time domain. When adding two values, and one is known to be an absl::Time, we can infer that the other should be interpreted as an absl::Duration of a similar scale, and make that inference explicit.]];
		};
		{
			"abseil-duration-comparison";
			[[Checks for comparisons which should be in the absl::Duration domain instead of the floating point or integer domains.]];
		};
		{
			"abseil-duration-conversion-cast";
			[[Checks for casts of absl::Duration conversion functions, and recommends the right conversion function instead.]];
		};
		{
			"abseil-duration-division";
			[[absl::Duration arithmetic works like it does with integers. That means that division of two absl::Duration objects returns an int64 with any fractional component truncated toward 0. See this link for more information on arithmetic with absl::Duration.]];
		};
		{
			"abseil-duration-factory-float";
			[[Checks for cases where the floating-point overloads of various absl::Duration factory functions are called when the more-efficient integer versions could be used instead.]];
		};
		{
			"abseil-duration-factory-scale";
			[[Checks for cases where arguments to absl::Duration factory functions are scaled internally and could be changed to a different factory function. This check also looks for arguments with a zero value and suggests using absl::ZeroDuration() instead.]];
		};
		{
			"abseil-duration-subtraction";
			[[Checks for cases where subtraction should be performed in the absl::Duration domain. When subtracting two values, and the first one is known to be a conversion from absl::Duration, we can infer that the second should also be interpreted as an absl::Duration, and make that inference explicit.]];
		};
		{
			"abseil-duration-unnecessary-conversion";
			[[Finds and fixes cases where absl::Duration values are being converted to numeric types and back again.]];
		};
		{
			"abseil-faster-strsplit-delimiter";
			[[Finds instances of absl::StrSplit() or absl::MaxSplits() where the delimiter is a single character string literal and replaces with a character. The check will offer a suggestion to change the string literal into a character. It will also catch code using absl::ByAnyChar() for just a single character and will transform that into a single character as well.]];
		};
		{
			"abseil-no-internal-dependencies";
			[[Warns if code using Abseil depends on internal details. If something is in a namespace that includes the word “internal”, code is not allowed to depend upon it because it’s an implementation detail. They cannot friend it, include it, you mention it or refer to it in any way. Doing so violates Abseil’s compatibility guidelines and may result in breakage. See https://abseil.io/about/compatibility for more information.]];
		};
		{
			"abseil-no-namespace";
			[[Ensures code does not open namespace absl as that violates Abseil’s compatibility guidelines. Code should not open namespace absl as that conflicts with Abseil’s compatibility guidelines and may result in breakage.]];
		};
		{
			"abseil-redundant-strcat-calls";
			[[Suggests removal of unnecessary calls to absl::StrCat when the result is being passed to another call to absl::StrCat or absl::StrAppend.]];
		};
		{
			"abseil-str-cat-append";
			[[Flags uses of absl::StrCat() to append to a std::string. Suggests absl::StrAppend() should be used instead.]];
		};
		{
			"abseil-string-find-startswith";
			[[Checks whether a std::string::find() or std::string::rfind() result is compared with 0, and suggests replacing with absl::StartsWith(). This is both a readability and performance issue.]];
		};
		{
			"abseil-string-find-str-contains";
			[[Finds s.find(...) == string::npos comparisons (for various string-like types) and suggests replacing with absl::StrContains().]];
		};
		{
			"abseil-time-comparison";
			[[Prefer comparisons in the absl::Time domain instead of the integer domain.]];
		};
		{
			"abseil-time-subtraction";
			[[Finds and fixes absl::Time subtraction expressions to do subtraction in the Time domain instead of the numeric domain.]];
		};
		{
			"abseil-upgrade-duration-conversions";
			[[Finds calls to absl::Duration arithmetic operators and factories whose argument needs an explicit cast to continue compiling after upcoming API changes.]];
		};
		{
			"altera-id-dependent-backward-branch";
			[[Finds ID-dependent variables and fields that are used within loops. This causes branches to occur inside the loops, and thus leads to performance degradation.]];
		};
		{
			"altera-kernel-name-restriction";
			[[Finds kernel files and include directives whose filename is kernel.cl, Verilog.cl, or VHDL.cl. The check is case insensitive.]];
		};
		{
			"altera-single-work-item-barrier";
			[[Finds OpenCL kernel functions that call a barrier function but do not call an ID function (get_local_id, get_local_id, get_group_id, or get_local_linear_id).]];
		};
		{
			"altera-struct-pack-align";
			[[Finds structs that are inefficiently packed or aligned, and recommends packing and/or aligning of said structs as needed.]];
		};
		{
			"altera-unroll-loops";
			[[Finds inner loops that have not been unrolled, as well as fully unrolled loops with unknown loop bounds or a large number of iterations.]];
		};
		{
			"android-cloexec-accept";
			[[The usage of accept() is not recommended, it’s better to use accept4(). Without this flag, an opened sensitive file descriptor would remain open across a fork+exec to a lower-privileged SELinux domain.]];
		};
		{
			"android-cloexec-accept4";
			[[accept4() should include SOCK_CLOEXEC in its type argument to avoid the file descriptor leakage. Without this flag, an opened sensitive file would remain open across a fork+exec to a lower-privileged SELinux domain.]];
		};
		{
			"android-cloexec-creat";
			[[The usage of creat() is not recommended, it’s better to use open().]];
		};
		{
			"android-cloexec-dup";
			[[The usage of dup() is not recommended, it’s better to use fcntl(), which can set the close-on-exec flag. Otherwise, an opened sensitive file would remain open across a fork+exec to a lower-privileged SELinux domain.]];
		};
		{
			"android-cloexec-epoll-create";
			[[The usage of epoll_create() is not recommended, it’s better to use epoll_create1(), which allows close-on-exec.]];
		};
		{
			"android-cloexec-epoll-create1";
			[[epoll_create1() should include EPOLL_CLOEXEC in its type argument to avoid the file descriptor leakage. Without this flag, an opened sensitive file would remain open across a fork+exec to a lower-privileged SELinux domain.]];
		};
		{
			"android-cloexec-fopen";
			[[fopen() should include e in their mode string; so re would be valid. This is equivalent to having set FD_CLOEXEC on that descriptor.]];
		};
		{
			"android-cloexec-inotify-init";
			[[The usage of inotify_init() is not recommended, it’s better to use inotify_init1().]];
		};
		{
			"android-cloexec-inotify-init1";
			[[inotify_init1() should include IN_CLOEXEC in its type argument to avoid the file descriptor leakage. Without this flag, an opened sensitive file would remain open across a fork+exec to a lower-privileged SELinux domain.]];
		};
		{
			"android-cloexec-memfd-create";
			[[memfd_create() should include MFD_CLOEXEC in its type argument to avoid the file descriptor leakage. Without this flag, an opened sensitive file would remain open across a fork+exec to a lower-privileged SELinux domain.]];
		};
		{
			"android-cloexec-open";
			[[A common source of security bugs is code that opens a file without using the O_CLOEXEC flag. Without that flag, an opened sensitive file would remain open across a fork+exec to a lower-privileged SELinux domain, leaking that sensitive data. Open-like functions including open(), openat(), and open64() should include O_CLOEXEC in their flags argument.]];
		};
		{
			"android-cloexec-pipe";
			[[This check detects usage of pipe(). Using pipe() is not recommended, pipe2() is the suggested replacement. The check also adds the O_CLOEXEC flag that marks the file descriptor to be closed in child processes. Without this flag a sensitive file descriptor can be leaked to a child process, potentially into a lower-privileged SELinux domain.]];
		};
		{
			"android-cloexec-pipe2";
			[[This check ensures that pipe2() is called with the O_CLOEXEC flag. The check also adds the O_CLOEXEC flag that marks the file descriptor to be closed in child processes. Without this flag a sensitive file descriptor can be leaked to a child process, potentially into a lower-privileged SELinux domain.]];
		};
		{
			"android-cloexec-socket";
			[[socket() should include SOCK_CLOEXEC in its type argument to avoid the file descriptor leakage. Without this flag, an opened sensitive file would remain open across a fork+exec to a lower-privileged SELinux domain.]];
		};
		{
			"android-comparison-in-temp-failure-retry";
			[[Diagnoses comparisons that appear to be incorrectly placed in the argument to the TEMP_FAILURE_RETRY macro. Having such a use is incorrect in the vast majority of cases, and will often silently defeat the purpose of the TEMP_FAILURE_RETRY macro.]];
		};
		{
			"boost-use-to-string";
			[[This check finds conversion from integer type like int to std::string or std::wstring using boost::lexical_cast, and replace it with calls to std::to_string and std::to_wstring.]];
		};
		{
			"bugprone-argument-comment";
			[[Checks that argument comments match parameter names.]];
		};
		{
			"bugprone-assert-side-effect";
			[[Finds assert() with side effect.]];
		};
		{
			"bugprone-assignment-in-if-condition";
			[[Finds assignments within conditions of if statements. Such assignments are bug-prone because they may have been intended as equality tests.]];
		};
		{
			"bugprone-bad-signal-to-kill-thread";
			[[Finds pthread_kill function calls when a thread is terminated by raising SIGTERM signal and the signal kills the entire process, not just the individual thread. Use any signal except SIGTERM.]];
		};
		{
			"bugprone-bool-pointer-implicit-conversion";
			[[Checks for conditions based on implicit conversion from a bool pointer to bool.]];
		};
		{
			"bugprone-branch-clone";
			[[Checks for repeated branches in if/else if/else chains, consecutive repeated branches in switch statements and identical true and false branches in conditional operators.]];
		};
		{
			"bugprone-copy-constructor-init";
			[[Finds copy constructors where the constructor doesn’t call the copy constructor of the base class.]];
		};
		{
			"bugprone-dangling-handle";
			[[Detect dangling references in value handles like std::string_view. These dangling references can be a result of constructing handles from temporary values, where the temporary is destroyed soon after the handle is created.]];
		};
		{
			"bugprone-dynamic-static-initializers";
			[[Finds instances of static variables that are dynamically initialized in header files.]];
		};
		{
			"bugprone-easily-swappable-parameters";
			[[Finds function definitions where parameters of convertible types follow each other directly, making call sites prone to calling the function with swapped (or badly ordered) arguments.]];
		};
		{
			"bugprone-exception-escape";
			[[Finds functions which may throw an exception directly or indirectly, but they should not. ]];
		};
		{
			"bugprone-fold-init-type";
			[[The check flags type mismatches in folds like std::accumulate that might result in loss of precision. std::accumulate folds an input range into an initial value using the type of the latter, with operator+ by default.]];
		};
		{
			"bugprone-forward-declaration-namespace";
			[[Checks if an unused forward declaration is in a wrong namespace.]];
		};
		{
			"bugprone-forwarding-reference-overload";
			[[The check looks for perfect forwarding constructors that can hide copy or move constructors. If a non const lvalue reference is passed to the constructor, the forwarding reference parameter will be a better match than the const reference parameter of the copy constructor, so the perfect forwarding constructor will be called, which can be confusing. For detailed description of this issue see: Scott Meyers, Effective Modern C++, Item 26.]];
		};
		{
			"bugprone-implicit-widening-of-multiplication-result";
			[[The check diagnoses instances where a result of a multiplication is implicitly widened, and suggests (with fix-it) to either silence the code by making widening explicit, or to perform the multiplication in a wider type, to avoid the widening afterwards.]];
		};
		{
			"bugprone-inaccurate-erase";
			[[Checks for inaccurate use of the erase() method.]];
		};
		{
			"bugprone-incorrect-roundings";
			[[Checks the usage of patterns known to produce incorrect rounding.]];
		};
		{
			"bugprone-infinite-loop";
			[[Finds obvious infinite loops (loops where the condition variable is not changed at all).]];
		};
		{
			"bugprone-integer-division";
			[[Finds cases where integer division in a floating point context is likely to cause unintended loss of precision.]];
		};
		{
			"bugprone-lambda-function-name";
			[[Checks for attempts to get the name of a function from within a lambda expression. The name of a lambda is always something like operator(), which is almost never what was intended.]];
		};
		{
			"bugprone-macro-parentheses";
			[[Finds macros that can have unexpected behavior due to missing parentheses.]];
		};
		{
			"bugprone-macro-repeated-side-effects";
			[[Checks for repeated argument with side effects in macros.]];
		};
		{
			"bugprone-misplaced-operator-in-strlen-in-alloc";
			[[Finds cases where 1 is added to the string in the argument to strlen(), strnlen(), strnlen_s(), wcslen(), wcsnlen(), and wcsnlen_s() instead of the result and the value is used as an argument to a memory allocation function (malloc(), calloc(), realloc(), alloca()) or the new[] operator in C++. The check detects error cases even if one of these functions (except the new[] operator) is called by a constant function pointer. Cases where 1 is added both to the parameter and the result of the strlen()-like function are ignored, as are cases where the whole addition is surrounded by extra parentheses.]];
		};
		{
			"bugprone-misplaced-pointer-arithmetic-in-alloc";
			[[Finds cases where an integer expression is added to or subtracted from the result of a memory allocation function (malloc(), calloc(), realloc(), alloca()) instead of its argument. The check detects error cases even if one of these functions is called by a constant function pointer.]];
		};
		{
			"bugprone-misplaced-widening-cast";
			[[This check will warn when there is a cast of a calculation result to a bigger type. If the intention of the cast is to avoid loss of precision then the cast is misplaced, and there can be loss of precision. Otherwise the cast is ineffective.]];
		};
		{
			"bugprone-move-forwarding-reference";
			[[Warns if std::move is called on a forwarding reference]];
		};
		{
			"bugprone-multiple-new-in-one-expression";
			[[Finds multiple new operator calls in a single expression, where the allocated memory by the first new may leak if the second allocation fails and throws exception.]];
		};
		{
			"bugprone-multiple-statement-macro";
			[[Detect multiple statement macros that are used in unbraced conditionals. Only the first statement of the macro will be inside the conditional and the other ones will be executed unconditionally.]];
		};
		{
			"bugprone-no-escape";
			[[Finds pointers with the noescape attribute that are captured by an asynchronously-executed block. The block arguments in dispatch_async() and dispatch_after() are guaranteed to escape, so it is an error if a pointer with the noescape attribute is captured by one of these blocks.]];
		};
		{
			"bugprone-non-zero-enum-to-bool-conversion";
			[[Detect implicit and explicit casts of enum type into bool where enum type doesn’t have a zero-value enumerator. If the enum is used only to hold values equal to its enumerators, then conversion to bool will always result in true value. This can lead to unnecessary code that reduces readability and maintainability and can result in bugs.]];
		};
		{
			"bugprone-not-null-terminated-result";
			[[Finds function calls where it is possible to cause a not null-terminated result. Usually the proper length of a string is strlen(src) + 1 or equal length of this expression, because the null terminator needs an extra space. Without the null terminator it can result in undefined behavior when the string is read.]];
		};
		{
			"bugprone-parent-virtual-call";
			[[Detects and fixes calls to grand-…parent virtual methods instead of calls to overridden parent’s virtual methods.]];
		};
		{
			"bugprone-posix-return";
			[[Checks if any calls to pthread_* or posix_* functions (except posix_openpt) expect negative return values. These functions return either 0 on success or an errno on failure, which is positive only.]];
		};
		{
			"bugprone-redundant-branch-condition";
			[[Finds condition variables in nested if statements that were also checked in the outer if statement and were not changed.]];
		};
		{
			"bugprone-reserved-identifier";
			[[Checks for usages of identifiers reserved for use by the implementation.]];
		};
		{
			"bugprone-shared-ptr-array-mismatch";
			[[Finds initializations of C++ shared pointers to non-array type that are initialized with an array.]];
		};
		{
			"bugprone-signal-handler";
			[[Finds specific constructs in signal handler functions that can cause undefined behavior. ]];
		};
		{
			"bugprone-signed-char-misuse";
			[[Finds those signed char -> integer conversions which might indicate a programming error. The basic problem with the signed char, that it might store the non-ASCII characters as negative values. This behavior can cause a misunderstanding of the written code both when an explicit and when an implicit conversion happens.]];
		};
		{
			"bugprone-sizeof-container";
			[[The check finds usages of sizeof on expressions of STL container types. Most likely the user wanted to use .size() instead.]];
		};
		{
			"bugprone-sizeof-expression";
			[[The check finds usages of sizeof expressions which are most likely errors.]];
		};
		{
			"bugprone-spuriously-wake-up-functions";
			[[Finds cnd_wait, cnd_timedwait, wait, wait_for, or wait_until function calls when the function is not invoked from a loop that checks whether a condition predicate holds or the function has a condition parameter.]];
		};
		{
			"bugprone-standalone-empty";
			[[Warns when empty() is used on a range and the result is ignored. Suggests clear() if it is an existing member function.]];
		};
		{
			"bugprone-string-constructor";
			[[Finds string constructors that are suspicious and probably errors.]];
		};
		{
			"bugprone-string-integer-assignment";
			[[The check finds assignments of an integer to std::basic_string<CharT> (std::string, std::wstring, etc.).]];
		};
		{
			"bugprone-string-literal-with-embedded-nul";
			[[Finds occurrences of string literal with embedded NUL character and validates their usage.]];
		};
		{
			"bugprone-stringview-nullptr";
			[[Checks for various ways that the const CharT* constructor of std::basic_string_view can be passed a null argument and replaces them with the default constructor in most cases. For the comparison operators, braced initializer list does not compile so instead a call to .empty() or the empty string literal are used, where appropriate.]];
		};
		{
			"bugprone-suspicious-enum-usage";
			[[The checker detects various cases when an enum is probably misused (as a bitmask ).]];
		};
		{
			"bugprone-suspicious-include";
			[[The check detects various cases when an include refers to what appears to be an implementation file, which often leads to hard-to-track-down ODR violations.]];
		};
		{
			"bugprone-suspicious-memory-comparison";
			[[Finds potentially incorrect calls to memcmp() based on properties of the arguments.]];
		};
		{
			"bugprone-suspicious-memset-usage";
			[[This check finds memset() calls with potential mistakes in their arguments.]];
		};
		{
			"bugprone-suspicious-missing-comma";
			[[String literals placed side-by-side are concatenated at translation phase 6 (after the preprocessor). This feature is used to represent long string literal on multiple lines.]];
		};
		{
			"bugprone-suspicious-realloc-usage";
			[[This check finds usages of realloc where the return value is assigned to the same expression as passed to the first argument: p = realloc(p, size); The problem with this construct is that if realloc fails it returns a null pointer but does not deallocate the original memory. If no other variable is pointing to it, the original memory block is not available any more for the program to use or free. In either case p = realloc(p, size); indicates bad coding style and can be replaced by q = realloc(p, size);.]];
		};
		{
			"bugprone-suspicious-semicolon";
			[[Finds most instances of stray semicolons that unexpectedly alter the meaning of the code. More specifically, it looks for if, while, for and for-range statements whose body is a single semicolon, and then analyzes the context of the code (e.g. indentation) in an attempt to determine whether that is intentional.]];
		};
		{
			"bugprone-suspicious-string-compare";
			[[Find suspicious usage of runtime string comparison functions.]];
		};
		{
			"bugprone-swapped-arguments";
			[[Finds potentially swapped arguments by looking at implicit conversions.]];
		};
		{
			"bugprone-terminating-continue";
			[[Detects do while loops with a condition always evaluating to false that have a continue statement, as this continue terminates the loop effectively.]];
		};
		{
			"bugprone-throw-keyword-missing";
			[[Warns about a potentially missing throw keyword. If a temporary object is created, but the object’s type derives from (or is the same as) a class that has ‘EXCEPTION’, ‘Exception’ or ‘exception’ in its name, we can assume that the programmer’s intention was to throw that object.]];
		};
		{
			"bugprone-too-small-loop-variable";
			[[Detects those for loops that have a loop variable with a "too small" type which means this type can't represent all values which are part of the iteration range.]];
		};
		{
			"bugprone-unchecked-optional-access";
			[[This check identifies unsafe accesses to values contained in std::optional<T>, absl::optional<T>, or base::Optional<T> objects. Below we will refer to all these types collectively as optional<T>.]];
		};
		{
			"bugprone-undefined-memory-manipulation";
			[[Finds calls of memory manipulation functions memset(), memcpy() and memmove() on not TriviallyCopyable objects resulting in undefined behavior.]];
		};
		{
			"bugprone-undelegated-constructor";
			[[Finds calls of memory manipulation functions memset(), memcpy() and memmove() on not TriviallyCopyable objects resulting in undefined behavior.]];
		};
		{
			"bugprone-unhandled-exception-at-new";
			[[Finds calls to new with missing exception handler for std::bad_alloc.]];
		};
		{
			"bugprone-unhandled-self-assignment";
			[[Finds user-defined copy assignment operators which do not protect the code against self-assignment either by checking self-assignment explicitly or using the copy-and-swap or the copy-and-move method.]];
		};
		{
			"bugprone-unsafe-functions";
			[[Checks for functions that have safer, more secure replacements available, or are considered deprecated due to design flaws. The check heavily relies on the functions from the Annex K. “Bounds-checking interfaces” of C11.]];
		};
		{
			"bugprone-unused-raii";
			[[Finds temporaries that look like RAII objects.]];
		};
		{
			"bugprone-unused-return-value";
			[[Warns on unused function return values. The checked functions can be configured.]];
		};
		{
			"bugprone-use-after-move";
			[[Warns if an object is used after it has been moved]];
		};
		{
			"bugprone-virtual-near-miss";
			[[Warn if a function is a near miss (i.e. the name is very similar and the function signature is the same) to a virtual function from a base class.]];
		};
		{
			"cert-dcl21-cpp";
			[[This check flags postfix operator++ and operator-- declarations if the return type is not a const object. This also warns if the return type is a reference type.]];
		};
		{
			"cert-dcl50-cpp";
			[[This check flags all function definitions (but not declarations) of C-style variadic functions.]];
		};
		{
			"cert-dcl58-cpp";
			[[Modification of the std or posix namespace can result in undefined behavior. This check warns for such modifications. The std (or posix) namespace is allowed to be extended with (class or function) template specializations that depend on an user-defined type (a type that is not defined in the standard system headers).]];
		};
		{
			"cert-env33-c";
			[[This check flags calls to system(), popen(), and _popen(), which execute a command processor. It does not flag calls to system() with a null pointer argument, as such a call checks for the presence of a command processor but does not actually attempt to execute a command.]];
		};
		{
			"cert-err33-c";
			[[Warns on unused function return values. Many of the standard library functions return a value that indicates if the call was successful. Ignoring the returned value can cause unexpected behavior if an error has occurred.]];
		};
		{
			"cert-err34-c";
			[[This check flags calls to string-to-number conversion functions that do not verify the validity of the conversion, such as atoi() or scanf(). It does not flag calls to strtol(), or other, related conversion functions that do perform better error checking.]];
		};
		{
			"cert-err52-cpp";
			[[This check flags all call expressions involving setjmp() and longjmp().]];
		};
		{
			"cert-err58-cpp";
			[[This check flags all static or thread_local variable declarations where the initializer for the object may throw an exception.]];
		};
		{
			"cert-err60-cpp";
			[[This check flags all throw expressions where the exception object is not nothrow copy constructible.]];
		};
		{
			"cert-flp30-c";
			[[This check flags for loops where the induction expression has a floating-point type.]];
		};
		{
			"cert-mem57-cpp";
			[[This check flags uses of default operator new where the type has extended alignment (an alignment greater than the fundamental alignment). (The default operator new is guaranteed to provide the correct alignment if the requested alignment is less or equal to the fundamental alignment). Only cases are detected (by design) where the operator new is not user-defined and is not a placement new (the reason is that in these cases we assume that the user provided the correct memory allocation).]];
		};
		{
			"cert-msc50-cpp";
			[[Pseudorandom number generators use mathematical algorithms to produce a sequence of numbers with good statistical properties, but the numbers produced are not genuinely random. The std::rand() function takes a seed (number), runs a mathematical operation on it and returns the result. By manipulating the seed the result can be predictable. This check warns for the usage of std::rand().]];
		};
		{
			"cert-msc51-cpp";
			[[This check flags all pseudo-random number engines, engine adaptor instantiations and srand() when initialized or seeded with default argument, constant expression or any user-configurable type. Pseudo-random number engines seeded with a predictable value may cause vulnerabilities e.g. in security protocols. This is a CERT security rule, see MSC51-CPP. Ensure your random number generator is properly seeded and MSC32-C. Properly seed pseudorandom number generators.]];
		};
		{
			"cert-oop57-cpp";
			[[Flags use of the C standard library functions memset, memcpy and memcmp and similar derivatives on non-trivial types.]];
		};
		{
			"cert-oop58-cpp";
			[[Finds assignments to the copied object and its direct or indirect members in copy constructors and copy assignment operators.]];
		};
		{
			"clang-analyzer-core.DynamicTypePropagation";
			[[Generate dynamic type information]];
		};
		{
			"clang-analyzer-core.uninitialized.CapturedBlockVariable";
			[[Check for blocks that capture uninitialized values]];
		};
		{
			"clang-analyzer-cplusplus.InnerPointer";
			[[Check for inner pointers of C++ containers used after re/deallocation]];
		};
		{
			"clang-analyzer-nullability.NullableReturnedFromNonnull";
			[[Warns when a nullable pointer is returned from a function that has _Nonnull return type.]];
		};
		{
			"clang-analyzer-optin.osx.OSObjectCStyleCast";
			[[Checker for C-style casts of OSObjects]];
		};
		{
			"clang-analyzer-optin.performance.GCDAntipattern";
			[[Check for performance anti-patterns when using Grand Central Dispatch]];
		};
		{
			"clang-analyzer-optin.performance.Padding";
			[[Check for excessively padded structs.]];
		};
		{
			"clang-analyzer-optin.portability.UnixAPI";
			[[Finds implementation-defined behavior in UNIX/Posix functions]];
		};
		{
			"clang-analyzer-osx.MIG";
			[[Find violations of the Mach Interface Generator calling convention]];
		};
		{
			"clang-analyzer-osx.NumberObjectConversion";
			[[Check for erroneous conversions of objects representing numbers into numbers]];
		};
		{
			"clang-analyzer-osx.OSObjectRetainCount";
			[[Check for leaks and improper reference count management for OSObject]];
		};
		{
			"clang-analyzer-osx.ObjCProperty";
			[[Check for proper uses of Objective-C properties]];
		};
		{
			"clang-analyzer-osx.cocoa.AutoreleaseWrite";
			[[Warn about potentially crashing writes to autoreleasing objects from different autoreleasing pools in Objective-C]];
		};
		{
			"clang-analyzer-osx.cocoa.Loops";
			[[Improved modeling of loops using Cocoa collection types]];
		};
		{
			"clang-analyzer-osx.cocoa.MissingSuperCall";
			[[Warn about Objective-C methods that lack a necessary call to super]];
		};
		{
			"clang-analyzer-osx.cocoa.NonNilReturnValue";
			[[Model the APIs that are guaranteed to return a non-nil value]];
		};
		{
			"clang-analyzer-osx.cocoa.RunLoopAutoreleaseLeak";
			[[Check for leaked memory in autorelease pools that will never be drained]];
		};
		{
			"clang-analyzer-valist.CopyToSelf";
			[[Check for va_lists which are copied onto itself.]];
		};
		{
			"clang-analyzer-valist.Uninitialized";
			[[Check for usages of uninitialized (or already released) va_lists.]];
		};
		{
			"clang-analyzer-valist.Unterminated";
			[[Check for va_lists which are not released by a va_end call.]];
		};
		{
			"concurrency-mt-unsafe";
			[[Checks for some thread-unsafe functions against a black list of known-to-be-unsafe functions. Usually they access static variables without synchronization (e.g. gmtime(3)) or utilize signals in a racy way. The set of functions to check is specified with the FunctionSet option.]];
		};
		{
			"concurrency-thread-canceltype-asynchronous";
			[[Finds pthread_setcanceltype function calls where a thread’s cancellation type is set to asynchronous. Asynchronous cancellation type (PTHREAD_CANCEL_ASYNCHRONOUS) is generally unsafe, use type PTHREAD_CANCEL_DEFERRED instead which is the default. Even with deferred cancellation, a cancellation point in an asynchronous signal handler may still be acted upon and the effect is as if it was an asynchronous cancellation.]];
		};
		{
			"cppcoreguidelines-avoid-capturing-lambda-coroutines";
			[[Flags C++20 coroutine lambdas with non-empty capture lists that may cause use-after-free errors and suggests avoiding captures or ensuring the lambda closure object has a guaranteed lifetime.]];
		};
		{
			"cppcoreguidelines-avoid-const-or-ref-data-members";
			[[This check warns when structs or classes have const-qualified or reference (lvalue or rvalue) data members. Having such members is rarely useful, and makes the class only copy-constructible but not copy-assignable.]];
		};
		{
			"cppcoreguidelines-avoid-do-while";
			[[Warns when using do-while loops. They are less readable than plain while loops, since the termination condition is at the end and the condition is not checked prior to the first iteration. This can lead to subtle bugs.]];
		};
		{
			"cppcoreguidelines-avoid-goto";
			[[The usage of goto for control flow is error prone and should be replaced with looping constructs. Only forward jumps in nested loops are accepted.]];
		};
		{
			"cppcoreguidelines-avoid-non-const-global-variables";
			[[Finds non-const global variables]];
		};
		{
			"cppcoreguidelines-avoid-reference-coroutine-parameters";
			[[Warns when a coroutine accepts reference parameters. After a coroutine suspend point, references could be dangling and no longer valid. Instead, pass parameters as values.]];
		};
		{
			"cppcoreguidelines-init-variables";
			[[Checks whether there are local variables that are declared without an initial value. These may lead to unexpected behavior if there is a code path that reads the variable before assigning to it.]];
		};
		{
			"cppcoreguidelines-interfaces-global-init";
			[[This check flags initializers of globals that access extern objects, and therefore can lead to order-of-initialization problems.]];
		};
		{
			"cppcoreguidelines-macro-usage";
			[[Finds macro usage that is considered problematic because better language constructs exist for the task.]];
		};
		{
			"cppcoreguidelines-misleading-capture-default-by-value";
			[[Warns when lambda specify a by-value capture default and capture this.]];
		};
		{
			"cppcoreguidelines-missing-std-forward";
			[[Warns when a forwarding reference parameter is not forwarded inside the function body.]];
		};
		{
			"cppcoreguidelines-narrowing-conversions";
			[[Checks for silent narrowing conversions, e.g: int i = 0; i += 0.1;. While the issue is obvious in this former example, it might not be so in the following: void MyClass::f(double d) { int_member_ += d; }.]];
		};
		{
			"cppcoreguidelines-no-malloc";
			[[This check handles C-Style memory management using malloc(), realloc(), calloc() and free(). It warns about its use and tries to suggest the use of an appropriate RAII object. Furthermore, it can be configured to check against a user-specified list of functions that are used for memory management (e.g. posix_memalign()).]];
		};
		{
			"cppcoreguidelines-owning-memory";
			[[This check implements the type-based semantics of gsl::owner<T*>, which allows static analysis on code, that uses raw pointers to handle resources like dynamic memory, but won’t introduce RAII concepts.]];
		};
		{
			"cppcoreguidelines-prefer-member-initializer";
			[[Finds member initializations in the constructor body which can be converted into member initializers of the constructor instead. This not only improves the readability of the code but also positively affects its performance. Class-member assignments inside a control statement or following the first control statement are ignored.]];
		};
		{
			"cppcoreguidelines-pro-bounds-array-to-pointer-decay";
			[[This check flags all array to pointer decays.]];
		};
		{
			"cppcoreguidelines-pro-bounds-constant-array-index";
			[[This check flags all array subscript expressions on static arrays and std::arrays that either do not have a constant integer expression index or are out of bounds (for std::array). ]];
		};
		{
			"cppcoreguidelines-pro-bounds-pointer-arithmetic";
			[[This check flags all usage of pointer arithmetic, because it could lead to an invalid pointer. Subtraction of two pointers is not flagged by this check.]];
		};
		{
			"cppcoreguidelines-pro-type-const-cast";
			[[This check flags all uses of const_cast in C++ code.]];
		};
		{
			"cppcoreguidelines-pro-type-cstyle-cast";
			[[This check flags all use of C-style casts that perform a static_cast downcast, const_cast, or reinterpret_cast.]];
		};
		{
			"cppcoreguidelines-pro-type-member-init";
			[[The check flags user-defined constructor definitions that do not initialize all fields that would be left in an undefined state by default construction, e.g. builtins, pointers and record types without user-provided default constructors containing at least one such type. If these fields aren’t initialized, the constructor will leave some of the memory in an undefined state.]];
		};
		{
			"cppcoreguidelines-pro-type-reinterpret-cast";
			[[This check flags all uses of reinterpret_cast in C++ code.]];
		};
		{
			"cppcoreguidelines-pro-type-static-cast-downcast";
			[[This check flags all usages of static_cast, where a base class is casted to a derived class. In those cases, a fix-it is provided to convert the cast to a dynamic_cast.]];
		};
		{
			"cppcoreguidelines-pro-type-union-access";
			[[This check flags all access to members of unions. Passing unions as a whole is not flagged.]];
		};
		{
			"cppcoreguidelines-pro-type-vararg";
			[[This check flags all calls to c-style vararg functions and all use of va_arg.]];
		};
		{
			"cppcoreguidelines-rvalue-reference-param-not-moved";
			[[Warns when an rvalue reference function parameter is never moved within the function body.]];
		};
		{
			"cppcoreguidelines-slicing";
			[[Flags slicing of member variables or vtable. Slicing happens when copying a derived object into a base object: the members of the derived object (both member variables and virtual member functions) will be discarded.]];
		};
		{
			"cppcoreguidelines-special-member-functions";
			[[The check finds classes where some but not all of the special member functions are defined.]];
		};
		{
			"cppcoreguidelines-virtual-class-destructor";
			[[Finds virtual classes whose destructor is neither public and virtual nor protected and non-virtual. A virtual class’s destructor should be specified in one of these ways to prevent undefined behavior.]];
		};
		{
			"darwin-avoid-spinlock";
			[[Finds usages of OSSpinlock, which is deprecated due to potential livelock problems.]];
		};
		{
			"darwin-dispatch-once-nonstatic";
			[[Finds declarations of dispatch_once_t variables without static or global storage. The behavior of using dispatch_once_t predicates with automatic or dynamic storage is undefined by libdispatch, and should be avoided.]];
		};
		{
			"fuchsia-default-arguments-calls";
			[[Warns if a function or method is called with default arguments.]];
		};
		{
			"fuchsia-default-arguments-declarations";
			[[Warns if a function or method is declared with default parameters.]];
		};
		{
			"fuchsia-multiple-inheritance";
			[[Warns if a class inherits from multiple classes that are not pure virtual.]];
		};
		{
			"fuchsia-overloaded-operator";
			[[Warns if an operator is overloaded, except for the assignment (copy and move) operators.]];
		};
		{
			"fuchsia-statically-constructed-objects";
			[[Warns if global, non-trivial objects with static storage are constructed, unless the object is statically initialized with a constexpr constructor or has no explicit constructor.]];
		};
		{
			"fuchsia-trailing-return";
			[[Functions that have trailing returns are disallowed, except for those using decltype specifiers and lambda with otherwise unutterable return types.]];
		};
		{
			"fuchsia-virtual-inheritance";
			[[Warns if classes are defined with virtual inheritance.]];
		};
		{
			"google-build-explicit-make-pair";
			[[Check that make_pair’s template arguments are deduced.]];
		};
		{
			"google-build-namespaces";
			[[Finds anonymous namespaces in headers.]];
		};
		{
			"google-build-using-namespace";
			[[Finds using namespace directives.]];
		};
		{
			"google-default-arguments";
			[[Checks that default arguments are not given for virtual methods.]];
		};
		{
			"google-explicit-constructor";
			[[Checks that constructors callable with a single argument and conversion operators are marked explicit to avoid the risk of unintentional implicit conversions.]];
		};
		{
			"google-global-names-in-headers";
			[[Flag global namespace pollution in header files. Right now it only triggers on using declarations and directives.]];
		};
		{
			"google-objc-avoid-nsobject-new";
			[[Finds calls to +new or overrides of it, which are prohibited by the Google Objective-C style guide.]];
		};
		{
			"google-objc-avoid-throwing-exception";
			[[Finds uses of throwing exceptions usages in Objective-C files.]];
		};
		{
			"google-objc-function-naming";
			[[Finds function declarations in Objective-C files that do not follow the pattern described in the Google Objective-C Style Guide.]];
		};
		{
			"google-objc-global-variable-declaration";
			[[Finds global variable declarations in Objective-C files that do not follow the pattern of variable names in Google’s Objective-C Style Guide.]];
		};
		{
			"google-readability-avoid-underscore-in-googletest-name";
			[[Checks whether there are underscores in googletest test suite names and test names in test macros]];
		};
		{
			"google-readability-casting";
			[[Finds usages of C-style casts.]];
		};
		{
			"google-readability-todo";
			[[Finds TODO comments without a username or bug number.]];
		};
		{
			"google-runtime-int";
			[[Finds uses of short, long and long long and suggest replacing them with u?intXX(_t)?.]];
		};
		{
			"google-runtime-operator";
			[[Finds overloads of unary operator &.]];
		};
		{
			"google-upgrade-googletest-case";
			[[Finds uses of deprecated Google Test version 1.9 APIs with names containing case and replaces them with equivalent APIs with suite.]];
		};
		{
			"hicpp-avoid-goto";
			[[The usage of goto for control flow is error prone and should be replaced with looping constructs. Only forward jumps in nested loops are accepted.]];
		};
		{
			"hicpp-exception-baseclass";
			[[Ensure that every value that in a throw expression is an instance of std::exception.]];
		};
		{
			"hicpp-multiway-paths-covered";
			[[This check discovers situations where code paths are not fully-covered. It furthermore suggests using if instead of switch if the code will be more clear. ]];
		};
		{
			"hicpp-no-assembler";
			[[Check for assembler statements. No fix is offered.]];
		};
		{
			"hicpp-signed-bitwise";
			[[Finds uses of bitwise operations on signed integer types, which may lead to undefined or implementation defined behavior.]];
		};
		{
			"linuxkernel-must-use-errs";
			[[Checks Linux kernel code to see if it uses the results from the functions in linux/err.h. Also checks to see if code uses the results from functions that directly return a value from one of these error functions.]];
		};
		{
			"llvm-header-guard";
			[[Finds and fixes header guards that do not adhere to LLVM style.]];
		};
		{
			"llvm-include-order";
			[[Checks the correct order of #includes.]];
		};
		{
			"llvm-namespace-comment";
			[[Checks that long namespaces have a closing comment.]];
		};
		{
			"llvm-prefer-isa-or-dyn-cast-in-conditionals";
			[[Looks at conditionals and finds and replaces cases of cast<>, which will assert rather than return a null pointer, and dyn_cast<> where the return value is not captured. Additionally, finds and replaces cases that match the pattern var && isa<X>(var), where var is evaluated twice.]];
		};
		{
			"llvm-prefer-register-over-unsigned";
			[[Finds historical use of unsigned to hold vregs and physregs and rewrites them to use Register.]];
		};
		{
			"llvm-twine-local";
			[[Looks for local Twine variables which are prone to use after frees and should be generally avoided.]];
		};
		{
			"llvmlibc-callee-namespace";
			[[Checks all calls resolve to functions within __llvm_libc namespace.]];
		};
		{
			"llvmlibc-implementation-in-namespace";
			[[Checks that all declarations in the llvm-libc implementation are within the correct namespace.]];
		};
		{
			"llvmlibc-inline-function-decl";
			[[Checks that all implicit and explicit inline functions in header files are tagged with the LIBC_INLINE macro. See the libc style guide for more information about this macro.]];
		};
		{
			"llvmlibc-restrict-system-libc-headers";
			[[Finds includes of system libc headers not provided by the compiler within llvm-libc implementations.]];
		};
		{
			"misc-confusable-identifiers";
			[[Warn about confusable identifiers, i.e. identifiers that are visually close to each other, but use different Unicode characters.]];
		};
		{
			"misc-const-correctness";
			[[This check implements detection of local variables which could be declared as const but are not.]];
		};
		{
			"misc-definitions-in-headers";
			[[Finds non-extern non-inline function and variable definitions in header files, which can lead to potential ODR violations in case these headers are included from multiple translation units.]];
		};
		{
			"misc-misleading-bidirectional";
			[[Warn about unterminated bidirectional unicode sequence, detecting potential attack as described in the Trojan Source attack.]];
		};
		{
			"misc-misleading-identifier";
			[[Finds identifiers that contain Unicode characters with right-to-left direction, which can be confusing as they may change the understanding of a whole statement line, as described in Trojan Source.]];
		};
		{
			"misc-misplaced-const";
			[[This check diagnoses when a const qualifier is applied to a typedef/ using to a pointer type rather than to the pointee, because such constructs are often misleading to developers because the const applies to the pointer rather than the pointee.]];
		};
		{
			"misc-new-delete-overloads";
			[[The check flags overloaded operator new() and operator delete() functions that do not have a corresponding free store function defined within the same scope. For instance, the check will flag a class implementation of a non-placement operator new() when the class does not also define a non-placement operator delete() function as well.]];
		};
		{
			"misc-no-recursion";
			[[Finds strongly connected functions (by analyzing the call graph for SCC’s (Strongly Connected Components) that are loops), diagnoses each function in the cycle, and displays one example of a possible call graph loop (recursion).]];
		};
		{
			"misc-non-copyable-objects";
			[[The check flags dereferences and non-pointer declarations of objects that are not meant to be passed by value, such as C FILE objects or POSIX pthread_mutex_t objects.]];
		};
		{
			"misc-non-private-member-variables-in-classes";
			[[Finds classes that contain non-static data members in addition to user-declared non-static member functions and diagnose all data members declared with a non-public access specifier. The data members should be declared as private and accessed through member functions instead of exposed to derived classes or class consumers.]];
		};
		{
			"misc-redundant-expression";
			[[Detect redundant expressions which are typically errors due to copy-paste.]];
		};
		{
			"misc-static-assert";
			[[Replaces assert() with static_assert() if the condition is evaluable at compile time.]];
		};
		{
			"misc-throw-by-value-catch-by-reference";
			[[Finds violations of the rule “Throw by value, catch by reference” presented for example in “C++ Coding Standards” by H. Sutter and A. Alexandrescu, as well as the CERT C++ Coding Standard rule ERR61-CPP. Catch exceptions by lvalue reference.]];
		};
		{
			"misc-unconventional-assign-operator";
			[[Finds declarations of assign operators with the wrong return and/or argument types and definitions with good return type but wrong return statements.]];
		};
		{
			"misc-uniqueptr-reset-release";
			[[Find and replace unique_ptr::reset(release()) with std::move().]];
		};
		{
			"misc-unused-alias-decls";
			[[Finds unused namespace alias declarations.]];
		};
		{
			"misc-unused-parameters";
			[[Finds unused function parameters. Unused parameters may signify a bug in the code (e.g. when a different parameter is used instead). The suggested fixes either comment parameter name out or remove the parameter completely, if all callers of the function are in the same translation unit and can be updated.]];
		};
		{
			"misc-unused-using-decls";
			[[Finds unused using declarations.]];
		};
		{
			"misc-use-anonymous-namespace";
			[[Finds instances of static functions or variables declared at global scope that could instead be moved into an anonymous namespace.]];
		};
		{
			"modernize-avoid-bind";
			[[The check finds uses of std::bind and boost::bind and replaces them with lambdas. Lambdas will use value-capture unless reference capture is explicitly requested with std::ref or boost::ref.]];
		};
		{
			"modernize-avoid-c-arrays";
			[[Finds C-style array types and recommend to use std::array<> / std::vector<>. All types of C arrays are diagnosed.]];
		};
		{
			"modernize-concat-nested-namespaces";
			[[Checks for use of nested namespaces such as namespace a { namespace b { ... } } and suggests changing to the more concise syntax introduced in C++17: namespace a::b { ... }. Inline namespaces are not modified.]];
		};
		{
			"modernize-deprecated-headers";
			[[Some headers from C library were deprecated in C++ and are no longer welcome in C++ codebases. Some have no effect in C++. For more details refer to the C++ 14 Standard [depr.c.headers] section.]];
		};
		{
			"modernize-deprecated-ios-base-aliases";
			[[Detects usage of the deprecated member types of std::ios_base and replaces those that have a non-deprecated equivalent.]];
		};
		{
			"modernize-loop-convert";
			[[This check converts for(...; ...; ...) loops to use the new range-based loops in C++11.]];
		};
		{
			"modernize-macro-to-enum";
			[[Replaces groups of adjacent macros with an unscoped anonymous enum. Using an unscoped anonymous enum ensures that everywhere the macro token was used previously, the enumerator name may be safely used.]];
		};
		{
			"modernize-make-shared";
			[[This check finds the creation of std::shared_ptr objects by explicitly calling the constructor and a new expression, and replaces it with a call to std::make_shared.]];
		};
		{
			"modernize-make-unique";
			[[This check finds the creation of std::unique_ptr objects by explicitly calling the constructor and a new expression, and replaces it with a call to std::make_unique, introduced in C++14.]];
		};
		{
			"modernize-pass-by-value";
			[[With move semantics added to the language and the standard library updated with move constructors added for many types it is now interesting to take an argument directly by value, instead of by const-reference, and then copy. This check allows the compiler to take care of choosing the best way to construct the copy.]];
		};
		{
			"modernize-raw-string-literal";
			[[This check selectively replaces string literals containing escaped characters with raw string literals.]];
		};
		{
			"modernize-redundant-void-arg";
			[[Find and remove redundant void argument lists.]];
		};
		{
			"modernize-replace-auto-ptr";
			[[This check replaces the uses of the deprecated class std::auto_ptr by std::unique_ptr (introduced in C++11). The transfer of ownership, done by the copy-constructor and the assignment operator, is changed to match std::unique_ptr usage by using explicit calls to std::move().]];
		};
		{
			"modernize-replace-disallow-copy-and-assign-macro";
			[[Finds macro expansions of DISALLOW_COPY_AND_ASSIGN(Type) and replaces them with a deleted copy constructor and a deleted assignment operator.]];
		};
		{
			"modernize-replace-random-shuffle";
			[[This check will find occurrences of std::random_shuffle and replace it with std::shuffle. In C++17 std::random_shuffle will no longer be available and thus we need to replace it.]];
		};
		{
			"modernize-return-braced-init-list";
			[[Replaces explicit calls to the constructor in a return with a braced initializer list. This way the return type is not needlessly duplicated in the function definition and the return statement.]];
		};
		{
			"modernize-shrink-to-fit";
			[[Replace copy and swap tricks on shrinkable containers with the shrink_to_fit() method call.]];
		};
		{
			"modernize-type-traits";
			[[Converts standard library type traits of the form traits<...>::type and traits<...>::value into traits_t<...> and traits_v<...> respectively.]];
		};
		{
			"modernize-unary-static-assert";
			[[The check diagnoses any static_assert declaration with an empty string literal and provides a fix-it to replace the declaration with a single-argument static_assert declaration.]];
		};
		{
			"modernize-use-auto";
			[[This check is responsible for using the auto type specifier for variable declarations to improve code readability and maintainability.]];
		};
		{
			"modernize-use-bool-literals";
			[[Finds integer literals which are cast to bool.]];
		};
		{
			"modernize-use-default-member-init";
			[[This check converts constructors’ member initializers into the new default member initializers in C++11. Other member initializers that match the default member initializer are removed. This can reduce repeated code or allow use of ‘= default’.]];
		};
		{
			"modernize-use-emplace";
			[[The check flags insertions to an STL-style container done by calling the push_back, push, or push_front methods with an explicitly-constructed temporary of the container element type. In this case, the corresponding emplace equivalent methods result in less verbose and potentially more efficient code. Right now the check doesn’t support insert. It also doesn’t support insert functions for associative containers because replacing insert with emplace may result in speed regression, but it might get support with some addition flag in the future.]];
		};
		{
			"modernize-use-equals-default";
			[[This check replaces default bodies of special member functions with = default;. The explicitly defaulted function declarations enable more opportunities in optimization, because the compiler might treat explicitly defaulted functions as trivial.]];
		};
		{
			"modernize-use-equals-delete";
			[[This check marks unimplemented private special member functions with = delete. To avoid false-positives, this check only applies in a translation unit that has all other member functions implemented.]];
		};
		{
			"modernize-use-nodiscard";
			"Adds [[nodiscard]] attributes (introduced in C++17) to member functions in order to highlight at compile time which return values should not be ignored.";
		};
		{
			"modernize-use-noexcept";
			[[This check replaces deprecated dynamic exception specifications with the appropriate noexcept specification (introduced in C++11). By default this check will replace throw() with noexcept, and throw(<exception>[,...]) or throw(...) with noexcept(false).]];
		};
		{
			"modernize-use-nullptr";
			[[The check converts the usage of null pointer constants (e.g. NULL, 0) to use the new C++11 nullptr keyword.]];
		};
		{
			"modernize-use-override";
			[[Adds override (introduced in C++11) to overridden virtual functions and removes virtual from those functions as it is not required.]];
		};
		{
			"modernize-use-trailing-return-type";
			[[Rewrites function signatures to use a trailing return type (introduced in C++11). This transformation is purely stylistic. The return type before the function name is replaced by auto and inserted after the function parameter list (and qualifiers).]];
		};
		{
			"modernize-use-transparent-functors";
			[[Prefer transparent functors to non-transparent ones. When using transparent functors, the type does not need to be repeated. The code is easier to read, maintain and less prone to errors. It is not possible to introduce unwanted conversions.]];
		};
		{
			"modernize-use-uncaught-exceptions";
			[[This check will warn on calls to std::uncaught_exception and replace them with calls to std::uncaught_exceptions, since std::uncaught_exception was deprecated in C++17.]];
		};
		{
			"modernize-use-using";
			[[The check converts the usage of typedef with using keyword.]];
		};
		{
			"mpi-buffer-deref";
			[[This check verifies if a buffer passed to an MPI (Message Passing Interface) function is sufficiently dereferenced. Buffers should be passed as a single pointer or array. As MPI function signatures specify void * for their buffer types, insufficiently dereferenced buffers can be passed, like for example as double pointers or multidimensional arrays, without a compiler warning emitted.]];
		};
		{
			"mpi-type-mismatch";
			[[This check verifies if buffer type and MPI (Message Passing Interface) datatype pairs match for used MPI functions. All MPI datatypes defined by the MPI standard (3.1) are verified by this check. User defined typedefs, custom MPI datatypes and null pointer constants are skipped, in the course of verification.]];
		};
		{
			"objc-assert-equals";
			[[Finds improper usages of XCTAssertEqual and XCTAssertNotEqual and replaces them with XCTAssertEqualObjects or XCTAssertNotEqualObjects.]];
		};
		{
			"objc-avoid-nserror-init";
			[[Finds improper initialization of NSError objects.]];
		};
		{
			"objc-dealloc-in-category";
			[[Finds implementations of -dealloc in Objective-C categories. The category implementation will override any -dealloc in the class implementation, potentially causing issues.]];
		};
		{
			"objc-forbidden-subclassing";
			[[Finds Objective-C classes which are subclasses of classes which are not designed to be subclassed.]];
		};
		{
			"objc-missing-hash";
			[[Finds Objective-C implementations that implement -isEqual: without also appropriately implementing -hash.]];
		};
		{
			"objc-nsdate-formatter";
			[[When NSDateFormatter is used to convert an NSDate type to a String type, the user can specify a custom format string. Certain format specifiers are undesirable despite being legal.]];
		};
		{
			"objc-nsinvocation-argument-lifetime";
			[[Finds calls to NSInvocation methods under ARC that don’t have proper argument object lifetimes. When passing Objective-C objects as parameters to the NSInvocation methods getArgument:atIndex: and getReturnValue:, the values are copied by value into the argument pointer, which leads to incorrect releasing behavior if the object pointers are not declared __unsafe_unretained.]];
		};
		{
			"objc-property-declaration";
			[[Finds property declarations in Objective-C files that do not follow the pattern of property names in Apple’s programming guide. The property name should be in the format of Lower Camel Case.]];
		};
		{
			"objc-super-self";
			[[Finds invocations of -self on super instances in initializers of subclasses of NSObject and recommends calling a superclass initializer instead.]];
		};
		{
			"openmp-exception-escape";
			[[Analyzes OpenMP Structured Blocks and checks that no exception escapes out of the Structured Block it was thrown in.]];
		};
		{
			"openmp-use-default-none";
			[[Finds OpenMP directives that are allowed to contain a default clause, but either don’t specify it or the clause is specified but with the kind other than none, and suggests to use the default(none) clause.]];
		};
		{
			"performance-avoid-endl";
			[[Checks for uses of std::endl on streams and suggests using the newline character '\n' instead.]];
		};
		{
			"performance-faster-string-find";
			[[Optimize calls to std::string::find() and friends when the needle passed is a single character string literal. The character literal overload is more efficient.]];
		};
		{
			"performance-for-range-copy";
			[[Finds C++11 for ranges where the loop variable is copied in each iteration but it would suffice to obtain it by const reference.]];
		};
		{
			"performance-implicit-conversion-in-loop";
			[[This warning appears in a range-based loop with a loop variable of const ref type where the type of the variable does not match the one returned by the iterator. This means that an implicit conversion happens, which can for example result in expensive deep copies.]];
		};
		{
			"performance-inefficient-algorithm";
			[[Warns on inefficient use of STL algorithms on associative containers.]];
		};
		{
			"performance-inefficient-string-concatenation";
			[[This check warns about the performance overhead arising from concatenating strings using the operator+]];
		};
		{
			"performance-inefficient-vector-operation";
			[[Finds possible inefficient std::vector operations (e.g. push_back, emplace_back) that may cause unnecessary memory reallocations.]];
		};
		{
			"performance-move-const-arg";
			[[The check warns
  if std::move() is called with a constant argument,
  if std::move() is called with an argument of a trivially-copyable type,
  if the result of std::move() is passed as a const reference argument.
In all three cases, the check will suggest a fix that removes the std::move().]];
		};
		{
			"performance-move-constructor-init";
			[[The check flags user-defined move constructors that have a ctor-initializer initializing a member or base class through a copy constructor instead of a move constructor.]];
		};
		{
			"performance-no-automatic-move";
			[[Finds local variables that cannot be automatically moved due to constness.]];
		};
		{
			"performance-no-int-to-ptr";
			[[Diagnoses every integer to pointer cast.]];
		};
		{
			"performance-noexcept-move-constructor";
			[[The check flags user-defined move constructors and assignment operators not marked with noexcept or marked with noexcept(expr) where expr evaluates to false (but is not a false literal itself).]];
		};
		{
			"performance-trivially-destructible";
			[[Finds types that could be made trivially-destructible by removing out-of-line defaulted destructor declarations.]];
		};
		{
			"performance-type-promotion-in-math-fn";
			[[Finds calls to C math library functions (from math.h or, in C++, cmath) with implicit float to double promotions.]];
		};
		{
			"performance-unnecessary-copy-initialization";
			[[Finds local variable declarations that are initialized using the copy constructor of a non-trivially-copyable type but it would suffice to obtain a const reference.]];
		};
		{
			"performance-unnecessary-value-param";
			[[Flags value parameter declarations of expensive to copy types that are copied for each invocation but it would suffice to pass them by const reference.]];
		};
		{
			"portability-restrict-system-includes";
			[[Checks to selectively allow or disallow a configurable list of system headers.]];
		};
		{
			"portability-simd-intrinsics";
			[[Finds SIMD intrinsics calls and suggests std::experimental::simd alternatives.]];
		};
		{
			"portability-std-allocator-const";
			[[Report use of std::vector<const T> (and similar containers of const elements). These are not allowed in standard C++, and should usually be std::vector<T> instead.”]];
		};
		{
			"readability-avoid-const-params-in-decls";
			[[Checks whether a function declaration has parameters that are top level const.]];
		};
		{
			"readability-avoid-unconditional-preprocessor-if";
			[[Finds code blocks that are constantly enabled or disabled in preprocessor directives by analyzing #if conditions, such as #if 0 and #if 1, etc.]];
		};
		{
			"readability-braces-around-statements";
			[[Checks that bodies of if statements and loops (for, do while, and while) are inside braces.]];
		};
		{
			"readability-const-return-type";
			[[Checks for functions with a const-qualified return type and recommends removal of the const keyword. Such use of const is usually superfluous, and can prevent valuable compiler optimizations. Does not (yet) fix trailing return types.]];
		};
		{
			"readability-container-contains";
			[[Finds usages of container.count() and container.find() == container.end() which should be replaced by a call to the container.contains() method introduced in C++ 20.]];
		};
		{
			"readability-container-data-pointer";
			[[Finds cases where code could use data() rather than the address of the element at index 0 in a container. This pattern is commonly used to materialize a pointer to the backing data of a container. std::vector and std::string provide a data() accessor to retrieve the data pointer which should be preferred.]];
		};
		{
			"readability-container-size-empty";
			[[Checks whether a call to the size() method can be replaced with a call to empty().]];
		};
		{
			"readability-convert-member-functions-to-static";
			[[Finds non-static member functions that can be made static because the functions don’t use this.]];
		};
		{
			"readability-delete-null-pointer";
			[[Checks the if statements where a pointer’s existence is checked and then deletes the pointer. The check is unnecessary as deleting a null pointer has no effect.]];
		};
		{
			"readability-duplicate-include";
			[[Looks for duplicate includes and removes them. The check maintains a list of included files and looks for duplicates. If a macro is defined or undefined then the list of included files is cleared.]];
		};
		{
			"readability-else-after-return";
			[[LLVM Coding Standards advises to reduce indentation where possible and where it makes understanding code easier. Early exit is one of the suggested enforcements of that. Please do not use else or else if after something that interrupts control flow - like return, break, continue, throw.]];
		};
		{
			"readability-function-cognitive-complexity";
			[[Checks function Cognitive Complexity metric.]];
		};
		{
			"readability-function-size";
			[[Checks for large functions based on various metrics.]];
		};
		{
			"readability-identifier-length";
			[[This check finds variables and function parameters whose length are too short. The desired name length is configurable.]];
		};
		{
			"readability-identifier-naming";
			[[Checks for identifiers naming style mismatch.]];
		};
		{
			"readability-implicit-bool-conversion";
			[[This check can be used to find implicit conversions between built-in types and booleans. Depending on use case, it may simply help with readability of the code, or in some cases, point to potential bugs which remain unnoticed due to implicit conversions.]];
		};
		{
			"readability-inconsistent-declaration-parameter-name";
			[[Find function declarations which differ in parameter names.]];
		};
		{
			"readability-isolate-declaration";
			[[Detects local variable declarations declaring more than one variable and tries to refactor the code to one statement per declaration.]];
		};
		{
			"readability-magic-numbers";
			[[Detects magic numbers, integer or floating point literals that are embedded in code and not introduced via constants or symbols.]];
		};
		{
			"readability-make-member-function-const";
			[[Finds non-static member functions that can be made const because the functions don’t use this in a non-const way.]];
		};
		{
			"readability-misleading-indentation";
			[[Correct indentation helps to understand code. Mismatch of the syntactical structure and the indentation of the code may hide serious problems. Missing braces can also make it significantly harder to read the code, therefore it is important to use braces.]];
		};
		{
			"readability-misplaced-array-index";
			[[This check warns for unusual array index syntax.]];
		};
		{
			"readability-named-parameter";
			[[Find functions with unnamed arguments.]];
		};
		{
			"readability-non-const-parameter";
			[[The check finds function parameters of a pointer type that could be changed to point to a constant type instead.]];
		};
		{
			"readability-operators-representation";
			[[Enforces consistent token representation for invoked binary, unary and overloaded operators in C++ code. The check supports both traditional and alternative representations of operators, such as && and and, || and or, and so on.]];
		};
		{
			"readability-qualified-auto";
			[[Adds pointer qualifications to auto-typed variables that are deduced to pointers.]];
		};
		{
			"readability-redundant-access-specifiers";
			[[Finds classes, structs, and unions containing redundant member (field and method) access specifiers.]];
		};
		{
			"readability-redundant-control-flow";
			[[This check looks for procedures (functions returning no value) with return statements at the end of the function. Such return statements are redundant.]];
		};
		{
			"readability-redundant-declaration";
			[[Finds redundant variable and function declarations.]];
		};
		{
			"readability-redundant-function-ptr-dereference";
			[[Finds redundant dereferences of a function pointer.]];
		};
		{
			"readability-redundant-member-init";
			[[Finds member initializations that are unnecessary because the same default constructor would be called if they were not present.]];
		};
		{
			"readability-redundant-preprocessor";
			[[Finds potentially redundant preprocessor directives.]];
		};
		{
			"readability-redundant-smartptr-get";
			[[Find and remove redundant calls to smart pointer’s .get() method.]];
		};
		{
			"readability-redundant-string-cstr";
			[[Finds unnecessary calls to std::string::c_str() and std::string::data().]];
		};
		{
			"readability-redundant-string-init";
			[[Finds unnecessary string initializations.]];
		};
		{
			"readability-simplify-boolean-expr";
			[[Looks for boolean expressions involving boolean constants and simplifies them to use the appropriate boolean expression directly. Simplifies boolean expressions by application of DeMorgan’s Theorem.]];
		};
		{
			"readability-simplify-subscript-expr";
			[[This check simplifies subscript expressions. Currently this covers calling .data() and immediately doing an array subscript operation to obtain a single element, in which case simply calling operator[] suffice.]];
		};
		{
			"readability-static-accessed-through-instance";
			[[Checks for member expressions that access static members through instances, and replaces them with uses of the appropriate qualified-id.]];
		};
		{
			"readability-static-definition-in-anonymous-namespace";
			[[Finds static function and variable definitions in anonymous namespace.]];
		};
		{
			"readability-string-compare";
			[[Finds string comparisons using the compare method.]];
		};
		{
			"readability-suspicious-call-argument";
			[[Finds function calls where the arguments passed are provided out of order, based on the difference between the argument name and the parameter names of the function.]];
		};
		{
			"readability-uniqueptr-delete-release";
			[[Replace delete <unique_ptr>.release() with <unique_ptr> = nullptr. The latter is shorter, simpler and does not require use of raw pointer APIs.]];
		};
		{
			"readability-uppercase-literal-suffix";
			[[Detects when the integral literal or floating point (decimal or hexadecimal) literal has a non-uppercase suffix and provides a fix-it hint with the uppercase suffix.]];
		};
		{
			"readability-use-anyofallof";
			[[Finds range-based for loops that can be replaced by a call to std::any_of or std::all_of. In C++ 20 mode, suggests std::ranges::any_of or std::ranges::all_of.]];
		};
		{
			"zircon-temporary-objects";
			[[Warns on construction of specific temporary objects in the Zircon kernel. If the object should be flagged, If the object should be flagged, the fully qualified type name must be explicitly passed to the check.]];
		};
	};
};
