diff --git a/test/cfg/generated-cfg-tests-avr.cpp b/test/cfg/generated-cfg-tests-avr.cpp
index 701887680..82f50d807 100644
--- a/test/cfg/generated-cfg-tests-avr.cpp
+++ b/test/cfg/generated-cfg-tests-avr.cpp
@@ -8,800 +8,599 @@
 // => 'unmatched suppression' warnings are false negatives.
 //
 
-void test__toascii__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        toascii(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__toascii__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    toascii(p);
-    // cppcheck-suppress memleak
-}
-
-void test__vfprintf_P__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vfprintf_P(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__vfprintf_P__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vfprintf_P(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__vfprintf_P__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vfprintf_P(NULL, arg2);
-}
-
-void test__vfprintf_P__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    vfprintf_P(x, arg2);
-}
-
-void test__printf_P__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        printf_P(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__printf_P__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    printf_P(p);
-    // cppcheck-suppress memleak
-}
-
-void test__sprintf_P__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sprintf_P(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sprintf_P__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sprintf_P(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__snprintf_P__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        snprintf_P(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__snprintf_P__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    snprintf_P(p, arg2, arg3);
-    // cppcheck-suppress memleak
-}
-
-void test__vsprintf_P__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vsprintf_P(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__vsprintf_P__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vsprintf_P(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__vsnprintf_P__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vsnprintf_P(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__vsnprintf_P__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vsnprintf_P(p, arg2, arg3);
-    // cppcheck-suppress memleak
-}
-
-void test__fprintf_P__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fprintf_P(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__fprintf_P__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fprintf_P(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__fprintf_P__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fprintf_P(NULL, arg2);
-}
-
-void test__fprintf_P__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fprintf_P(x, arg2);
-}
-
-void test__fputs_P__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fputs_P(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__toascii__noreturn() {
+  int x = 1;
+  if (cond) { x=100; toascii(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__fputs_P__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fputs_P(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__fputs_P__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fputs_P(NULL, arg2);
-}
-
-void test__fputs_P__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fputs_P(x, arg2);
-}
-
-void test__fputs_P__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fputs_P(arg1, NULL);
+
+void test__toascii__leakignore() {
+  char *p = malloc(10); *p=0;
+  toascii(p);
+  // cppcheck-suppress memleak
+}
+
+void test__vfprintf_P__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vfprintf_P(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fputs_P__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fputs_P(arg1, x);
-}
-
-void test__puts_P__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        puts_P(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__vfprintf_P__leakignore() {
+  char *p = malloc(10); *p=0;
+  vfprintf_P(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__puts_P__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    puts_P(p);
-    // cppcheck-suppress memleak
-}
-
-void test__puts_P__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    puts_P(!x);
-}
-
-void test__puts_P__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    puts_P(NULL);
+void test__vfprintf_P__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vfprintf_P(NULL, arg2);
 }
 
-void test__puts_P__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    puts_P(x);
+void test__vfprintf_P__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vfprintf_P(x, arg2);
 }
 
-void test__scanf_P__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        scanf_P(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__printf_P__noreturn() {
+  int x = 1;
+  if (cond) { x=100; printf_P(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__scanf_P__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    scanf_P(p, arg2);
-    // cppcheck-suppress memleak
-}
+void test__printf_P__leakignore() {
+  char *p = malloc(10); *p=0;
+  printf_P(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sprintf_P__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sprintf_P(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__scanf_P__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    scanf_P(x, arg2);
+void test__sprintf_P__leakignore() {
+  char *p = malloc(10); *p=0;
+  sprintf_P(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__fscanf_P__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fscanf_P(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__snprintf_P__noreturn() {
+  int x = 1;
+  if (cond) { x=100; snprintf_P(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fscanf_P__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fscanf_P(p, arg2);
-    // cppcheck-suppress memleak
+void test__snprintf_P__leakignore() {
+  char *p = malloc(10); *p=0;
+  snprintf_P(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__fscanf_P__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fscanf_P(x, arg2);
+void test__vsprintf_P__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vsprintf_P(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sscanf_P__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sscanf_P(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__vsprintf_P__leakignore() {
+  char *p = malloc(10); *p=0;
+  vsprintf_P(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__sscanf_P__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sscanf_P(p, arg2);
-    // cppcheck-suppress memleak
+void test__vsnprintf_P__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vsnprintf_P(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fdevopen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fdevopen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__vsnprintf_P__leakignore() {
+  char *p = malloc(10); *p=0;
+  vsnprintf_P(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__fdevopen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fdevopen(NULL, arg2);
+void test__fprintf_P__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fprintf_P(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fdevopen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fdevopen(x, arg2);
+void test__fprintf_P__leakignore() {
+  char *p = malloc(10); *p=0;
+  fprintf_P(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__fdevopen__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fdevopen(arg1, NULL);
+void test__fprintf_P__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fprintf_P(NULL, arg2);
 }
 
-void test__fdevopen__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fdevopen(arg1, x);
+void test__fprintf_P__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fprintf_P(x, arg2);
 }
 
-void test__ltoa__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ltoa(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fputs_P__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fputs_P(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ltoa__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ltoa(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__fputs_P__leakignore() {
+  char *p = malloc(10); *p=0;
+  fputs_P(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__ltoa__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ltoa(x, arg2, arg3);
+void test__fputs_P__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fputs_P(NULL, arg2);
 }
 
-void test__ltoa__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ltoa(arg1, NULL, arg3);
+void test__fputs_P__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fputs_P(x, arg2);
 }
 
-void test__ltoa__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    ltoa(arg1, x, arg3);
+void test__fputs_P__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fputs_P(arg1, NULL);
 }
 
-void test__ltoa__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ltoa(arg1, arg2, NULL);
+void test__fputs_P__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fputs_P(arg1, x);
 }
 
-void test__ltoa__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    ltoa(arg1, arg2, x);
+void test__puts_P__noreturn() {
+  int x = 1;
+  if (cond) { x=100; puts_P(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__utoa__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        utoa(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__puts_P__leakignore() {
+  char *p = malloc(10); *p=0;
+  puts_P(p);
+  // cppcheck-suppress memleak
 }
 
-void test__utoa__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    utoa(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__puts_P__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  puts_P(!x);
 }
 
-void test__utoa__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    utoa(x, arg2, arg3);
+void test__puts_P__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  puts_P(NULL);
 }
 
-void test__utoa__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    utoa(arg1, NULL, arg3);
+void test__puts_P__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  puts_P(x);
 }
 
-void test__utoa__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    utoa(arg1, x, arg3);
+void test__scanf_P__noreturn() {
+  int x = 1;
+  if (cond) { x=100; scanf_P(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__utoa__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    utoa(arg1, arg2, NULL);
+void test__scanf_P__leakignore() {
+  char *p = malloc(10); *p=0;
+  scanf_P(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__utoa__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    utoa(arg1, arg2, x);
+void test__scanf_P__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  scanf_P(x, arg2);
 }
 
-void test__ultoa__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ultoa(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fscanf_P__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fscanf_P(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ultoa__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ultoa(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__fscanf_P__leakignore() {
+  char *p = malloc(10); *p=0;
+  fscanf_P(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__ultoa__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ultoa(x, arg2, arg3);
+void test__fscanf_P__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fscanf_P(x, arg2);
 }
 
-void test__ultoa__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ultoa(arg1, NULL, arg3);
+void test__sscanf_P__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sscanf_P(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ultoa__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    ultoa(arg1, x, arg3);
+void test__sscanf_P__leakignore() {
+  char *p = malloc(10); *p=0;
+  sscanf_P(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__ultoa__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ultoa(arg1, arg2, NULL);
+void test__fdevopen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fdevopen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ultoa__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    ultoa(arg1, arg2, x);
+void test__fdevopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fdevopen(NULL, arg2);
 }
 
-void test__random__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        random();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fdevopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fdevopen(x, arg2);
 }
 
-void test__random__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    random();
-    // cppcheck-suppress memleak
+void test__fdevopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fdevopen(arg1, NULL);
 }
 
-void test__random_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        random_r(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fdevopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fdevopen(arg1, x);
 }
 
-void test__random_r__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    random_r(p);
-    // cppcheck-suppress memleak
+void test__ltoa__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ltoa(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__random_r__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    random_r(NULL);
+void test__ltoa__leakignore() {
+  char *p = malloc(10); *p=0;
+  ltoa(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__srandom__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        srandom(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ltoa__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ltoa(x, arg2, arg3);
 }
 
-void test__srandom__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    srandom(p);
-    // cppcheck-suppress memleak
+void test__ltoa__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  ltoa(arg1, NULL, arg3);
 }
 
-void test__srandom__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    srandom(x);
+void test__ltoa__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ltoa(arg1, x, arg3);
 }
 
-void test__dtostre__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        dtostre(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__dtostre__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    dtostre(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__dtostre__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    dtostre(x, arg2);
-}
-
-void test__dtostre__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    dtostre(arg1, NULL);
-}
-
-void test__dtostrf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        dtostrf(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__dtostrf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    dtostrf(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
-}
-
-void test__dtostrf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    dtostrf(x, arg2, arg3, arg4);
+void test__ltoa__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  ltoa(arg1, arg2, NULL);
 }
 
-void test__dtostrf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    dtostrf(arg1, x, arg3, arg4);
-}
-
-void test__dtostrf__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    dtostrf(arg1, arg2, x, arg4);
-}
-
-void test__dtostrf__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    dtostrf(arg1, arg2, arg3, NULL);
-}
-
-void test__ffs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ffs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ltoa__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ltoa(arg1, arg2, x);
 }
 
-void test__ffs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ffs(p);
-    // cppcheck-suppress memleak
+void test__utoa__noreturn() {
+  int x = 1;
+  if (cond) { x=100; utoa(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ffs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ffs(x);
-}
-
-void test__ffsl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ffsl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__utoa__leakignore() {
+  char *p = malloc(10); *p=0;
+  utoa(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__ffsl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ffsl(p);
-    // cppcheck-suppress memleak
+void test__utoa__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  utoa(x, arg2, arg3);
 }
 
-void test__ffsl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ffsl(x);
-}
+void test__utoa__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  utoa(arg1, NULL, arg3);
+}
+
+void test__utoa__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  utoa(arg1, x, arg3);
+}
+
+void test__utoa__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  utoa(arg1, arg2, NULL);
+}
+
+void test__utoa__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  utoa(arg1, arg2, x);
+}
+
+void test__ultoa__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ultoa(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ultoa__leakignore() {
+  char *p = malloc(10); *p=0;
+  ultoa(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__ultoa__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ultoa(x, arg2, arg3);
+}
+
+void test__ultoa__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  ultoa(arg1, NULL, arg3);
+}
+
+void test__ultoa__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ultoa(arg1, x, arg3);
+}
+
+void test__ultoa__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  ultoa(arg1, arg2, NULL);
+}
+
+void test__ultoa__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ultoa(arg1, arg2, x);
+}
+
+void test__random__noreturn() {
+  int x = 1;
+  if (cond) { x=100; random(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__random__leakignore() {
+  char *p = malloc(10); *p=0;
+  random();
+  // cppcheck-suppress memleak
+}
+
+void test__random_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; random_r(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__random_r__leakignore() {
+  char *p = malloc(10); *p=0;
+  random_r(p);
+  // cppcheck-suppress memleak
+}
+
+void test__random_r__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  random_r(NULL);
+}
+
+void test__srandom__noreturn() {
+  int x = 1;
+  if (cond) { x=100; srandom(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__srandom__leakignore() {
+  char *p = malloc(10); *p=0;
+  srandom(p);
+  // cppcheck-suppress memleak
+}
+
+void test__srandom__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  srandom(x);
+}
+
+void test__dtostre__noreturn() {
+  int x = 1;
+  if (cond) { x=100; dtostre(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__dtostre__leakignore() {
+  char *p = malloc(10); *p=0;
+  dtostre(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__dtostre__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dtostre(x, arg2);
+}
+
+void test__dtostre__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  dtostre(arg1, NULL);
+}
+
+void test__dtostrf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; dtostrf(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__dtostrf__leakignore() {
+  char *p = malloc(10); *p=0;
+  dtostrf(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__dtostrf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dtostrf(x, arg2, arg3, arg4);
+}
+
+void test__dtostrf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dtostrf(arg1, x, arg3, arg4);
+}
+
+void test__dtostrf__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dtostrf(arg1, arg2, x, arg4);
+}
+
+void test__dtostrf__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  dtostrf(arg1, arg2, arg3, NULL);
+}
+
+void test__ffs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ffs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ffs__leakignore() {
+  char *p = malloc(10); *p=0;
+  ffs(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ffs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ffs(x);
+}
+
+void test__ffsl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ffsl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ffsl__leakignore() {
+  char *p = malloc(10); *p=0;
+  ffsl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ffsl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ffsl(x);
+}
+
+void test__ffsll__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ffsll(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ffsll__leakignore() {
+  char *p = malloc(10); *p=0;
+  ffsll(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ffsll__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ffsll(x);
+}
 
-void test__ffsll__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ffsll(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__memccpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; memccpy(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ffsll__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ffsll(p);
-    // cppcheck-suppress memleak
+void test__memccpy__leakignore() {
+  char *p = malloc(10); *p=0;
+  memccpy(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__ffsll__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ffsll(x);
+void test__memccpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  memccpy(NULL, arg2, arg3, arg4);
 }
 
-void test__memccpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        memccpy(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__memccpy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    memccpy(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
-}
-
-void test__memccpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    memccpy(NULL, arg2, arg3, arg4);
-}
-
-void test__memccpy__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    memccpy(arg1, x, arg3, arg4);
+void test__memccpy__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memccpy(arg1, x, arg3, arg4);
 }
 
-void test__memccpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    memccpy(arg1, arg2, x, arg4);
+void test__memccpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memccpy(arg1, arg2, x, arg4);
 }
 
-void test__memccpy__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    memccpy(arg1, arg2, arg3, x);
+void test__memccpy__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memccpy(arg1, arg2, arg3, x);
 }
 
diff --git a/test/cfg/generated-cfg-tests-bsd.cpp b/test/cfg/generated-cfg-tests-bsd.cpp
index 352add36c..c8144c317 100644
--- a/test/cfg/generated-cfg-tests-bsd.cpp
+++ b/test/cfg/generated-cfg-tests-bsd.cpp
@@ -8,324 +8,249 @@
 // => 'unmatched suppression' warnings are false negatives.
 //
 
-void test__fts_open__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fts_open(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fts_open__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fts_open(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fts_open__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fts_open(x, arg2, arg3);
+void test__fts_open__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fts_open(x, arg2, arg3);
 }
 
-void test__fts_open__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fts_open(arg1, x, arg3);
+void test__fts_open__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fts_open(arg1, x, arg3);
 }
 
-void test__fts_open__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fts_open(arg1, arg2, NULL);
+void test__fts_open__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  fts_open(arg1, arg2, NULL);
 }
 
-void test__fts_open__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fts_open(arg1, arg2, x);
+void test__fts_open__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fts_open(arg1, arg2, x);
 }
 
-void test__fts_read__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fts_read(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fts_read__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fts_read(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fts_read__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fts_read(NULL);
+void test__fts_read__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fts_read(NULL);
 }
 
-void test__fts_read__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fts_read(x);
+void test__fts_read__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fts_read(x);
 }
 
-void test__readpassphrase__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        readpassphrase(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__readpassphrase__noreturn() {
+  int x = 1;
+  if (cond) { x=100; readpassphrase(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__readpassphrase__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    readpassphrase(x, arg2);
+void test__readpassphrase__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  readpassphrase(x, arg2);
 }
 
-void test__readpassphrase__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    readpassphrase(arg1, x);
+void test__readpassphrase__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  readpassphrase(arg1, x);
 }
 
-void test__fts_set__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fts_set(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fts_set__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fts_set(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fts_set__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fts_set(x, arg2, arg3);
+void test__fts_set__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fts_set(x, arg2, arg3);
 }
 
-void test__fts_set__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fts_set(arg1, x, arg3);
+void test__fts_set__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fts_set(arg1, x, arg3);
 }
 
-void test__fts_set__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fts_set(arg1, arg2, x);
+void test__fts_set__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fts_set(arg1, arg2, x);
 }
 
-void test__fts_set_clientptr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fts_set_clientptr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fts_set_clientptr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fts_set_clientptr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fts_set_clientptr__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fts_set_clientptr(x, arg2);
+void test__fts_set_clientptr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fts_set_clientptr(x, arg2);
 }
 
-void test__fts_set_clientptr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fts_set_clientptr(arg1, x);
+void test__fts_set_clientptr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fts_set_clientptr(arg1, x);
 }
 
-void test__fts_get_clientptr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fts_get_clientptr(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fts_get_clientptr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fts_get_clientptr(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fts_get_clientptr__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fts_get_clientptr(x);
+void test__fts_get_clientptr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fts_get_clientptr(x);
 }
 
-void test__fts_get_stream__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fts_get_stream(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fts_get_stream__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fts_get_stream(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fts_get_stream__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fts_get_stream(x);
+void test__fts_get_stream__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fts_get_stream(x);
 }
 
-void test__fts_close__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fts_close(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fts_close__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fts_close(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fts_close__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fts_close(x);
+void test__fts_close__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fts_close(x);
 }
 
-void test__readpassphrase__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        readpassphrase(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__readpassphrase__noreturn() {
+  int x = 1;
+  if (cond) { x=100; readpassphrase(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__readpassphrase__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    readpassphrase(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__readpassphrase__leakignore() {
+  char *p = malloc(10); *p=0;
+  readpassphrase(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__readpassphrase__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    readpassphrase(x, arg2, arg3, arg4);
+void test__readpassphrase__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  readpassphrase(x, arg2, arg3, arg4);
 }
 
-void test__readpassphrase__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    readpassphrase(arg1, NULL, arg3, arg4);
+void test__readpassphrase__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  readpassphrase(arg1, NULL, arg3, arg4);
 }
 
-void test__readpassphrase__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    readpassphrase(arg1, arg2, NULL, arg4);
+void test__readpassphrase__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  readpassphrase(arg1, arg2, NULL, arg4);
 }
 
-void test__readpassphrase__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    readpassphrase(arg1, arg2, x, arg4);
+void test__readpassphrase__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  readpassphrase(arg1, arg2, x, arg4);
 }
 
-void test__readpassphrase__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    readpassphrase(arg1, arg2, arg3, x);
+void test__readpassphrase__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  readpassphrase(arg1, arg2, arg3, x);
 }
 
-void test__setfib__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setfib(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__setfib__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setfib(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__setfib__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setfib(x);
+void test__setfib__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setfib(x);
 }
 
-void test__strtonum__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strtonum(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strtonum__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strtonum(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strtonum__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strtonum(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__strtonum__leakignore() {
+  char *p = malloc(10); *p=0;
+  strtonum(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__strtonum__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strtonum(NULL, arg2, arg3, arg4);
+void test__strtonum__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtonum(NULL, arg2, arg3, arg4);
 }
 
-void test__strtonum__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strtonum(x, arg2, arg3, arg4);
+void test__strtonum__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtonum(x, arg2, arg3, arg4);
 }
 
-void test__strtonum__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strtonum(arg1, x, arg3, arg4);
+void test__strtonum__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtonum(arg1, x, arg3, arg4);
 }
 
-void test__strtonum__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strtonum(arg1, arg2, x, arg4);
+void test__strtonum__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtonum(arg1, arg2, x, arg4);
 }
 
-void test__strtonum__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strtonum(arg1, arg2, arg3, x);
+void test__strtonum__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtonum(arg1, arg2, arg3, x);
 }
 
diff --git a/test/cfg/generated-cfg-tests-gnu.cpp b/test/cfg/generated-cfg-tests-gnu.cpp
index e19dd31a9..7384d0459 100644
--- a/test/cfg/generated-cfg-tests-gnu.cpp
+++ b/test/cfg/generated-cfg-tests-gnu.cpp
@@ -8,1915 +8,1494 @@
 // => 'unmatched suppression' warnings are false negatives.
 //
 
-void test__accept__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        accept(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__accept__noreturn() {
+  int x = 1;
+  if (cond) { x=100; accept(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__accept__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    accept(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__accept__leakignore() {
+  char *p = malloc(10); *p=0;
+  accept(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__accept__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    accept(x, arg2, arg3, arg4);
+void test__accept__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  accept(x, arg2, arg3, arg4);
 }
 
-void test__accept__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    accept(arg1, x, arg3, arg4);
+void test__accept__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  accept(arg1, x, arg3, arg4);
 }
 
-void test__accept__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    accept(arg1, arg2, NULL, arg4);
+void test__accept__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  accept(arg1, arg2, NULL, arg4);
 }
 
-void test__accept__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    accept(arg1, arg2, x, arg4);
+void test__accept__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  accept(arg1, arg2, x, arg4);
 }
 
-void test__accept__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    accept(arg1, arg2, arg3, x);
+void test__accept__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  accept(arg1, arg2, arg3, x);
 }
 
-void test__atoq__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = atoq(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__atoq__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = atoq(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atoq__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    atoq(arg1);
+void test__atoq__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  atoq(arg1);
 }
 
-void test__atoq__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = atoq(NULL);
+void test__atoq__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = atoq(NULL);
 }
 
-void test__atoq__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = atoq(x);
+void test__atoq__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = atoq(x);
 }
 
-void test__strndupa__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strndupa(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strndupa__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strndupa(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strndupa__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strndupa(arg1, arg2);
+void test__strndupa__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strndupa(arg1, arg2);
 }
 
-void test__strndupa__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strndupa(NULL, arg2);
+void test__strndupa__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strndupa(NULL, arg2);
 }
 
-void test__strndupa__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strndupa(x, arg2);
+void test__strndupa__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strndupa(x, arg2);
 }
 
-void test__strndupa__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = strndupa(arg1, x);
+void test__strndupa__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strndupa(arg1, x);
 }
 
-void test__strsep__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strsep(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strsep__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strsep(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strsep__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strsep(arg1, arg2);
+void test__strsep__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strsep(arg1, arg2);
 }
 
-void test__strsep__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = strsep(x, arg2);
+void test__strsep__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strsep(x, arg2);
 }
 
-void test__strsep__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strsep(arg1, NULL);
+void test__strsep__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strsep(arg1, NULL);
 }
 
-void test__strsep__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strsep(arg1, x);
+void test__strsep__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strsep(arg1, x);
 }
 
-void test__strdupa__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strdupa(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strdupa__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strdupa(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strdupa__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strdupa(arg1);
+void test__strdupa__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strdupa(arg1);
 }
 
-void test__strdupa__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strdupa(NULL);
+void test__strdupa__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strdupa(NULL);
 }
 
-void test__strdupa__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strdupa(x);
+void test__strdupa__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strdupa(x);
 }
 
-void test__backtrace__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        backtrace(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__backtrace__noreturn() {
+  int x = 1;
+  if (cond) { x=100; backtrace(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__backtrace__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    backtrace(NULL, arg2);
+void test__backtrace__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  backtrace(NULL, arg2);
 }
 
-void test__backtrace__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    backtrace(arg1, x);
+void test__backtrace__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  backtrace(arg1, x);
 }
 
-void test__backtrace_symbols__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = backtrace_symbols(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__backtrace_symbols__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = backtrace_symbols(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__backtrace_symbols__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    backtrace_symbols(arg1, arg2);
+void test__backtrace_symbols__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  backtrace_symbols(arg1, arg2);
 }
 
-void test__backtrace_symbols__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = backtrace_symbols(NULL, arg2);
+void test__backtrace_symbols__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = backtrace_symbols(NULL, arg2);
 }
 
-void test__backtrace_symbols__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = backtrace_symbols(x, arg2);
+void test__backtrace_symbols__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = backtrace_symbols(x, arg2);
 }
 
-void test__backtrace_symbols__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = backtrace_symbols(arg1, x);
+void test__backtrace_symbols__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = backtrace_symbols(arg1, x);
 }
 
-void test__backtrace_symbols_fd__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        backtrace_symbols_fd(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__backtrace_symbols_fd__noreturn() {
+  int x = 1;
+  if (cond) { x=100; backtrace_symbols_fd(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__backtrace_symbols_fd__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    backtrace_symbols_fd(NULL, arg2, arg3);
+void test__backtrace_symbols_fd__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  backtrace_symbols_fd(NULL, arg2, arg3);
 }
 
-void test__backtrace_symbols_fd__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    backtrace_symbols_fd(x, arg2, arg3);
+void test__backtrace_symbols_fd__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  backtrace_symbols_fd(x, arg2, arg3);
 }
 
-void test__backtrace_symbols_fd__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    backtrace_symbols_fd(arg1, x, arg3);
+void test__backtrace_symbols_fd__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  backtrace_symbols_fd(arg1, x, arg3);
 }
 
-void test__backtrace_symbols_fd__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    backtrace_symbols_fd(arg1, arg2, x);
+void test__backtrace_symbols_fd__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  backtrace_symbols_fd(arg1, arg2, x);
 }
 
-void test__ecvt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ecvt(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ecvt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ecvt(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ecvt__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ecvt(x, arg2, arg3, arg4);
+void test__ecvt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ecvt(x, arg2, arg3, arg4);
 }
 
-void test__ecvt__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ecvt(arg1, x, arg3, arg4);
+void test__ecvt__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ecvt(arg1, x, arg3, arg4);
 }
 
-void test__ecvt__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ecvt(arg1, arg2, NULL, arg4);
+void test__ecvt__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  ecvt(arg1, arg2, NULL, arg4);
 }
 
-void test__ecvt__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ecvt(arg1, arg2, arg3, NULL);
+void test__ecvt__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  ecvt(arg1, arg2, arg3, NULL);
 }
 
-void test__qfcvt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        qfcvt(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__qfcvt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; qfcvt(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__qfcvt__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    qfcvt(x, arg2, arg3, arg4);
+void test__qfcvt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qfcvt(x, arg2, arg3, arg4);
 }
 
-void test__qfcvt__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    qfcvt(arg1, x, arg3, arg4);
+void test__qfcvt__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qfcvt(arg1, x, arg3, arg4);
 }
 
-void test__qfcvt__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    qfcvt(arg1, arg2, NULL, arg4);
+void test__qfcvt__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  qfcvt(arg1, arg2, NULL, arg4);
 }
 
-void test__qfcvt__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    qfcvt(arg1, arg2, arg3, NULL);
+void test__qfcvt__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  qfcvt(arg1, arg2, arg3, NULL);
 }
 
-void test__qgcvt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        qgcvt(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__qgcvt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; qgcvt(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__qgcvt__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    qgcvt(x, arg2, arg3);
+void test__qgcvt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qgcvt(x, arg2, arg3);
 }
 
-void test__qgcvt__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    qgcvt(arg1, x, arg3);
+void test__qgcvt__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qgcvt(arg1, x, arg3);
 }
 
-void test__qgcvt__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    qgcvt(arg1, arg2, NULL);
+void test__qgcvt__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  qgcvt(arg1, arg2, NULL);
 }
 
-void test__ecvt_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ecvt_r(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ecvt_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ecvt_r(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ecvt_r__pure(int arg1,int arg2,int arg3,int arg4,int arg5,int arg6)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ecvt_r(arg1, arg2, arg3, arg4, arg5, arg6) > 10) || (ecvt_r(arg1, arg2, arg3, arg4, arg5, arg6) < 100)) {}
+void test__ecvt_r__pure(int arg1,int arg2,int arg3,int arg4,int arg5,int arg6) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ecvt_r(arg1, arg2, arg3, arg4, arg5, arg6) > 10) || (ecvt_r(arg1, arg2, arg3, arg4, arg5, arg6) < 100)) {}
 }
 
-void test__ecvt_r__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ecvt_r(x, arg2, arg3, arg4, arg5, arg6);
+void test__ecvt_r__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ecvt_r(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__ecvt_r__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ecvt_r(arg1, x, arg3, arg4, arg5, arg6);
+void test__ecvt_r__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ecvt_r(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__ecvt_r__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ecvt_r(arg1, arg2, NULL, arg4, arg5, arg6);
+void test__ecvt_r__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  ecvt_r(arg1, arg2, NULL, arg4, arg5, arg6);
 }
 
-void test__ecvt_r__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ecvt_r(arg1, arg2, arg3, NULL, arg5, arg6);
+void test__ecvt_r__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  ecvt_r(arg1, arg2, arg3, NULL, arg5, arg6);
 }
 
-void test__ecvt_r__arg5__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ecvt_r(arg1, arg2, arg3, arg4, NULL, arg6);
+void test__ecvt_r__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  ecvt_r(arg1, arg2, arg3, arg4, NULL, arg6);
 }
 
-void test__ecvt_r__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ecvt_r(arg1, arg2, arg3, arg4, arg5, x);
+void test__ecvt_r__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ecvt_r(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__fcvt_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fcvt_r(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fcvt_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fcvt_r(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fcvt_r__pure(int arg1,int arg2,int arg3,int arg4,int arg5,int arg6)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fcvt_r(arg1, arg2, arg3, arg4, arg5, arg6) > 10) || (fcvt_r(arg1, arg2, arg3, arg4, arg5, arg6) < 100)) {}
+void test__fcvt_r__pure(int arg1,int arg2,int arg3,int arg4,int arg5,int arg6) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fcvt_r(arg1, arg2, arg3, arg4, arg5, arg6) > 10) || (fcvt_r(arg1, arg2, arg3, arg4, arg5, arg6) < 100)) {}
 }
 
-void test__fcvt_r__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fcvt_r(x, arg2, arg3, arg4, arg5, arg6);
+void test__fcvt_r__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fcvt_r(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__fcvt_r__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fcvt_r(arg1, x, arg3, arg4, arg5, arg6);
+void test__fcvt_r__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fcvt_r(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__fcvt_r__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fcvt_r(arg1, arg2, NULL, arg4, arg5, arg6);
+void test__fcvt_r__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  fcvt_r(arg1, arg2, NULL, arg4, arg5, arg6);
 }
 
-void test__fcvt_r__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fcvt_r(arg1, arg2, arg3, NULL, arg5, arg6);
+void test__fcvt_r__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  fcvt_r(arg1, arg2, arg3, NULL, arg5, arg6);
 }
 
-void test__fcvt_r__arg5__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fcvt_r(arg1, arg2, arg3, arg4, NULL, arg6);
+void test__fcvt_r__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  fcvt_r(arg1, arg2, arg3, arg4, NULL, arg6);
 }
 
-void test__fcvt_r__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fcvt_r(arg1, arg2, arg3, arg4, arg5, x);
+void test__fcvt_r__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fcvt_r(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__qecvt_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        qecvt_r(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__qecvt_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; qecvt_r(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__qecvt_r__pure(int arg1,int arg2,int arg3,int arg4,int arg5,int arg6)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((qecvt_r(arg1, arg2, arg3, arg4, arg5, arg6) > 10) || (qecvt_r(arg1, arg2, arg3, arg4, arg5, arg6) < 100)) {}
+void test__qecvt_r__pure(int arg1,int arg2,int arg3,int arg4,int arg5,int arg6) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((qecvt_r(arg1, arg2, arg3, arg4, arg5, arg6) > 10) || (qecvt_r(arg1, arg2, arg3, arg4, arg5, arg6) < 100)) {}
 }
 
-void test__qecvt_r__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    qecvt_r(x, arg2, arg3, arg4, arg5, arg6);
+void test__qecvt_r__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qecvt_r(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__qecvt_r__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    qecvt_r(arg1, x, arg3, arg4, arg5, arg6);
+void test__qecvt_r__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qecvt_r(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__qecvt_r__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    qecvt_r(arg1, arg2, NULL, arg4, arg5, arg6);
+void test__qecvt_r__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  qecvt_r(arg1, arg2, NULL, arg4, arg5, arg6);
 }
 
-void test__qecvt_r__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    qecvt_r(arg1, arg2, arg3, NULL, arg5, arg6);
+void test__qecvt_r__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  qecvt_r(arg1, arg2, arg3, NULL, arg5, arg6);
 }
 
-void test__qecvt_r__arg5__notnull()
-{
-    // cppcheck-suppress nullPointer
-    qecvt_r(arg1, arg2, arg3, arg4, NULL, arg6);
+void test__qecvt_r__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  qecvt_r(arg1, arg2, arg3, arg4, NULL, arg6);
 }
 
-void test__qecvt_r__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    qecvt_r(arg1, arg2, arg3, arg4, arg5, x);
+void test__qecvt_r__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qecvt_r(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__qfcvt_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        qfcvt_r(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__qfcvt_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; qfcvt_r(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__qfcvt_r__pure(int arg1,int arg2,int arg3,int arg4,int arg5,int arg6)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((qfcvt_r(arg1, arg2, arg3, arg4, arg5, arg6) > 10) || (qfcvt_r(arg1, arg2, arg3, arg4, arg5, arg6) < 100)) {}
+void test__qfcvt_r__pure(int arg1,int arg2,int arg3,int arg4,int arg5,int arg6) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((qfcvt_r(arg1, arg2, arg3, arg4, arg5, arg6) > 10) || (qfcvt_r(arg1, arg2, arg3, arg4, arg5, arg6) < 100)) {}
 }
 
-void test__qfcvt_r__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    qfcvt_r(x, arg2, arg3, arg4, arg5, arg6);
+void test__qfcvt_r__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qfcvt_r(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__qfcvt_r__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    qfcvt_r(arg1, x, arg3, arg4, arg5, arg6);
+void test__qfcvt_r__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qfcvt_r(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__qfcvt_r__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    qfcvt_r(arg1, arg2, NULL, arg4, arg5, arg6);
+void test__qfcvt_r__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  qfcvt_r(arg1, arg2, NULL, arg4, arg5, arg6);
 }
 
-void test__qfcvt_r__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    qfcvt_r(arg1, arg2, arg3, NULL, arg5, arg6);
+void test__qfcvt_r__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  qfcvt_r(arg1, arg2, arg3, NULL, arg5, arg6);
 }
 
-void test__qfcvt_r__arg5__notnull()
-{
-    // cppcheck-suppress nullPointer
-    qfcvt_r(arg1, arg2, arg3, arg4, NULL, arg6);
+void test__qfcvt_r__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  qfcvt_r(arg1, arg2, arg3, arg4, NULL, arg6);
 }
 
-void test__qfcvt_r__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    qfcvt_r(arg1, arg2, arg3, arg4, arg5, x);
+void test__qfcvt_r__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qfcvt_r(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__strcasestr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strcasestr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strcasestr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strcasestr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strcasestr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strcasestr(arg1, arg2);
+void test__strcasestr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strcasestr(arg1, arg2);
 }
 
-void test__strcasestr__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((strcasestr(arg1, arg2) > 10) || (strcasestr(arg1, arg2) < 100)) {}
+void test__strcasestr__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strcasestr(arg1, arg2) > 10) || (strcasestr(arg1, arg2) < 100)) {}
 }
 
-void test__strcasestr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = strcasestr(p, arg2);
-    // cppcheck-suppress memleak
+void test__strcasestr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = strcasestr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__strcasestr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strcasestr(NULL, arg2);
+void test__strcasestr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strcasestr(NULL, arg2);
 }
 
-void test__strcasestr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strcasestr(x, arg2);
+void test__strcasestr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strcasestr(x, arg2);
 }
 
-void test__strcasestr__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strcasestr(arg1, NULL);
+void test__strcasestr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strcasestr(arg1, NULL);
 }
 
-void test__strcasestr__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strcasestr(arg1, x);
+void test__strcasestr__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strcasestr(arg1, x);
 }
 
-void test__getresuid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getresuid(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getresuid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getresuid(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getresuid__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((getresuid(arg1, arg2, arg3) > 10) || (getresuid(arg1, arg2, arg3) < 100)) {}
+void test__getresuid__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((getresuid(arg1, arg2, arg3) > 10) || (getresuid(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__getresuid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getresuid(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__getresuid__leakignore() {
+  char *p = malloc(10); *p=0;
+  getresuid(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__getresuid__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getresuid(NULL, arg2, arg3);
+void test__getresuid__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getresuid(NULL, arg2, arg3);
 }
 
-void test__getresuid__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getresuid(arg1, NULL, arg3);
+void test__getresuid__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getresuid(arg1, NULL, arg3);
 }
 
-void test__getresuid__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getresuid(arg1, arg2, NULL);
+void test__getresuid__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  getresuid(arg1, arg2, NULL);
 }
 
-void test__getresgid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getresgid(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getresgid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getresgid(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getresgid__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((getresgid(arg1, arg2, arg3) > 10) || (getresgid(arg1, arg2, arg3) < 100)) {}
+void test__getresgid__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((getresgid(arg1, arg2, arg3) > 10) || (getresgid(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__getresgid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getresgid(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__getresgid__leakignore() {
+  char *p = malloc(10); *p=0;
+  getresgid(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__getresgid__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getresgid(NULL, arg2, arg3);
+void test__getresgid__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getresgid(NULL, arg2, arg3);
 }
 
-void test__getresgid__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getresgid(arg1, NULL, arg3);
+void test__getresgid__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getresgid(arg1, NULL, arg3);
 }
 
-void test__getresgid__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getresgid(arg1, arg2, NULL);
+void test__getresgid__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  getresgid(arg1, arg2, NULL);
 }
 
-void test__setresuid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setresuid(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__setresuid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setresuid(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__setresuid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setresuid(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__setresuid__leakignore() {
+  char *p = malloc(10); *p=0;
+  setresuid(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__setresuid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setresuid(x, arg2, arg3);
+void test__setresuid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setresuid(x, arg2, arg3);
 }
 
-void test__setresuid__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setresuid(arg1, x, arg3);
+void test__setresuid__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setresuid(arg1, x, arg3);
 }
 
-void test__setresuid__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setresuid(arg1, arg2, x);
+void test__setresuid__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setresuid(arg1, arg2, x);
 }
 
-void test__setresgid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setresgid(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__setresgid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setresgid(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__setresgid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setresgid(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__setresgid__leakignore() {
+  char *p = malloc(10); *p=0;
+  setresgid(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__setresgid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setresgid(x, arg2, arg3);
+void test__setresgid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setresgid(x, arg2, arg3);
 }
 
-void test__setresgid__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setresgid(arg1, x, arg3);
+void test__setresgid__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setresgid(arg1, x, arg3);
 }
 
-void test__setresgid__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setresgid(arg1, arg2, x);
+void test__setresgid__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setresgid(arg1, arg2, x);
 }
 
-void test__inet_aton__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        inet_aton(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__inet_aton__noreturn() {
+  int x = 1;
+  if (cond) { x=100; inet_aton(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__inet_aton__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    inet_aton(p, arg2);
-    // cppcheck-suppress memleak
+void test__inet_aton__leakignore() {
+  char *p = malloc(10); *p=0;
+  inet_aton(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__inet_aton__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    inet_aton(NULL, arg2);
+void test__inet_aton__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  inet_aton(NULL, arg2);
 }
 
-void test__inet_aton__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    inet_aton(x, arg2);
+void test__inet_aton__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  inet_aton(x, arg2);
 }
 
-void test__inet_aton__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    inet_aton(arg1, NULL);
+void test__inet_aton__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  inet_aton(arg1, NULL);
 }
 
-void test__inet_addr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        inet_addr(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__inet_addr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; inet_addr(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__inet_addr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    inet_addr(p);
-    // cppcheck-suppress memleak
+void test__inet_addr__leakignore() {
+  char *p = malloc(10); *p=0;
+  inet_addr(p);
+  // cppcheck-suppress memleak
 }
 
-void test__inet_addr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    inet_addr(NULL);
+void test__inet_addr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  inet_addr(NULL);
 }
 
-void test__inet_addr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    inet_addr(x);
+void test__inet_addr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  inet_addr(x);
 }
 
-void test__inet_network__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        inet_network(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__inet_network__noreturn() {
+  int x = 1;
+  if (cond) { x=100; inet_network(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__inet_network__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    inet_network(p);
-    // cppcheck-suppress memleak
+void test__inet_network__leakignore() {
+  char *p = malloc(10); *p=0;
+  inet_network(p);
+  // cppcheck-suppress memleak
 }
 
-void test__inet_network__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    inet_network(NULL);
-}
-
-void test__inet_network__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    inet_network(x);
-}
-
-void test__inet_ntoa__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        inet_ntoa(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__inet_network__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  inet_network(NULL);
+}
+
+void test__inet_network__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  inet_network(x);
+}
+
+void test__inet_ntoa__noreturn() {
+  int x = 1;
+  if (cond) { x=100; inet_ntoa(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__inet_ntoa__leakignore() {
+  char *p = malloc(10); *p=0;
+  inet_ntoa(p);
+  // cppcheck-suppress memleak
+}
+
+void test__inet_ntoa__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  inet_ntoa(x);
+}
+
+void test__inet_makeaddr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; inet_makeaddr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__inet_makeaddr__leakignore() {
+  char *p = malloc(10); *p=0;
+  inet_makeaddr(p, arg2);
+  // cppcheck-suppress memleak
+}
 
-void test__inet_ntoa__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    inet_ntoa(p);
-    // cppcheck-suppress memleak
-}
-
-void test__inet_ntoa__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    inet_ntoa(x);
-}
-
-void test__inet_makeaddr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        inet_makeaddr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__inet_makeaddr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    inet_makeaddr(p, arg2);
-    // cppcheck-suppress memleak
+void test__inet_makeaddr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  inet_makeaddr(x, arg2);
 }
 
-void test__inet_makeaddr__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    inet_makeaddr(x, arg2);
+void test__inet_makeaddr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  inet_makeaddr(arg1, x);
 }
 
-void test__inet_makeaddr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    inet_makeaddr(arg1, x);
+void test__inet_lnaof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; inet_lnaof(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__inet_lnaof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        inet_lnaof(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__inet_lnaof__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    inet_lnaof(p);
-    // cppcheck-suppress memleak
+void test__inet_lnaof__leakignore() {
+  char *p = malloc(10); *p=0;
+  inet_lnaof(p);
+  // cppcheck-suppress memleak
 }
 
-void test__inet_lnaof__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    inet_lnaof(x);
+void test__inet_lnaof__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  inet_lnaof(x);
 }
 
-void test__inet_netof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        inet_netof(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__inet_netof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; inet_netof(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__inet_netof__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    inet_netof(p);
-    // cppcheck-suppress memleak
+void test__inet_netof__leakignore() {
+  char *p = malloc(10); *p=0;
+  inet_netof(p);
+  // cppcheck-suppress memleak
 }
 
-void test__inet_netof__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    inet_netof(x);
+void test__inet_netof__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  inet_netof(x);
 }
 
-void test__inet_pton__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        inet_pton(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__inet_pton__noreturn() {
+  int x = 1;
+  if (cond) { x=100; inet_pton(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__inet_pton__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    inet_pton(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__inet_pton__leakignore() {
+  char *p = malloc(10); *p=0;
+  inet_pton(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__inet_pton__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    inet_pton(x, arg2, arg3);
+void test__inet_pton__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  inet_pton(x, arg2, arg3);
 }
 
-void test__inet_pton__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    inet_pton(arg1, NULL, arg3);
+void test__inet_pton__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  inet_pton(arg1, NULL, arg3);
 }
 
-void test__inet_pton__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    inet_pton(arg1, x, arg3);
+void test__inet_pton__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  inet_pton(arg1, x, arg3);
 }
 
-void test__inet_pton__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    inet_pton(arg1, arg2, NULL);
+void test__inet_pton__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  inet_pton(arg1, arg2, NULL);
 }
 
-void test__inet_ntop__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        inet_ntop(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__inet_ntop__noreturn() {
+  int x = 1;
+  if (cond) { x=100; inet_ntop(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__inet_ntop__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    inet_ntop(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__inet_ntop__leakignore() {
+  char *p = malloc(10); *p=0;
+  inet_ntop(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__inet_ntop__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    inet_ntop(x, arg2, arg3, arg4);
+void test__inet_ntop__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  inet_ntop(x, arg2, arg3, arg4);
 }
 
-void test__inet_ntop__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    inet_ntop(arg1, NULL, arg3, arg4);
+void test__inet_ntop__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  inet_ntop(arg1, NULL, arg3, arg4);
 }
 
-void test__inet_ntop__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    inet_ntop(arg1, x, arg3, arg4);
+void test__inet_ntop__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  inet_ntop(arg1, x, arg3, arg4);
 }
 
-void test__inet_ntop__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    inet_ntop(arg1, arg2, NULL, arg4);
+void test__inet_ntop__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  inet_ntop(arg1, arg2, NULL, arg4);
 }
 
-void test__inet_ntop__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    inet_ntop(arg1, arg2, arg3, x);
+void test__inet_ntop__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  inet_ntop(arg1, arg2, arg3, x);
 }
 
-void test__canonicalize_file_name__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = canonicalize_file_name(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__canonicalize_file_name__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = canonicalize_file_name(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__canonicalize_file_name__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    canonicalize_file_name(arg1);
+void test__canonicalize_file_name__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  canonicalize_file_name(arg1);
 }
 
-void test__canonicalize_file_name__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = canonicalize_file_name(p);
-    // cppcheck-suppress memleak
+void test__canonicalize_file_name__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = canonicalize_file_name(p);
+  // cppcheck-suppress memleak
 }
 
-void test__canonicalize_file_name__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = canonicalize_file_name(NULL);
+void test__canonicalize_file_name__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = canonicalize_file_name(NULL);
 }
 
-void test__execvpe__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        execvpe(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__execvpe__noreturn() {
+  int x = 1;
+  if (cond) { x=100; execvpe(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__execvpe__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    execvpe(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__execvpe__leakignore() {
+  char *p = malloc(10); *p=0;
+  execvpe(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__execvpe__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    execvpe(NULL, arg2, arg3);
+void test__execvpe__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  execvpe(NULL, arg2, arg3);
 }
 
-void test__execvpe__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    execvpe(x, arg2, arg3);
+void test__execvpe__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  execvpe(x, arg2, arg3);
 }
 
-void test__execvpe__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    execvpe(arg1, x, arg3);
+void test__execvpe__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  execvpe(arg1, x, arg3);
 }
 
-void test__execvpe__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    execvpe(arg1, arg2, x);
+void test__execvpe__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  execvpe(arg1, arg2, x);
 }
 
-void test__mkostemp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mkostemp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mkostemp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mkostemp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mkostemp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mkostemp(p, arg2);
-    // cppcheck-suppress memleak
+void test__mkostemp__leakignore() {
+  char *p = malloc(10); *p=0;
+  mkostemp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__mkostemp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mkostemp(NULL, arg2);
+void test__mkostemp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mkostemp(NULL, arg2);
 }
 
-void test__mkostemp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    mkostemp(x, arg2);
+void test__mkostemp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mkostemp(x, arg2);
 }
 
-void test__mkostemp__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mkostemp(arg1, x);
+void test__mkostemp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mkostemp(arg1, x);
 }
 
-void test__mkstemps__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mkstemps(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mkstemps__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mkstemps(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mkstemps__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mkstemps(p, arg2);
-    // cppcheck-suppress memleak
+void test__mkstemps__leakignore() {
+  char *p = malloc(10); *p=0;
+  mkstemps(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__mkstemps__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mkstemps(NULL, arg2);
+void test__mkstemps__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mkstemps(NULL, arg2);
 }
 
-void test__mkstemps__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    mkstemps(x, arg2);
+void test__mkstemps__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mkstemps(x, arg2);
 }
 
-void test__mkstemps__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mkstemps(arg1, x);
+void test__mkstemps__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mkstemps(arg1, x);
 }
 
-void test__mkostemps__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mkostemps(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mkostemps__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mkostemps(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mkostemps__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mkostemps(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__mkostemps__leakignore() {
+  char *p = malloc(10); *p=0;
+  mkostemps(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__mkostemps__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mkostemps(NULL, arg2, arg3);
+void test__mkostemps__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mkostemps(NULL, arg2, arg3);
 }
 
-void test__mkostemps__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    mkostemps(x, arg2, arg3);
+void test__mkostemps__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mkostemps(x, arg2, arg3);
 }
 
-void test__mkostemps__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mkostemps(arg1, x, arg3);
+void test__mkostemps__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mkostemps(arg1, x, arg3);
 }
 
-void test__mkostemps__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mkostemps(arg1, arg2, x);
+void test__mkostemps__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mkostemps(arg1, arg2, x);
 }
 
-void test__memmem__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = memmem(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__memmem__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = memmem(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__memmem__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    memmem(arg1, arg2, arg3, arg4);
+void test__memmem__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  memmem(arg1, arg2, arg3, arg4);
 }
 
-void test__memmem__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = memmem(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__memmem__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = memmem(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__memmem__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = memmem(NULL, arg2, arg3, arg4);
+void test__memmem__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = memmem(NULL, arg2, arg3, arg4);
 }
 
-void test__memmem__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = memmem(x, arg2, arg3, arg4);
+void test__memmem__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = memmem(x, arg2, arg3, arg4);
 }
 
-void test__memmem__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = memmem(arg1, x, arg3, arg4);
+void test__memmem__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = memmem(arg1, x, arg3, arg4);
 }
 
-void test__memmem__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = memmem(arg1, arg2, NULL, arg4);
+void test__memmem__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = memmem(arg1, arg2, NULL, arg4);
 }
 
-void test__memmem__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = memmem(arg1, arg2, x, arg4);
+void test__memmem__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = memmem(arg1, arg2, x, arg4);
 }
 
-void test__memmem__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = memmem(arg1, arg2, arg3, x);
+void test__memmem__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = memmem(arg1, arg2, arg3, x);
 }
 
-void test__memrchr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        memrchr(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__memrchr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; memrchr(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__memrchr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    memrchr(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__memrchr__leakignore() {
+  char *p = malloc(10); *p=0;
+  memrchr(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__memrchr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    memrchr(NULL, arg2, arg3);
+void test__memrchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  memrchr(NULL, arg2, arg3);
 }
 
-void test__memrchr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    memrchr(x, arg2, arg3);
+void test__memrchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  memrchr(x, arg2, arg3);
 }
 
-void test__memrchr__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    memrchr(arg1, !x, arg3);
+void test__memrchr__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  memrchr(arg1, !x, arg3);
 }
 
-void test__memrchr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    memrchr(arg1, x, arg3);
+void test__memrchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memrchr(arg1, x, arg3);
 }
 
-void test__memrchr__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    memrchr(arg1, arg2, !x);
+void test__memrchr__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  memrchr(arg1, arg2, !x);
 }
 
-void test__rawmemchr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        rawmemchr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__rawmemchr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; rawmemchr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__rawmemchr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    rawmemchr(p, arg2);
-    // cppcheck-suppress memleak
+void test__rawmemchr__leakignore() {
+  char *p = malloc(10); *p=0;
+  rawmemchr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__rawmemchr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    rawmemchr(NULL, arg2);
+void test__rawmemchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  rawmemchr(NULL, arg2);
 }
 
-void test__rawmemchr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    rawmemchr(x, arg2);
+void test__rawmemchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  rawmemchr(x, arg2);
 }
 
-void test__rawmemchr__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    rawmemchr(arg1, !x);
+void test__rawmemchr__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  rawmemchr(arg1, !x);
 }
 
-void test__rawmemchr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    rawmemchr(arg1, x);
+void test__rawmemchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  rawmemchr(arg1, x);
 }
 
-void test__ffsl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ffsl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ffsl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ffsl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ffsl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ffsl(arg1);
+void test__ffsl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ffsl(arg1);
 }
 
-void test__ffsl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ffsl(p);
-    // cppcheck-suppress memleak
+void test__ffsl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ffsl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ffsl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ffsl(x);
+void test__ffsl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ffsl(x);
 }
 
-void test__ffsll__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ffsll(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ffsll__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ffsll(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ffsll__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ffsll(arg1);
+void test__ffsll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ffsll(arg1);
 }
 
-void test__ffsll__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ffsll(p);
-    // cppcheck-suppress memleak
+void test__ffsll__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ffsll(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ffsll__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ffsll(x);
+void test__ffsll__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ffsll(x);
 }
 
-void test__strchrnul__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strchrnul(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strchrnul__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strchrnul(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strchrnul__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strchrnul(arg1, arg2);
+void test__strchrnul__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strchrnul(arg1, arg2);
 }
 
-void test__strchrnul__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = strchrnul(p, arg2);
-    // cppcheck-suppress memleak
+void test__strchrnul__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = strchrnul(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__strchrnul__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strchrnul(NULL, arg2);
+void test__strchrnul__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strchrnul(NULL, arg2);
 }
 
-void test__strchrnul__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strchrnul(x, arg2);
+void test__strchrnul__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strchrnul(x, arg2);
 }
 
-void test__strchrnul__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = strchrnul(arg1, x);
+void test__strchrnul__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strchrnul(arg1, x);
 }
 
-void test__prlimit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        prlimit(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__prlimit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; prlimit(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__prlimit__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    prlimit(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__prlimit__leakignore() {
+  char *p = malloc(10); *p=0;
+  prlimit(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__prlimit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    prlimit(x, arg2, arg3, arg4);
+void test__prlimit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  prlimit(x, arg2, arg3, arg4);
 }
 
-void test__prlimit__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    prlimit(arg1, x, arg3, arg4);
+void test__prlimit__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  prlimit(arg1, x, arg3, arg4);
 }
 
-void test__prlimit__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    prlimit(arg1, arg2, x, arg4);
+void test__prlimit__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  prlimit(arg1, arg2, x, arg4);
 }
 
-void test__epoll_create__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        epoll_create(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__epoll_create__noreturn() {
+  int x = 1;
+  if (cond) { x=100; epoll_create(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__epoll_create__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    epoll_create(!x);
+void test__epoll_create__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  epoll_create(!x);
 }
 
-void test__epoll_create__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    epoll_create(x);
+void test__epoll_create__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  epoll_create(x);
 }
 
-void test__epoll_create1__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        epoll_create1(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__epoll_create1__noreturn() {
+  int x = 1;
+  if (cond) { x=100; epoll_create1(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__epoll_create1__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    epoll_create1(!x);
+void test__epoll_create1__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  epoll_create1(!x);
 }
 
-void test__epoll_create1__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    epoll_create1(x);
+void test__epoll_create1__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  epoll_create1(x);
 }
 
-void test__epoll_ctl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        epoll_ctl(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__epoll_ctl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; epoll_ctl(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__epoll_ctl__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    epoll_ctl(!x, arg2, arg3, arg4);
+void test__epoll_ctl__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  epoll_ctl(!x, arg2, arg3, arg4);
 }
 
-void test__epoll_ctl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    epoll_ctl(x, arg2, arg3, arg4);
+void test__epoll_ctl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  epoll_ctl(x, arg2, arg3, arg4);
 }
 
-void test__epoll_ctl__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    epoll_ctl(arg1, !x, arg3, arg4);
+void test__epoll_ctl__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  epoll_ctl(arg1, !x, arg3, arg4);
 }
 
-void test__epoll_ctl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    epoll_ctl(arg1, x, arg3, arg4);
+void test__epoll_ctl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  epoll_ctl(arg1, x, arg3, arg4);
 }
 
-void test__epoll_ctl__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    epoll_ctl(arg1, arg2, !x, arg4);
+void test__epoll_ctl__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  epoll_ctl(arg1, arg2, !x, arg4);
 }
 
-void test__epoll_ctl__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    epoll_ctl(arg1, arg2, x, arg4);
+void test__epoll_ctl__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  epoll_ctl(arg1, arg2, x, arg4);
 }
 
-void test__epoll_ctl__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    epoll_ctl(arg1, arg2, arg3, !x);
+void test__epoll_ctl__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  epoll_ctl(arg1, arg2, arg3, !x);
 }
 
-void test__epoll_ctl__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    epoll_ctl(arg1, arg2, arg3, NULL);
+void test__epoll_ctl__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  epoll_ctl(arg1, arg2, arg3, NULL);
 }
 
-void test__epoll_wait__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        epoll_wait(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__epoll_wait__noreturn() {
+  int x = 1;
+  if (cond) { x=100; epoll_wait(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__epoll_wait__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    epoll_wait(!x, arg2, arg3, arg4);
+void test__epoll_wait__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  epoll_wait(!x, arg2, arg3, arg4);
 }
 
-void test__epoll_wait__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    epoll_wait(x, arg2, arg3, arg4);
+void test__epoll_wait__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  epoll_wait(x, arg2, arg3, arg4);
 }
 
-void test__epoll_wait__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    epoll_wait(arg1, !x, arg3, arg4);
+void test__epoll_wait__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  epoll_wait(arg1, !x, arg3, arg4);
 }
 
-void test__epoll_wait__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    epoll_wait(arg1, NULL, arg3, arg4);
+void test__epoll_wait__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  epoll_wait(arg1, NULL, arg3, arg4);
 }
 
-void test__epoll_wait__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    epoll_wait(arg1, arg2, !x, arg4);
+void test__epoll_wait__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  epoll_wait(arg1, arg2, !x, arg4);
 }
 
-void test__epoll_wait__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    epoll_wait(arg1, arg2, x, arg4);
+void test__epoll_wait__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  epoll_wait(arg1, arg2, x, arg4);
 }
 
-void test__epoll_wait__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    epoll_wait(arg1, arg2, arg3, !x);
+void test__epoll_wait__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  epoll_wait(arg1, arg2, arg3, !x);
 }
 
-void test__epoll_wait__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    epoll_wait(arg1, arg2, arg3, x);
+void test__epoll_wait__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  epoll_wait(arg1, arg2, arg3, x);
 }
 
-void test__epoll_pwait__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        epoll_pwait(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__epoll_pwait__noreturn() {
+  int x = 1;
+  if (cond) { x=100; epoll_pwait(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__epoll_pwait__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    epoll_pwait(!x, arg2, arg3, arg4, arg5);
+void test__epoll_pwait__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  epoll_pwait(!x, arg2, arg3, arg4, arg5);
 }
 
-void test__epoll_pwait__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    epoll_pwait(x, arg2, arg3, arg4, arg5);
+void test__epoll_pwait__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  epoll_pwait(x, arg2, arg3, arg4, arg5);
 }
 
-void test__epoll_pwait__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    epoll_pwait(arg1, !x, arg3, arg4, arg5);
+void test__epoll_pwait__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  epoll_pwait(arg1, !x, arg3, arg4, arg5);
 }
 
-void test__epoll_pwait__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    epoll_pwait(arg1, NULL, arg3, arg4, arg5);
+void test__epoll_pwait__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  epoll_pwait(arg1, NULL, arg3, arg4, arg5);
 }
 
-void test__epoll_pwait__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    epoll_pwait(arg1, arg2, !x, arg4, arg5);
+void test__epoll_pwait__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  epoll_pwait(arg1, arg2, !x, arg4, arg5);
 }
 
-void test__epoll_pwait__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    epoll_pwait(arg1, arg2, x, arg4, arg5);
+void test__epoll_pwait__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  epoll_pwait(arg1, arg2, x, arg4, arg5);
 }
 
-void test__epoll_pwait__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    epoll_pwait(arg1, arg2, arg3, !x, arg5);
+void test__epoll_pwait__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  epoll_pwait(arg1, arg2, arg3, !x, arg5);
 }
 
-void test__epoll_pwait__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    epoll_pwait(arg1, arg2, arg3, x, arg5);
+void test__epoll_pwait__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  epoll_pwait(arg1, arg2, arg3, x, arg5);
 }
 
-void test__epoll_pwait__arg5__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    epoll_pwait(arg1, arg2, arg3, arg4, !x);
+void test__epoll_pwait__arg5__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  epoll_pwait(arg1, arg2, arg3, arg4, !x);
 }
 
-void test__epoll_pwait__arg5__notnull()
-{
-    // cppcheck-suppress nullPointer
-    epoll_pwait(arg1, arg2, arg3, arg4, NULL);
+void test__epoll_pwait__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  epoll_pwait(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test__epoll_pwait__arg5__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    epoll_pwait(arg1, arg2, arg3, arg4, x);
+void test__epoll_pwait__arg5__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  epoll_pwait(arg1, arg2, arg3, arg4, x);
 }
 
diff --git a/test/cfg/generated-cfg-tests-motif.cpp b/test/cfg/generated-cfg-tests-motif.cpp
index 5ed370baa..b807652a8 100644
--- a/test/cfg/generated-cfg-tests-motif.cpp
+++ b/test/cfg/generated-cfg-tests-motif.cpp
@@ -8,614 +8,453 @@
 // => 'unmatched suppression' warnings are false negatives.
 //
 
-void test__MrmCloseHierarchy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        MrmCloseHierarchy(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__MrmCloseHierarchy__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    MrmCloseHierarchy(x);
-}
-
-void test__MrmOpenHierarchy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = MrmOpenHierarchy(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__MrmOpenHierarchy__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    MrmOpenHierarchy(arg1, arg2, arg3, arg4);
-}
-
-void test__MrmOpenHierarchyPerDisplay__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = MrmOpenHierarchyPerDisplay(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__MrmOpenHierarchyPerDisplay__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    MrmOpenHierarchyPerDisplay(arg1, arg2, arg3, arg4, arg5);
-}
-
-void test__XmFontListEntryFree__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        XmFontListEntryFree(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__MrmCloseHierarchy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; MrmCloseHierarchy(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__MrmCloseHierarchy__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MrmCloseHierarchy(x);
+}
+
+void test__MrmOpenHierarchy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = MrmOpenHierarchy(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__MrmOpenHierarchy__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  MrmOpenHierarchy(arg1, arg2, arg3, arg4);
+}
+
+void test__MrmOpenHierarchyPerDisplay__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = MrmOpenHierarchyPerDisplay(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__MrmOpenHierarchyPerDisplay__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  MrmOpenHierarchyPerDisplay(arg1, arg2, arg3, arg4, arg5);
+}
+
+void test__XmFontListEntryFree__noreturn() {
+  int x = 1;
+  if (cond) { x=100; XmFontListEntryFree(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XmFontListEntryFree__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  XmFontListEntryFree(x);
+}
+
+void test__XmFontListCreate__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = XmFontListCreate(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XmFontListCreate__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  XmFontListCreate(arg1, arg2);
+}
+
+void test__XmFontListCreate__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = XmFontListCreate(x, arg2);
+}
+
+void test__XmFontListCreate__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = XmFontListCreate(arg1, x);
+}
+
+void test__XmFontListAppendEntry__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = XmFontListAppendEntry(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XmFontListAppendEntry__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  XmFontListAppendEntry(arg1, arg2);
+}
+
+void test__XmFontListAppendEntry__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = XmFontListAppendEntry(x, arg2);
+}
+
+void test__XmFontListAppendEntry__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = XmFontListAppendEntry(arg1, x);
+}
+
+void test__XmStringCreateLocalized__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = XmStringCreateLocalized(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XmStringCreateLocalized__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  XmStringCreateLocalized(arg1);
+}
+
+void test__XmStringCreateLocalized__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = XmStringCreateLocalized(p);
+  // cppcheck-suppress memleak
+}
+
+void test__XmStringCreateLocalized__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = XmStringCreateLocalized(NULL);
+}
+
+void test__XmStringCreateLocalized__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = XmStringCreateLocalized(x);
+}
+
+void test__XmStringCreateSimple__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = XmStringCreateSimple(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XmStringCreateSimple__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  XmStringCreateSimple(arg1);
+}
+
+void test__XmStringCreateSimple__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = XmStringCreateSimple(p);
+  // cppcheck-suppress memleak
+}
+
+void test__XmStringCreateSimple__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = XmStringCreateSimple(NULL);
+}
+
+void test__XmStringCreateSimple__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = XmStringCreateSimple(x);
+}
+
+void test__XmStringFree__noreturn() {
+  int x = 1;
+  if (cond) { x=100; XmStringFree(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XmStringFree__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  XmStringFree(x);
+}
+
+void test__XmStringGenerate__noreturn() {
+  int x = 1;
+  if (cond) { x=100; XmStringGenerate(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XmStringGenerate__leakignore() {
+  char *p = malloc(10); *p=0;
+  XmStringGenerate(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__XmTextGetString__noreturn() {
+  int x = 1;
+  if (cond) { x=100; XmTextGetString(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XmTextGetString__leakignore() {
+  char *p = malloc(10); *p=0;
+  XmTextGetString(p);
+  // cppcheck-suppress memleak
+}
+
+void test__XmTextGetString__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  XmTextGetString(x);
+}
+
+void test__XmTextGetStringWcs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; XmTextGetStringWcs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XmTextGetStringWcs__leakignore() {
+  char *p = malloc(10); *p=0;
+  XmTextGetStringWcs(p);
+  // cppcheck-suppress memleak
+}
+
+void test__XmTextGetStringWcs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  XmTextGetStringWcs(x);
+}
+
+void test__XtAsprintf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  XtAsprintf(arg1, NULL);
+}
+
+void test__XtAsprintf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  XtAsprintf(arg1, x);
+}
+
+void test__XtFree__noreturn() {
+  int x = 1;
+  if (cond) { x=100; XtFree(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XtFree__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  XtFree(x);
+}
+
+void test__XtSetValues__noreturn() {
+  int x = 1;
+  if (cond) { x=100; XtSetValues(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XtSetValues__leakignore() {
+  char *p = malloc(10); *p=0;
+  XtSetValues(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__XtGetValues__noreturn() {
+  int x = 1;
+  if (cond) { x=100; XtGetValues(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XtGetValues__leakignore() {
+  char *p = malloc(10); *p=0;
+  XtGetValues(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
 
-void test__XmFontListEntryFree__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    XmFontListEntryFree(x);
-}
+void test__XtSetSubvalues__noreturn() {
+  int x = 1;
+  if (cond) { x=100; XtSetSubvalues(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XtSetSubvalues__leakignore() {
+  char *p = malloc(10); *p=0;
+  XtSetSubvalues(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__XtGetSubvalues__noreturn() {
+  int x = 1;
+  if (cond) { x=100; XtGetSubvalues(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__XmFontListCreate__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = XmFontListCreate(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XmFontListCreate__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    XmFontListCreate(arg1, arg2);
-}
+void test__XtGetSubvalues__leakignore() {
+  char *p = malloc(10); *p=0;
+  XtGetSubvalues(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
 
-void test__XmFontListCreate__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = XmFontListCreate(x, arg2);
-}
-
-void test__XmFontListCreate__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = XmFontListCreate(arg1, x);
-}
+void test__XtMalloc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = XtMalloc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__XmFontListAppendEntry__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = XmFontListAppendEntry(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__XtMalloc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  XtMalloc(arg1);
 }
 
-void test__XmFontListAppendEntry__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    XmFontListAppendEntry(arg1, arg2);
+void test__XtMalloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = XtMalloc(x);
 }
 
-void test__XmFontListAppendEntry__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = XmFontListAppendEntry(x, arg2);
+void test__XtNew__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = XtNew(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__XmFontListAppendEntry__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = XmFontListAppendEntry(arg1, x);
+void test__XtNew__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  XtNew(arg1);
 }
 
-void test__XmStringCreateLocalized__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = XmStringCreateLocalized(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__XtNew__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = XtNew(x);
 }
 
-void test__XmStringCreateLocalized__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    XmStringCreateLocalized(arg1);
+void test__XtNewString__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = XtNewString(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__XmStringCreateLocalized__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = XmStringCreateLocalized(p);
-    // cppcheck-suppress memleak
+void test__XtNewString__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  XtNewString(arg1);
 }
 
-void test__XmStringCreateLocalized__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = XmStringCreateLocalized(NULL);
+void test__XtNewString__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = XtNewString(x);
 }
 
-void test__XmStringCreateLocalized__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = XmStringCreateLocalized(x);
+void test__XtCalloc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = XtCalloc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__XmStringCreateSimple__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = XmStringCreateSimple(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__XtCalloc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  XtCalloc(arg1, arg2);
 }
 
-void test__XmStringCreateSimple__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    XmStringCreateSimple(arg1);
+void test__XtCalloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = XtCalloc(x, arg2);
 }
-
-void test__XmStringCreateSimple__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = XmStringCreateSimple(p);
-    // cppcheck-suppress memleak
-}
-
-void test__XmStringCreateSimple__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = XmStringCreateSimple(NULL);
+
+void test__XtCalloc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = XtCalloc(arg1, x);
 }
-
-void test__XmStringCreateSimple__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = XmStringCreateSimple(x);
+
+void test__XOpenDisplay__noreturn() {
+  int x = 1;
+  if (cond) { x=100; XOpenDisplay(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XOpenDisplay__leakignore() {
+  char *p = malloc(10); *p=0;
+  XOpenDisplay(p);
+  // cppcheck-suppress memleak
+}
+
+void test__XOpenDisplay__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  XOpenDisplay(x);
+}
+
+void test__XCloseDisplay__noreturn() {
+  int x = 1;
+  if (cond) { x=100; XCloseDisplay(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XCloseDisplay__leakignore() {
+  char *p = malloc(10); *p=0;
+  XCloseDisplay(p);
+  // cppcheck-suppress memleak
+}
+
+void test__XCloseDisplay__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  XCloseDisplay(x);
+}
+
+void test__XtDatabase__noreturn() {
+  int x = 1;
+  if (cond) { x=100; XtDatabase(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XtDatabase__leakignore() {
+  char *p = malloc(10); *p=0;
+  XtDatabase(p);
+  // cppcheck-suppress memleak
+}
+
+void test__XtDatabase__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  XtDatabase(x);
+}
+
+void test__XtScreenDatabase__noreturn() {
+  int x = 1;
+  if (cond) { x=100; XtScreenDatabase(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XtScreenDatabase__leakignore() {
+  char *p = malloc(10); *p=0;
+  XtScreenDatabase(p);
+  // cppcheck-suppress memleak
 }
 
-void test__XmStringFree__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        XmStringFree(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XmStringFree__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    XmStringFree(x);
-}
-
-void test__XmStringGenerate__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        XmStringGenerate(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XmStringGenerate__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    XmStringGenerate(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
-}
-
-void test__XmTextGetString__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        XmTextGetString(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XmTextGetString__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    XmTextGetString(p);
-    // cppcheck-suppress memleak
-}
-
-void test__XmTextGetString__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    XmTextGetString(x);
-}
-
-void test__XmTextGetStringWcs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        XmTextGetStringWcs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XmTextGetStringWcs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    XmTextGetStringWcs(p);
-    // cppcheck-suppress memleak
-}
-
-void test__XmTextGetStringWcs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    XmTextGetStringWcs(x);
-}
-
-void test__XtAsprintf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    XtAsprintf(arg1, NULL);
-}
-
-void test__XtAsprintf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    XtAsprintf(arg1, x);
-}
-
-void test__XtFree__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        XtFree(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XtFree__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    XtFree(x);
-}
-
-void test__XtSetValues__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        XtSetValues(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XtSetValues__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    XtSetValues(p, arg2, arg3);
-    // cppcheck-suppress memleak
-}
-
-void test__XtGetValues__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        XtGetValues(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XtGetValues__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    XtGetValues(p, arg2, arg3);
-    // cppcheck-suppress memleak
-}
-
-void test__XtSetSubvalues__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        XtSetSubvalues(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XtSetSubvalues__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    XtSetSubvalues(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
-}
-
-void test__XtGetSubvalues__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        XtGetSubvalues(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XtGetSubvalues__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    XtGetSubvalues(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
-}
-
-void test__XtMalloc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = XtMalloc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XtMalloc__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    XtMalloc(arg1);
-}
-
-void test__XtMalloc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = XtMalloc(x);
-}
-
-void test__XtNew__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = XtNew(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XtNew__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    XtNew(arg1);
-}
-
-void test__XtNew__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = XtNew(x);
-}
-
-void test__XtNewString__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = XtNewString(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XtNewString__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    XtNewString(arg1);
-}
-
-void test__XtNewString__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = XtNewString(x);
-}
-
-void test__XtCalloc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = XtCalloc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XtCalloc__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    XtCalloc(arg1, arg2);
-}
-
-void test__XtCalloc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = XtCalloc(x, arg2);
-}
-
-void test__XtCalloc__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = XtCalloc(arg1, x);
-}
-
-void test__XOpenDisplay__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        XOpenDisplay(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XOpenDisplay__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    XOpenDisplay(p);
-    // cppcheck-suppress memleak
-}
-
-void test__XOpenDisplay__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    XOpenDisplay(x);
-}
-
-void test__XCloseDisplay__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        XCloseDisplay(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XCloseDisplay__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    XCloseDisplay(p);
-    // cppcheck-suppress memleak
-}
-
-void test__XCloseDisplay__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    XCloseDisplay(x);
-}
-
-void test__XtDatabase__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        XtDatabase(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XtDatabase__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    XtDatabase(p);
-    // cppcheck-suppress memleak
-}
-
-void test__XtDatabase__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    XtDatabase(x);
-}
-
-void test__XtScreenDatabase__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        XtScreenDatabase(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__XtScreenDatabase__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    XtScreenDatabase(p);
-    // cppcheck-suppress memleak
-}
-
-void test__XtScreenDatabase__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    XtScreenDatabase(x);
+void test__XtScreenDatabase__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  XtScreenDatabase(x);
 }
 
diff --git a/test/cfg/generated-cfg-tests-posix.cpp b/test/cfg/generated-cfg-tests-posix.cpp
index de9034513..4b676b9c6 100644
--- a/test/cfg/generated-cfg-tests-posix.cpp
+++ b/test/cfg/generated-cfg-tests-posix.cpp
@@ -8,9660 +8,7333 @@
 // => 'unmatched suppression' warnings are false negatives.
 //
 
-void test__a64l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = a64l(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__a64l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = a64l(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__a64l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    a64l(arg1);
-}
-
-void test__a64l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = a64l(p);
-    // cppcheck-suppress memleak
-}
-
-void test__a64l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = a64l(NULL);
+void test__a64l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  a64l(arg1);
 }
 
-void test__a64l__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = a64l(x);
+void test__a64l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = a64l(p);
+  // cppcheck-suppress memleak
 }
 
-void test__l64a__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = l64a(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__a64l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = a64l(NULL);
 }
 
-void test__l64a__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    l64a(arg1);
+void test__a64l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = a64l(x);
 }
 
-void test__l64a__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = l64a(p);
-    // cppcheck-suppress memleak
+void test__l64a__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = l64a(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__l64a__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = l64a(x);
+void test__l64a__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  l64a(arg1);
 }
 
-void test__accept__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        accept(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__l64a__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = l64a(p);
+  // cppcheck-suppress memleak
 }
 
-void test__accept__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    accept(p, arg2, arg3);
-    // cppcheck-suppress memleak
-}
-
-void test__accept__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    accept(x, arg2, arg3);
+void test__l64a__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = l64a(x);
 }
-
-void test__accept__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    accept(arg1, x, arg3);
+
+void test__accept__noreturn() {
+  int x = 1;
+  if (cond) { x=100; accept(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__accept__leakignore() {
+  char *p = malloc(10); *p=0;
+  accept(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__accept__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  accept(x, arg2, arg3);
+}
+
+void test__accept__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  accept(arg1, x, arg3);
+}
+
+void test__accept__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  accept(arg1, arg2, x);
+}
+
+void test__access__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = access(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__access__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  access(arg1, arg2);
+}
+
+void test__access__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = access(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__access__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = access(NULL, arg2);
+}
+
+void test__access__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = access(x, arg2);
+}
+
+void test__access__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = access(arg1, x);
+}
+
+void test__adjtime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; adjtime(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__adjtime__leakignore() {
+  char *p = malloc(10); *p=0;
+  adjtime(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__adjtime__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  adjtime(x, arg2);
+}
+
+void test__gettimeofday__noreturn() {
+  int x = 1;
+  if (cond) { x=100; gettimeofday(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__gettimeofday__leakignore() {
+  char *p = malloc(10); *p=0;
+  gettimeofday(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__settimeofday__noreturn() {
+  int x = 1;
+  if (cond) { x=100; settimeofday(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__settimeofday__leakignore() {
+  char *p = malloc(10); *p=0;
+  settimeofday(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__settimeofday__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  settimeofday(x, arg2);
+}
+
+void test__settimeofday__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  settimeofday(arg1, x);
+}
+
+void test__FD_CLR__noreturn() {
+  int x = 1;
+  if (cond) { x=100; FD_CLR(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FD_CLR__leakignore() {
+  char *p = malloc(10); *p=0;
+  FD_CLR(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__FD_CLR__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  FD_CLR(x, arg2);
+}
+
+void test__FD_CLR__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  FD_CLR(arg1, NULL);
+}
+
+void test__FD_ISSET__noreturn() {
+  int x = 1;
+  if (cond) { x=100; FD_ISSET(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FD_ISSET__leakignore() {
+  char *p = malloc(10); *p=0;
+  FD_ISSET(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__FD_ISSET__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  FD_ISSET(x, arg2);
+}
+
+void test__FD_ISSET__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  FD_ISSET(arg1, NULL);
+}
+
+void test__FD_SET__noreturn() {
+  int x = 1;
+  if (cond) { x=100; FD_SET(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FD_SET__leakignore() {
+  char *p = malloc(10); *p=0;
+  FD_SET(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__FD_SET__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  FD_SET(x, arg2);
+}
+
+void test__FD_SET__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  FD_SET(arg1, NULL);
+}
+
+void test__FD_ZERO__noreturn() {
+  int x = 1;
+  if (cond) { x=100; FD_ZERO(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FD_ZERO__leakignore() {
+  char *p = malloc(10); *p=0;
+  FD_ZERO(p);
+  // cppcheck-suppress memleak
+}
+
+void test__FD_ZERO__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  FD_ZERO(NULL);
+}
+
+void test__fdatasync__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fdatasync(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fdatasync__leakignore() {
+  char *p = malloc(10); *p=0;
+  fdatasync(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fdatasync__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fdatasync(x);
+}
+
+void test__fnmatch__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fnmatch(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fnmatch__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fnmatch(arg1, arg2, arg3);
+}
+
+void test__fnmatch__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fnmatch(arg1, arg2, arg3) > 10) || (fnmatch(arg1, arg2, arg3) < 100)) {}
+}
+
+void test__fnmatch__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fnmatch(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__fnmatch__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fnmatch(NULL, arg2, arg3);
+}
+
+void test__fnmatch__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fnmatch(x, arg2, arg3);
+}
+
+void test__fnmatch__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fnmatch(arg1, NULL, arg3);
+}
+
+void test__fnmatch__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fnmatch(arg1, x, arg3);
+}
+
+void test__fnmatch__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fnmatch(arg1, arg2, x);
+}
+
+void test__fsync__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fsync(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fsync__leakignore() {
+  char *p = malloc(10); *p=0;
+  fsync(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fsync__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fsync(x);
+}
+
+void test__truncate__noreturn() {
+  int x = 1;
+  if (cond) { x=100; truncate(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__truncate__leakignore() {
+  char *p = malloc(10); *p=0;
+  truncate(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__truncate__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  truncate(NULL, arg2);
+}
+
+void test__truncate__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  truncate(x, arg2);
+}
+
+void test__truncate__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  truncate(arg1, x);
+}
+
+void test__ftruncate__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ftruncate(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ftruncate__leakignore() {
+  char *p = malloc(10); *p=0;
+  ftruncate(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__ftruncate__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ftruncate(x, arg2);
+}
+
+void test__ftruncate__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ftruncate(arg1, x);
+}
+
+void test__flock__noreturn() {
+  int x = 1;
+  if (cond) { x=100; flock(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__flock__leakignore() {
+  char *p = malloc(10); *p=0;
+  flock(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__flock__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  flock(x, arg2);
+}
+
+void test__flock__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  flock(arg1, x);
+}
+
+void test__symlink__noreturn() {
+  int x = 1;
+  if (cond) { x=100; symlink(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__symlink__leakignore() {
+  char *p = malloc(10); *p=0;
+  symlink(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__symlink__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  symlink(NULL, arg2);
+}
+
+void test__symlink__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  symlink(x, arg2);
+}
+
+void test__symlink__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  symlink(arg1, NULL);
+}
+
+void test__symlink__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  symlink(arg1, x);
+}
+
+void test__open__noreturn() {
+  int x = 1;
+  if (cond) { x=100; open(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__open__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  open(NULL, arg2, arg3);
+}
+
+void test__open__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  open(x, arg2, arg3);
+}
+
+void test__open__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  open(arg1, x, arg3);
+}
+
+void test__open__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  open(arg1, arg2, x);
+}
+
+void test__creat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = creat(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__creat__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  creat(arg1, arg2);
+}
+
+void test__creat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = creat(NULL, arg2);
+}
+
+void test__creat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = creat(x, arg2);
+}
+
+void test__creat__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = creat(arg1, x);
+}
+
+void test__sleep__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sleep(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sleep__leakignore() {
+  char *p = malloc(10); *p=0;
+  sleep(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sleep__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  sleep(!x);
+}
+
+void test__sleep__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sleep(x);
+}
+
+void test__usleep__noreturn() {
+  int x = 1;
+  if (cond) { x=100; usleep(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__usleep__leakignore() {
+  char *p = malloc(10); *p=0;
+  usleep(p);
+  // cppcheck-suppress memleak
+}
+
+void test__usleep__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  usleep(!x);
+}
+
+void test___exit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _exit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___exit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _exit(x);
+}
+
+void test__faccessat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; faccessat(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__faccessat__leakignore() {
+  char *p = malloc(10); *p=0;
+  faccessat(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__faccessat__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  faccessat(x, arg2, arg3, arg4);
+}
+
+void test__faccessat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  faccessat(arg1, NULL, arg3, arg4);
+}
+
+void test__faccessat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  faccessat(arg1, x, arg3, arg4);
+}
+
+void test__faccessat__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  faccessat(arg1, arg2, x, arg4);
 }
 
-void test__accept__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    accept(arg1, arg2, x);
+void test__faccessat__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  faccessat(arg1, arg2, arg3, x);
 }
 
-void test__access__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = access(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__acct__noreturn() {
+  int x = 1;
+  if (cond) { x=100; acct(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__access__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    access(arg1, arg2);
+void test__acct__leakignore() {
+  char *p = malloc(10); *p=0;
+  acct(p);
+  // cppcheck-suppress memleak
 }
 
-void test__access__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = access(p, arg2);
-    // cppcheck-suppress memleak
+void test__acct__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  acct(x);
 }
 
-void test__access__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = access(NULL, arg2);
-}
-
-void test__access__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = access(x, arg2);
+void test__alarm__noreturn() {
+  int x = 1;
+  if (cond) { x=100; alarm(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__access__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = access(arg1, x);
+void test__alarm__leakignore() {
+  char *p = malloc(10); *p=0;
+  alarm(p);
+  // cppcheck-suppress memleak
 }
-
-void test__adjtime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        adjtime(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__alarm__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  alarm(x);
 }
 
-void test__adjtime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    adjtime(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__adjtime__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    adjtime(x, arg2);
+void test__getrpcent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getrpcent(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__gettimeofday__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        gettimeofday(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__getrpcent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getrpcent();
 }
 
-void test__gettimeofday__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    gettimeofday(p, arg2);
-    // cppcheck-suppress memleak
+void test__getrpcent__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getrpcent();
+  // cppcheck-suppress memleak
 }
 
-void test__settimeofday__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        settimeofday(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__settimeofday__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    settimeofday(p, arg2);
-    // cppcheck-suppress memleak
+void test__getrpcbyname__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getrpcbyname(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__settimeofday__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    settimeofday(x, arg2);
+void test__getrpcbyname__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getrpcbyname(arg1);
 }
 
-void test__settimeofday__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    settimeofday(arg1, x);
+void test__getrpcbyname__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getrpcbyname(p);
+  // cppcheck-suppress memleak
 }
 
-void test__FD_CLR__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        FD_CLR(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__FD_CLR__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    FD_CLR(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__FD_CLR__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    FD_CLR(x, arg2);
-}
-
-void test__FD_CLR__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    FD_CLR(arg1, NULL);
-}
+void test__getrpcbyname__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = getrpcbyname(NULL);
+}
 
-void test__FD_ISSET__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        FD_ISSET(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__FD_ISSET__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    FD_ISSET(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__FD_ISSET__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    FD_ISSET(x, arg2);
-}
+void test__getrpcbyname__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = getrpcbyname(x);
+}
 
-void test__FD_ISSET__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    FD_ISSET(arg1, NULL);
-}
+void test__getrpcbynumber__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getrpcbynumber(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__FD_SET__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        FD_SET(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getrpcbynumber__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getrpcbynumber(arg1);
 }
 
-void test__FD_SET__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    FD_SET(p, arg2);
-    // cppcheck-suppress memleak
+void test__getrpcbynumber__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getrpcbynumber(p);
+  // cppcheck-suppress memleak
 }
 
-void test__FD_SET__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    FD_SET(x, arg2);
+void test__getrpcbynumber__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getrpcbynumber(x);
 }
 
-void test__FD_SET__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    FD_SET(arg1, NULL);
+void test__getprotoent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getprotoent(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__FD_ZERO__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        FD_ZERO(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getprotoent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getprotoent();
 }
 
-void test__FD_ZERO__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    FD_ZERO(p);
-    // cppcheck-suppress memleak
+void test__getprotoent__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getprotoent();
+  // cppcheck-suppress memleak
 }
 
-void test__FD_ZERO__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    FD_ZERO(NULL);
+void test__getprotobyname__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getprotobyname(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fdatasync__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fdatasync(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getprotobyname__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getprotobyname(arg1);
 }
 
-void test__fdatasync__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fdatasync(p);
-    // cppcheck-suppress memleak
+void test__getprotobyname__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getprotobyname(p);
+  // cppcheck-suppress memleak
 }
 
-void test__fdatasync__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fdatasync(x);
+void test__getprotobyname__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = getprotobyname(NULL);
 }
 
-void test__fnmatch__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fnmatch(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getprotobyname__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = getprotobyname(x);
 }
 
-void test__fnmatch__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fnmatch(arg1, arg2, arg3);
+void test__getprotobynumber__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getprotobynumber(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fnmatch__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fnmatch(arg1, arg2, arg3) > 10) || (fnmatch(arg1, arg2, arg3) < 100)) {}
+void test__getprotobynumber__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getprotobynumber(arg1);
 }
 
-void test__fnmatch__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fnmatch(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__getprotobynumber__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getprotobynumber(p);
+  // cppcheck-suppress memleak
 }
 
-void test__fnmatch__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = fnmatch(NULL, arg2, arg3);
+void test__getprotobynumber__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getprotobynumber(x);
 }
 
-void test__fnmatch__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = fnmatch(x, arg2, arg3);
+void test__getservent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getservent(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fnmatch__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = fnmatch(arg1, NULL, arg3);
+void test__getservent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getservent();
 }
 
-void test__fnmatch__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = fnmatch(arg1, x, arg3);
+void test__getservent__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getservent();
+  // cppcheck-suppress memleak
 }
 
-void test__fnmatch__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fnmatch(arg1, arg2, x);
+void test__getservbyname__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getservbyname(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fsync__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fsync(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getservbyname__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getservbyname(arg1, arg2);
 }
 
-void test__fsync__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fsync(p);
-    // cppcheck-suppress memleak
+void test__getservbyname__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getservbyname(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__fsync__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fsync(x);
+void test__getservbyname__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = getservbyname(NULL, arg2);
 }
 
-void test__truncate__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        truncate(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getservbyname__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = getservbyname(x, arg2);
 }
 
-void test__truncate__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    truncate(p, arg2);
-    // cppcheck-suppress memleak
+void test__getservbyname__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getservbyname(arg1, x);
 }
 
-void test__truncate__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    truncate(NULL, arg2);
+void test__getservbyport__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getservbyport(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__truncate__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    truncate(x, arg2);
+void test__getservbyport__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getservbyport(arg1, arg2);
 }
 
-void test__truncate__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    truncate(arg1, x);
+void test__getservbyport__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getservbyport(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__ftruncate__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ftruncate(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getservbyport__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getservbyport(x, arg2);
 }
 
-void test__ftruncate__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ftruncate(p, arg2);
-    // cppcheck-suppress memleak
+void test__getservbyport__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getservbyport(arg1, x);
 }
 
-void test__ftruncate__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ftruncate(x, arg2);
+void test__getnetent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getnetent(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ftruncate__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ftruncate(arg1, x);
+void test__getnetent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getnetent();
 }
 
-void test__flock__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        flock(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getnetent__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getnetent();
+  // cppcheck-suppress memleak
 }
 
-void test__flock__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    flock(p, arg2);
-    // cppcheck-suppress memleak
+void test__getnetbyname__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getnetbyname(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__flock__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    flock(x, arg2);
+void test__getnetbyname__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getnetbyname(arg1);
 }
 
-void test__flock__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    flock(arg1, x);
+void test__getnetbyname__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getnetbyname(p);
+  // cppcheck-suppress memleak
 }
 
-void test__symlink__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        symlink(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getnetbyname__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = getnetbyname(NULL);
 }
 
-void test__symlink__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    symlink(p, arg2);
-    // cppcheck-suppress memleak
+void test__getnetbyname__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = getnetbyname(x);
 }
 
-void test__symlink__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    symlink(NULL, arg2);
+void test__getnetbyaddr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getnetbyaddr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__symlink__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    symlink(x, arg2);
+void test__getnetbyaddr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getnetbyaddr(arg1, arg2);
 }
 
-void test__symlink__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    symlink(arg1, NULL);
+void test__getnetbyaddr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getnetbyaddr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__symlink__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    symlink(arg1, x);
+void test__getnetbyaddr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getnetbyaddr(x, arg2);
 }
 
-void test__open__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        open(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getnetbyaddr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getnetbyaddr(arg1, x);
 }
 
-void test__open__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    open(NULL, arg2, arg3);
+void test__gethostent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = gethostent(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__open__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    open(x, arg2, arg3);
+void test__gethostent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  gethostent();
 }
 
-void test__open__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    open(arg1, x, arg3);
+void test__gethostent__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = gethostent();
+  // cppcheck-suppress memleak
 }
 
-void test__open__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    open(arg1, arg2, x);
+void test__gethostbyname__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = gethostbyname(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__creat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = creat(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__gethostbyname__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  gethostbyname(arg1);
 }
 
-void test__creat__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    creat(arg1, arg2);
+void test__gethostbyname__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = gethostbyname(p);
+  // cppcheck-suppress memleak
 }
 
-void test__creat__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = creat(NULL, arg2);
+void test__gethostbyname__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = gethostbyname(NULL);
 }
 
-void test__creat__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = creat(x, arg2);
+void test__gethostbyname__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = gethostbyname(x);
 }
 
-void test__creat__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = creat(arg1, x);
+void test__gethostbyname2__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = gethostbyname2(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sleep__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sleep(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__gethostbyname2__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  gethostbyname2(arg1, arg2);
 }
 
-void test__sleep__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sleep(p);
-    // cppcheck-suppress memleak
+void test__gethostbyname2__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = gethostbyname2(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__sleep__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    sleep(!x);
+void test__gethostbyname2__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = gethostbyname2(NULL, arg2);
 }
 
-void test__sleep__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sleep(x);
+void test__gethostbyname2__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = gethostbyname2(x, arg2);
 }
 
-void test__usleep__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        usleep(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__gethostbyname2__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = gethostbyname2(arg1, x);
 }
 
-void test__usleep__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    usleep(p);
-    // cppcheck-suppress memleak
+void test__gethostbyaddr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = gethostbyaddr(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__usleep__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    usleep(!x);
+void test__gethostbyaddr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  gethostbyaddr(arg1, arg2, arg3);
 }
 
-void test___exit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _exit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__gethostbyaddr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = gethostbyaddr(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___exit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _exit(x);
+void test__gethostbyaddr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = gethostbyaddr(NULL, arg2, arg3);
 }
 
-void test__faccessat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        faccessat(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__gethostbyaddr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = gethostbyaddr(x, arg2, arg3);
 }
-
-void test__faccessat__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    faccessat(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
-}
-
-void test__faccessat__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    faccessat(x, arg2, arg3, arg4);
-}
-
-void test__faccessat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    faccessat(arg1, NULL, arg3, arg4);
+
+void test__gethostbyaddr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = gethostbyaddr(arg1, x, arg3);
 }
 
-void test__faccessat__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    faccessat(arg1, x, arg3, arg4);
-}
-
-void test__faccessat__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    faccessat(arg1, arg2, x, arg4);
-}
-
-void test__faccessat__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    faccessat(arg1, arg2, arg3, x);
-}
-
-void test__acct__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        acct(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__gethostbyaddr__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = gethostbyaddr(arg1, arg2, x);
 }
 
-void test__acct__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    acct(p);
-    // cppcheck-suppress memleak
+void test__brk__noreturn() {
+  int x = 1;
+  if (cond) { x=100; brk(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__acct__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    acct(x);
-}
+void test__brk__leakignore() {
+  char *p = malloc(10); *p=0;
+  brk(p);
+  // cppcheck-suppress memleak
+}
 
-void test__alarm__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        alarm(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__brk__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  brk(NULL);
 }
 
-void test__alarm__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    alarm(p);
-    // cppcheck-suppress memleak
+void test__sbrk__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sbrk(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__alarm__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    alarm(x);
+void test__sbrk__leakignore() {
+  char *p = malloc(10); *p=0;
+  sbrk(p);
+  // cppcheck-suppress memleak
 }
 
-void test__getrpcent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getrpcent();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sbrk__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sbrk(x);
 }
 
-void test__getrpcent__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getrpcent();
+void test__closedir__noreturn() {
+  int x = 1;
+  if (cond) { x=100; closedir(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getrpcent__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getrpcent();
-    // cppcheck-suppress memleak
+void test__closedir__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  closedir(!x);
 }
 
-void test__getrpcbyname__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getrpcbyname(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__getrpcbyname__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getrpcbyname(arg1);
-}
-
-void test__getrpcbyname__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getrpcbyname(p);
-    // cppcheck-suppress memleak
-}
-
-void test__getrpcbyname__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = getrpcbyname(NULL);
+void test__closedir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  closedir(NULL);
 }
 
-void test__getrpcbyname__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = getrpcbyname(x);
+void test__closedir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  closedir(x);
 }
 
-void test__getrpcbynumber__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getrpcbynumber(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strfry__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strfry(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getrpcbynumber__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getrpcbynumber(arg1);
+void test__strfry__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strfry(NULL);
 }
 
-void test__getrpcbynumber__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getrpcbynumber(p);
-    // cppcheck-suppress memleak
+void test__strsep__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strsep(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getrpcbynumber__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getrpcbynumber(x);
+void test__strsep__leakignore() {
+  char *p = malloc(10); *p=0;
+  strsep(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__getprotoent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getprotoent();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strsep__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strsep(NULL, arg2);
 }
 
-void test__getprotoent__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getprotoent();
+void test__strsep__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strsep(x, arg2);
 }
 
-void test__getprotoent__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getprotoent();
-    // cppcheck-suppress memleak
+void test__strsep__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strsep(arg1, NULL);
 }
 
-void test__getprotobyname__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getprotobyname(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strsep__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strsep(arg1, x);
 }
 
-void test__getprotobyname__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getprotobyname(arg1);
+void test__strdup__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strdup(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getprotobyname__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getprotobyname(p);
-    // cppcheck-suppress memleak
+void test__strdup__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strdup(NULL);
 }
 
-void test__getprotobyname__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = getprotobyname(NULL);
+void test__strdup__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strdup(x);
 }
 
-void test__getprotobyname__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = getprotobyname(x);
+void test__strndup__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strndup(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getprotobynumber__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getprotobynumber(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strndup__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strndup(NULL, arg2);
 }
 
-void test__getprotobynumber__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getprotobynumber(arg1);
+void test__strndup__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strndup(x, arg2);
 }
 
-void test__getprotobynumber__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getprotobynumber(p);
-    // cppcheck-suppress memleak
+void test__strndup__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strndup(arg1, x);
 }
 
-void test__getprotobynumber__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getprotobynumber(x);
+void test__wcsdup__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcsdup(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getservent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getservent();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsdup__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsdup(NULL);
 }
 
-void test__getservent__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getservent();
+void test__wcsdup__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsdup(x);
 }
 
-void test__getservent__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getservent();
-    // cppcheck-suppress memleak
+void test__mkstemp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mkstemp(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getservbyname__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getservbyname(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mkstemp__leakignore() {
+  char *p = malloc(10); *p=0;
+  mkstemp(p);
+  // cppcheck-suppress memleak
 }
 
-void test__getservbyname__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getservbyname(arg1, arg2);
+void test__mkstemp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mkstemp(NULL);
 }
 
-void test__getservbyname__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getservbyname(p, arg2);
-    // cppcheck-suppress memleak
+void test__mkstemp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mkstemp(x);
 }
 
-void test__getservbyname__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = getservbyname(NULL, arg2);
+void test__mkdtemp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mkdtemp(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getservbyname__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = getservbyname(x, arg2);
+void test__mkdtemp__leakignore() {
+  char *p = malloc(10); *p=0;
+  mkdtemp(p);
+  // cppcheck-suppress memleak
 }
 
-void test__getservbyname__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getservbyname(arg1, x);
+void test__mkdtemp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mkdtemp(NULL);
 }
 
-void test__getservbyport__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getservbyport(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mkdtemp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mkdtemp(x);
 }
 
-void test__getservbyport__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getservbyport(arg1, arg2);
+void test__mktemp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = mktemp(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getservbyport__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getservbyport(p, arg2);
-    // cppcheck-suppress memleak
+void test__mktemp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  mktemp(arg1);
 }
 
-void test__getservbyport__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getservbyport(x, arg2);
+void test__mktemp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = mktemp(p);
+  // cppcheck-suppress memleak
 }
 
-void test__getservbyport__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getservbyport(arg1, x);
+void test__mktemp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = mktemp(NULL);
 }
 
-void test__getnetent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getnetent();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mktemp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = mktemp(x);
 }
 
-void test__getnetent__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getnetent();
+void test__getcwd__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getcwd(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getnetent__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getnetent();
-    // cppcheck-suppress memleak
+void test__getcwd__leakignore() {
+  char *p = malloc(10); *p=0;
+  getcwd(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__getnetbyname__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getnetbyname(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getcwd__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getcwd(x, arg2);
 }
 
-void test__getnetbyname__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getnetbyname(arg1);
+void test__getcwd__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getcwd(arg1, x);
 }
 
-void test__getnetbyname__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getnetbyname(p);
-    // cppcheck-suppress memleak
+void test__mkdir__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mkdir(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getnetbyname__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = getnetbyname(NULL);
+void test__mkdir__leakignore() {
+  char *p = malloc(10); *p=0;
+  mkdir(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__getnetbyname__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = getnetbyname(x);
+void test__mkdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mkdir(NULL, arg2);
 }
 
-void test__getnetbyaddr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getnetbyaddr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mkdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mkdir(x, arg2);
 }
 
-void test__getnetbyaddr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getnetbyaddr(arg1, arg2);
+void test__mkdir__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mkdir(arg1, x);
 }
 
-void test__getnetbyaddr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getnetbyaddr(p, arg2);
-    // cppcheck-suppress memleak
+void test__rmdir__noreturn() {
+  int x = 1;
+  if (cond) { x=100; rmdir(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getnetbyaddr__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getnetbyaddr(x, arg2);
+void test__rmdir__leakignore() {
+  char *p = malloc(10); *p=0;
+  rmdir(p);
+  // cppcheck-suppress memleak
 }
 
-void test__getnetbyaddr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getnetbyaddr(arg1, x);
+void test__rmdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  rmdir(NULL);
 }
 
-void test__gethostent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = gethostent();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__rmdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  rmdir(x);
 }
 
-void test__gethostent__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    gethostent();
+void test__chdir__noreturn() {
+  int x = 1;
+  if (cond) { x=100; chdir(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__gethostent__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = gethostent();
-    // cppcheck-suppress memleak
+void test__chdir__leakignore() {
+  char *p = malloc(10); *p=0;
+  chdir(p);
+  // cppcheck-suppress memleak
 }
 
-void test__gethostbyname__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = gethostbyname(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__chdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  chdir(NULL);
 }
 
-void test__gethostbyname__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    gethostbyname(arg1);
+void test__chdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  chdir(x);
 }
 
-void test__gethostbyname__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = gethostbyname(p);
-    // cppcheck-suppress memleak
+void test__chroot__noreturn() {
+  int x = 1;
+  if (cond) { x=100; chroot(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__gethostbyname__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = gethostbyname(NULL);
+void test__chroot__leakignore() {
+  char *p = malloc(10); *p=0;
+  chroot(p);
+  // cppcheck-suppress memleak
 }
 
-void test__gethostbyname__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = gethostbyname(x);
+void test__chroot__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  chroot(NULL);
 }
 
-void test__gethostbyname2__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = gethostbyname2(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__chroot__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  chroot(x);
 }
 
-void test__gethostbyname2__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    gethostbyname2(arg1, arg2);
+void test__link__noreturn() {
+  int x = 1;
+  if (cond) { x=100; link(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__gethostbyname2__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = gethostbyname2(p, arg2);
-    // cppcheck-suppress memleak
+void test__link__leakignore() {
+  char *p = malloc(10); *p=0;
+  link(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__gethostbyname2__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = gethostbyname2(NULL, arg2);
+void test__link__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  link(NULL, arg2);
 }
 
-void test__gethostbyname2__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = gethostbyname2(x, arg2);
+void test__link__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  link(x, arg2);
 }
 
-void test__gethostbyname2__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = gethostbyname2(arg1, x);
+void test__link__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  link(arg1, NULL);
 }
 
-void test__gethostbyaddr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = gethostbyaddr(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__link__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  link(arg1, x);
 }
 
-void test__gethostbyaddr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    gethostbyaddr(arg1, arg2, arg3);
+void test__unlink__noreturn() {
+  int x = 1;
+  if (cond) { x=100; unlink(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__gethostbyaddr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = gethostbyaddr(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__unlink__leakignore() {
+  char *p = malloc(10); *p=0;
+  unlink(p);
+  // cppcheck-suppress memleak
 }
 
-void test__gethostbyaddr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = gethostbyaddr(NULL, arg2, arg3);
+void test__unlink__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  unlink(NULL);
 }
 
-void test__gethostbyaddr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = gethostbyaddr(x, arg2, arg3);
+void test__unlink__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  unlink(x);
 }
 
-void test__gethostbyaddr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = gethostbyaddr(arg1, x, arg3);
+void test__rename__noreturn() {
+  int x = 1;
+  if (cond) { x=100; rename(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__gethostbyaddr__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = gethostbyaddr(arg1, arg2, x);
+void test__rename__leakignore() {
+  char *p = malloc(10); *p=0;
+  rename(p);
+  // cppcheck-suppress memleak
 }
 
-void test__brk__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        brk(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__rename__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  rename(NULL);
 }
 
-void test__brk__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    brk(p);
-    // cppcheck-suppress memleak
+void test__rename__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  rename(x);
 }
 
-void test__brk__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    brk(NULL);
+void test__stat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; stat(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sbrk__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sbrk(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__stat__leakignore() {
+  char *p = malloc(10); *p=0;
+  stat(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__sbrk__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sbrk(p);
-    // cppcheck-suppress memleak
+void test__stat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  stat(NULL, arg2);
 }
 
-void test__sbrk__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sbrk(x);
+void test__stat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  stat(x, arg2);
 }
 
-void test__closedir__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        closedir(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__stat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  stat(arg1, NULL);
 }
 
-void test__closedir__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    closedir(!x);
+void test__lstat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; lstat(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__closedir__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    closedir(NULL);
+void test__lstat__leakignore() {
+  char *p = malloc(10); *p=0;
+  lstat(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__closedir__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    closedir(x);
+void test__lstat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  lstat(NULL, arg2);
 }
 
-void test__strfry__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strfry(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__lstat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  lstat(x, arg2);
 }
 
-void test__strfry__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strfry(NULL);
+void test__lstat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  lstat(arg1, NULL);
 }
 
-void test__strsep__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strsep(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fstat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fstat(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strsep__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strsep(p, arg2);
-    // cppcheck-suppress memleak
+void test__fstat__leakignore() {
+  char *p = malloc(10); *p=0;
+  fstat(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__strsep__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strsep(NULL, arg2);
+void test__fstat__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fstat(x, arg2);
 }
 
-void test__strsep__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strsep(x, arg2);
+void test__fstat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fstat(arg1, NULL);
 }
 
-void test__strsep__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strsep(arg1, NULL);
+void test__chmod__noreturn() {
+  int x = 1;
+  if (cond) { x=100; chmod(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strsep__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strsep(arg1, x);
+void test__chmod__leakignore() {
+  char *p = malloc(10); *p=0;
+  chmod(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__strdup__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strdup(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__chmod__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  chmod(NULL, arg2);
 }
 
-void test__strdup__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strdup(NULL);
+void test__chmod__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  chmod(x, arg2);
 }
 
-void test__strdup__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strdup(x);
+void test__chmod__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  chmod(arg1, x);
 }
 
-void test__strndup__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strndup(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fchmod__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fchmod(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strndup__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strndup(NULL, arg2);
+void test__fchmod__leakignore() {
+  char *p = malloc(10); *p=0;
+  fchmod(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__strndup__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strndup(x, arg2);
+void test__fchmod__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fchmod(x, arg2);
 }
 
-void test__strndup__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strndup(arg1, x);
+void test__fchmod__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fchmod(arg1, x);
 }
 
-void test__wcsdup__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcsdup(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__chown__noreturn() {
+  int x = 1;
+  if (cond) { x=100; chown(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsdup__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcsdup(NULL);
+void test__chown__leakignore() {
+  char *p = malloc(10); *p=0;
+  chown(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__wcsdup__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcsdup(x);
+void test__chown__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  chown(NULL, arg2, arg3);
 }
 
-void test__mkstemp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mkstemp(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__chown__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  chown(x, arg2, arg3);
 }
 
-void test__mkstemp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mkstemp(p);
-    // cppcheck-suppress memleak
+void test__chown__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  chown(arg1, x, arg3);
 }
 
-void test__mkstemp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mkstemp(NULL);
+void test__chown__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  chown(arg1, arg2, x);
 }
 
-void test__mkstemp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    mkstemp(x);
+void test__lchown__noreturn() {
+  int x = 1;
+  if (cond) { x=100; lchown(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mkdtemp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mkdtemp(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__lchown__leakignore() {
+  char *p = malloc(10); *p=0;
+  lchown(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__mkdtemp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mkdtemp(p);
-    // cppcheck-suppress memleak
+void test__lchown__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  lchown(NULL, arg2, arg3);
 }
 
-void test__mkdtemp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mkdtemp(NULL);
+void test__lchown__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  lchown(x, arg2, arg3);
 }
 
-void test__mkdtemp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    mkdtemp(x);
+void test__lchown__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  lchown(arg1, x, arg3);
 }
 
-void test__mktemp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = mktemp(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__lchown__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  lchown(arg1, arg2, x);
 }
 
-void test__mktemp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    mktemp(arg1);
+void test__fchown__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fchown(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mktemp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = mktemp(p);
-    // cppcheck-suppress memleak
+void test__fchown__leakignore() {
+  char *p = malloc(10); *p=0;
+  fchown(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__mktemp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = mktemp(NULL);
+void test__fchown__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fchown(x, arg2, arg3);
 }
 
-void test__mktemp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = mktemp(x);
+void test__fchown__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fchown(arg1, x, arg3);
 }
 
-void test__getcwd__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getcwd(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fchown__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fchown(arg1, arg2, x);
 }
 
-void test__getcwd__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getcwd(p, arg2);
-    // cppcheck-suppress memleak
+void test__times__noreturn() {
+  int x = 1;
+  if (cond) { x=100; times(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getcwd__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getcwd(x, arg2);
+void test__times__leakignore() {
+  char *p = malloc(10); *p=0;
+  times(p);
+  // cppcheck-suppress memleak
 }
 
-void test__getcwd__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getcwd(arg1, x);
+void test__times__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  times(x);
 }
 
-void test__mkdir__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mkdir(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__utime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; utime(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mkdir__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mkdir(p, arg2);
-    // cppcheck-suppress memleak
+void test__utime__leakignore() {
+  char *p = malloc(10); *p=0;
+  utime(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__mkdir__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mkdir(NULL, arg2);
+void test__utime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  utime(NULL, arg2);
 }
 
-void test__mkdir__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    mkdir(x, arg2);
+void test__utime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  utime(x, arg2);
 }
 
-void test__mkdir__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mkdir(arg1, x);
+void test__utime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  utime(arg1, x);
 }
 
-void test__rmdir__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        rmdir(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__utimes__noreturn() {
+  int x = 1;
+  if (cond) { x=100; utimes(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__rmdir__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    rmdir(p);
-    // cppcheck-suppress memleak
+void test__utimes__leakignore() {
+  char *p = malloc(10); *p=0;
+  utimes(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__rmdir__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    rmdir(NULL);
+void test__utimes__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  utimes(NULL, arg2);
 }
 
-void test__rmdir__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    rmdir(x);
+void test__utimes__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  utimes(x, arg2);
 }
 
-void test__chdir__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        chdir(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__utimes__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  utimes(arg1, x);
 }
 
-void test__chdir__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    chdir(p);
-    // cppcheck-suppress memleak
+void test__opendir__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = opendir(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__chdir__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    chdir(NULL);
+void test__opendir__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  opendir(arg1);
 }
 
-void test__chdir__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    chdir(x);
+void test__opendir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = opendir(NULL);
 }
 
-void test__chroot__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        chroot(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__opendir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = opendir(x);
 }
 
-void test__chroot__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    chroot(p);
-    // cppcheck-suppress memleak
+void test__fdopendir__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fdopendir(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__chroot__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    chroot(NULL);
+void test__fdopendir__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fdopendir(arg1);
 }
 
-void test__chroot__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    chroot(x);
+void test__fdopendir__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdopendir(x);
 }
 
-void test__link__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        link(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isatty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isatty(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__link__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    link(p, arg2);
-    // cppcheck-suppress memleak
+void test__isatty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isatty(arg1);
 }
 
-void test__link__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    link(NULL, arg2);
+void test__isatty__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isatty(p);
+  // cppcheck-suppress memleak
 }
 
-void test__link__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    link(x, arg2);
+void test__isatty__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isatty(x);
 }
 
-void test__link__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    link(arg1, NULL);
+void test__popen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = popen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__link__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    link(arg1, x);
+void test__popen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  popen(arg1, arg2);
 }
 
-void test__unlink__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        unlink(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__popen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = popen(NULL, arg2);
 }
 
-void test__unlink__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    unlink(p);
-    // cppcheck-suppress memleak
+void test__popen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = popen(x, arg2);
 }
 
-void test__unlink__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    unlink(NULL);
+void test__popen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = popen(arg1, NULL);
 }
 
-void test__unlink__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    unlink(x);
+void test__popen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = popen(arg1, x);
 }
 
-void test__rename__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        rename(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__pclose__noreturn() {
+  int x = 1;
+  if (cond) { x=100; pclose(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__rename__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    rename(p);
-    // cppcheck-suppress memleak
+void test__pclose__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  pclose(NULL);
 }
 
-void test__rename__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    rename(NULL);
+void test__pclose__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  pclose(x);
 }
 
-void test__rename__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    rename(x);
+void test__socket__noreturn() {
+  int x = 1;
+  if (cond) { x=100; socket(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        stat(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__socket__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  socket(x, arg2, arg3);
 }
 
-void test__stat__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    stat(p, arg2);
-    // cppcheck-suppress memleak
+void test__socket__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  socket(arg1, x, arg3);
 }
 
-void test__stat__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    stat(NULL, arg2);
+void test__socket__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  socket(arg1, arg2, x);
 }
 
-void test__stat__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    stat(x, arg2);
+void test__nice__noreturn() {
+  int x = 1;
+  if (cond) { x=100; nice(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    stat(arg1, NULL);
+void test__nice__leakignore() {
+  char *p = malloc(10); *p=0;
+  nice(p);
+  // cppcheck-suppress memleak
 }
 
-void test__lstat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        lstat(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__nice__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  nice(x);
 }
 
-void test__lstat__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    lstat(p, arg2);
-    // cppcheck-suppress memleak
+void test__pause__noreturn() {
+  int x = 1;
+  if (cond) { x=100; pause(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__lstat__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    lstat(NULL, arg2);
+void test__pause__leakignore() {
+  char *p = malloc(10); *p=0;
+  pause();
+  // cppcheck-suppress memleak
 }
 
-void test__lstat__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    lstat(x, arg2);
+void test__close__noreturn() {
+  int x = 1;
+  if (cond) { x=100; close(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__lstat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    lstat(arg1, NULL);
+void test__close__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  close(x);
 }
 
-void test__fstat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fstat(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__confstr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; confstr(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fstat__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fstat(p, arg2);
-    // cppcheck-suppress memleak
+void test__confstr__leakignore() {
+  char *p = malloc(10); *p=0;
+  confstr(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__fstat__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fstat(x, arg2);
+void test__confstr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  confstr(x, arg2, arg3);
 }
 
-void test__fstat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fstat(arg1, NULL);
+void test__confstr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  confstr(arg1, x, arg3);
 }
 
-void test__chmod__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        chmod(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__confstr__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  confstr(arg1, arg2, x);
 }
 
-void test__chmod__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    chmod(p, arg2);
-    // cppcheck-suppress memleak
+void test__fpathconf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fpathconf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__chmod__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    chmod(NULL, arg2);
+void test__fpathconf__leakignore() {
+  char *p = malloc(10); *p=0;
+  fpathconf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__chmod__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    chmod(x, arg2);
+void test__fpathconf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fpathconf(x, arg2);
 }
 
-void test__chmod__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    chmod(arg1, x);
+void test__fpathconf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fpathconf(arg1, x);
 }
 
-void test__fchmod__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fchmod(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__pathconf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; pathconf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fchmod__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fchmod(p, arg2);
-    // cppcheck-suppress memleak
+void test__pathconf__leakignore() {
+  char *p = malloc(10); *p=0;
+  pathconf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__fchmod__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fchmod(x, arg2);
+void test__pathconf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  pathconf(NULL, arg2);
 }
 
-void test__fchmod__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fchmod(arg1, x);
+void test__pathconf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  pathconf(x, arg2);
 }
 
-void test__chown__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        chown(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__pathconf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  pathconf(arg1, x);
 }
 
-void test__chown__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    chown(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__sysconf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sysconf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__chown__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    chown(NULL, arg2, arg3);
+void test__sysconf__leakignore() {
+  char *p = malloc(10); *p=0;
+  sysconf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__chown__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    chown(x, arg2, arg3);
+void test__sysconf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sysconf(x);
 }
 
-void test__chown__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    chown(arg1, x, arg3);
+void test__fdopen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fdopen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__chown__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    chown(arg1, arg2, x);
+void test__fdopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fdopen(arg1, arg2);
 }
 
-void test__lchown__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        lchown(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fdopen__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdopen(x, arg2);
 }
 
-void test__lchown__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    lchown(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__fdopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fdopen(arg1, NULL);
 }
 
-void test__lchown__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    lchown(NULL, arg2, arg3);
+void test__fdopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fdopen(arg1, x);
 }
 
-void test__lchown__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    lchown(x, arg2, arg3);
+void test__random__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = random(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__lchown__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    lchown(arg1, x, arg3);
+void test__random__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  random();
 }
 
-void test__lchown__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    lchown(arg1, arg2, x);
+void test__srandom__noreturn() {
+  int x = 1;
+  if (cond) { x=100; srandom(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fchown__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fchown(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__rewinddir__noreturn() {
+  int x = 1;
+  if (cond) { x=100; rewinddir(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fchown__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fchown(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__rewinddir__leakignore() {
+  char *p = malloc(10); *p=0;
+  rewinddir(p);
+  // cppcheck-suppress memleak
 }
 
-void test__fchown__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fchown(x, arg2, arg3);
+void test__rewinddir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  rewinddir(NULL);
 }
 
-void test__fchown__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fchown(arg1, x, arg3);
+void test__rewinddir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  rewinddir(x);
 }
 
-void test__fchown__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fchown(arg1, arg2, x);
+void test__seekdir__noreturn() {
+  int x = 1;
+  if (cond) { x=100; seekdir(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__times__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        times(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__seekdir__leakignore() {
+  char *p = malloc(10); *p=0;
+  seekdir(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__times__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    times(p);
-    // cppcheck-suppress memleak
+void test__seekdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  seekdir(NULL, arg2);
 }
 
-void test__times__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    times(x);
+void test__seekdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  seekdir(x, arg2);
 }
 
-void test__utime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        utime(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__seekdir__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  seekdir(arg1, x);
 }
 
-void test__utime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    utime(p, arg2);
-    // cppcheck-suppress memleak
+void test__rand_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; rand_r(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__utime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    utime(NULL, arg2);
+void test__rand_r__leakignore() {
+  char *p = malloc(10); *p=0;
+  rand_r(p);
+  // cppcheck-suppress memleak
 }
 
-void test__utime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    utime(x, arg2);
+void test__rand_r__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  rand_r(NULL);
 }
 
-void test__utime__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    utime(arg1, x);
+void test__strcasecmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strcasecmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__utimes__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        utimes(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strcasecmp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strcasecmp(arg1, arg2) > 10) || (strcasecmp(arg1, arg2) < 100)) {}
 }
 
-void test__utimes__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    utimes(p, arg2);
-    // cppcheck-suppress memleak
+void test__strcasecmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  strcasecmp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__utimes__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    utimes(NULL, arg2);
+void test__strcasecmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strcasecmp(NULL, arg2);
 }
 
-void test__utimes__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    utimes(x, arg2);
+void test__strcasecmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strcasecmp(x, arg2);
 }
 
-void test__utimes__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    utimes(arg1, x);
+void test__strcasecmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strcasecmp(arg1, NULL);
 }
 
-void test__opendir__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = opendir(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strcasecmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strcasecmp(arg1, x);
 }
 
-void test__opendir__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    opendir(arg1);
+void test__strncasecmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strncasecmp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__opendir__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = opendir(NULL);
+void test__strncasecmp__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strncasecmp(arg1, arg2, arg3) > 10) || (strncasecmp(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__opendir__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = opendir(x);
+void test__strncasecmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  strncasecmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__fdopendir__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fdopendir(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strncasecmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strncasecmp(NULL, arg2, arg3);
 }
 
-void test__fdopendir__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fdopendir(arg1);
+void test__strncasecmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strncasecmp(x, arg2, arg3);
 }
 
-void test__fdopendir__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fdopendir(x);
+void test__strncasecmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strncasecmp(arg1, NULL, arg3);
 }
 
-void test__isatty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isatty(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strncasecmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strncasecmp(arg1, x, arg3);
 }
 
-void test__isatty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isatty(arg1);
+void test__strncasecmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  strncasecmp(arg1, arg2, !x);
 }
 
-void test__isatty__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isatty(p);
-    // cppcheck-suppress memleak
+void test__read__leakignore() {
+  char *p = malloc(10); *p=0;
+  read(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__isatty__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isatty(x);
+void test__read__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  read(x, arg2, arg3);
 }
 
-void test__popen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = popen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__read__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  read(arg1, arg2, x);
 }
 
-void test__popen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    popen(arg1, arg2);
+void test__write__noreturn() {
+  int x = 1;
+  if (cond) { x=100; write(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__popen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = popen(NULL, arg2);
+void test__write__leakignore() {
+  char *p = malloc(10); *p=0;
+  write(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__popen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = popen(x, arg2);
+void test__write__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  write(x, arg2, arg3);
 }
 
-void test__popen__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = popen(arg1, NULL);
+void test__write__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  write(arg1, x, arg3);
 }
 
-void test__popen__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = popen(arg1, x);
+void test__write__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  write(arg1, arg2, x);
 }
 
-void test__pclose__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        pclose(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__recv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recv(x, arg2, arg3, arg4);
 }
 
-void test__pclose__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    pclose(NULL);
+void test__recv__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recv(arg1, arg2, x, arg4);
 }
 
-void test__pclose__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    pclose(x);
+void test__recv__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recv(arg1, arg2, arg3, x);
 }
 
-void test__socket__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        socket(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__recvfrom__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recvfrom(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__socket__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    socket(x, arg2, arg3);
+void test__recvfrom__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recvfrom(arg1, arg2, x, arg4, arg5, arg6);
 }
-
-void test__socket__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    socket(arg1, x, arg3);
+
+void test__recvfrom__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recvfrom(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__socket__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    socket(arg1, arg2, x);
+void test__recvmsg__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recvmsg(x, arg2, arg3);
 }
 
-void test__nice__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        nice(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__recvmsg__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recvmsg(arg1, arg2, x);
 }
 
-void test__nice__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    nice(p);
-    // cppcheck-suppress memleak
-}
-
-void test__nice__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    nice(x);
-}
-
-void test__pause__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        pause();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__send__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  send(x, arg2, arg3, arg4);
 }
-
-void test__pause__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    pause();
-    // cppcheck-suppress memleak
-}
-
-void test__close__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        close(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__close__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    close(x);
-}
-
-void test__confstr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        confstr(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__confstr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    confstr(p, arg2, arg3);
-    // cppcheck-suppress memleak
-}
-
-void test__confstr__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    confstr(x, arg2, arg3);
-}
-
-void test__confstr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    confstr(arg1, x, arg3);
-}
-
-void test__confstr__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    confstr(arg1, arg2, x);
-}
-
-void test__fpathconf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fpathconf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__fpathconf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fpathconf(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__fpathconf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fpathconf(x, arg2);
-}
-
-void test__fpathconf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fpathconf(arg1, x);
+
+void test__send__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  send(arg1, arg2, x, arg4);
 }
 
-void test__pathconf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        pathconf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__pathconf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    pathconf(p, arg2);
-    // cppcheck-suppress memleak
+void test__send__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  send(arg1, arg2, arg3, x);
 }
 
-void test__pathconf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    pathconf(NULL, arg2);
+void test__sendto__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendto(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__pathconf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    pathconf(x, arg2);
+void test__sendto__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendto(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__pathconf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    pathconf(arg1, x);
-}
-
-void test__sysconf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sysconf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sendto__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendto(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__sysconf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sysconf(p);
-    // cppcheck-suppress memleak
+void test__sendmsg__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendmsg(x, arg2, arg3);
 }
 
-void test__sysconf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sysconf(x);
+void test__sendmsg__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendmsg(arg1, x, arg3);
 }
 
-void test__fdopen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fdopen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sendmsg__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendmsg(arg1, arg2, x);
 }
 
-void test__fdopen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fdopen(arg1, arg2);
+void test__mmap__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = mmap(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fdopen__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fdopen(x, arg2);
+void test__mmap__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  mmap(arg1, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__fdopen__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = fdopen(arg1, NULL);
+void test__mmap__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = mmap(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
 }
 
-void test__fdopen__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = fdopen(arg1, x);
+void test__mmap__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__random__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = random();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mmap__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__random__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    random();
+void test__mmap__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__srandom__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        srandom(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mmap__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__rewinddir__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        rewinddir(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__rewinddir__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    rewinddir(p);
-    // cppcheck-suppress memleak
+void test__mmap__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__rewinddir__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    rewinddir(NULL);
+void test__mmap__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__rewinddir__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    rewinddir(x);
+void test__mmap64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = mmap64(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__seekdir__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        seekdir(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mmap64__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  mmap64(arg1, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__seekdir__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    seekdir(p, arg2);
-    // cppcheck-suppress memleak
+void test__mmap64__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = mmap64(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
 }
 
-void test__seekdir__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    seekdir(NULL, arg2);
+void test__mmap64__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap64(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__seekdir__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    seekdir(x, arg2);
+void test__mmap64__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap64(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__seekdir__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    seekdir(arg1, x);
+void test__mmap64__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap64(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__rand_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        rand_r(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mmap64__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap64(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__rand_r__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    rand_r(p);
-    // cppcheck-suppress memleak
+void test__mmap64__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap64(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__rand_r__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    rand_r(NULL);
+void test__mmap64__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap64(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__strcasecmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strcasecmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__munmap__noreturn() {
+  int x = 1;
+  if (cond) { x=100; munmap(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strcasecmp__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((strcasecmp(arg1, arg2) > 10) || (strcasecmp(arg1, arg2) < 100)) {}
+void test__munmap__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  munmap(NULL, arg2);
 }
 
-void test__strcasecmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strcasecmp(p, arg2);
-    // cppcheck-suppress memleak
+void test__munmap__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  munmap(x, arg2);
 }
 
-void test__strcasecmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strcasecmp(NULL, arg2);
+void test__munmap__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  munmap(arg1, x);
 }
 
-void test__strcasecmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strcasecmp(x, arg2);
+void test__openlog__noreturn() {
+  int x = 1;
+  if (cond) { x=100; openlog(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strcasecmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strcasecmp(arg1, NULL);
+void test__openlog__leakignore() {
+  char *p = malloc(10); *p=0;
+  openlog(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__strcasecmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strcasecmp(arg1, x);
+void test__openlog__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  openlog(x, arg2, arg3);
 }
 
-void test__strncasecmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strncasecmp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__openlog__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  openlog(arg1, x, arg3);
 }
 
-void test__strncasecmp__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((strncasecmp(arg1, arg2, arg3) > 10) || (strncasecmp(arg1, arg2, arg3) < 100)) {}
+void test__openlog__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  openlog(arg1, arg2, x);
 }
 
-void test__strncasecmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strncasecmp(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__fcntl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fcntl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strncasecmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strncasecmp(NULL, arg2, arg3);
+void test__fcntl__leakignore() {
+  char *p = malloc(10); *p=0;
+  fcntl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__strncasecmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strncasecmp(x, arg2, arg3);
+void test__fcntl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fcntl(x, arg2);
 }
 
-void test__strncasecmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strncasecmp(arg1, NULL, arg3);
+void test__fcntl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fcntl(arg1, x);
 }
 
-void test__strncasecmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strncasecmp(arg1, x, arg3);
+void test__ioctl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ioctl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strncasecmp__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    strncasecmp(arg1, arg2, !x);
+void test__ioctl__leakignore() {
+  char *p = malloc(10); *p=0;
+  ioctl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__read__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    read(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__ioctl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ioctl(x, arg2);
 }
 
-void test__read__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    read(x, arg2, arg3);
+void test__ioctl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ioctl(arg1, x);
 }
 
-void test__read__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    read(arg1, arg2, x);
+void test__syslog__noreturn() {
+  int x = 1;
+  if (cond) { x=100; syslog(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__write__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        write(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__syslog__leakignore() {
+  char *p = malloc(10); *p=0;
+  syslog(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__write__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    write(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__syslog__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  syslog(x, arg2);
 }
 
-void test__write__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    write(x, arg2, arg3);
+void test__vsyslog__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vsyslog(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__write__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    write(arg1, x, arg3);
+void test__vsyslog__leakignore() {
+  char *p = malloc(10); *p=0;
+  vsyslog(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__write__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    write(arg1, arg2, x);
+void test__vsyslog__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vsyslog(x, arg2);
 }
 
-void test__recv__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    recv(x, arg2, arg3, arg4);
+void test__getgid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getgid(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__recv__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    recv(arg1, arg2, x, arg4);
+void test__getgid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getgid();
 }
 
-void test__recv__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    recv(arg1, arg2, arg3, x);
+void test__getegid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getegid(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__recvfrom__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    recvfrom(x, arg2, arg3, arg4, arg5, arg6);
+void test__getegid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getegid();
 }
 
-void test__recvfrom__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    recvfrom(arg1, arg2, x, arg4, arg5, arg6);
+void test__getuid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getuid(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__recvfrom__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    recvfrom(arg1, arg2, arg3, x, arg5, arg6);
+void test__getuid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getuid();
 }
 
-void test__recvmsg__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    recvmsg(x, arg2, arg3);
+void test__getuid__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getuid();
+  // cppcheck-suppress memleak
 }
 
-void test__recvmsg__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    recvmsg(arg1, arg2, x);
+void test__getsid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getsid(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__send__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    send(x, arg2, arg3, arg4);
+void test__getsid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getsid(arg1);
 }
 
-void test__send__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    send(arg1, arg2, x, arg4);
+void test__getsid__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getsid(p);
+  // cppcheck-suppress memleak
 }
 
-void test__send__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    send(arg1, arg2, arg3, x);
+void test__getsid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getsid(x);
 }
 
-void test__sendto__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sendto(x, arg2, arg3, arg4, arg5, arg6);
+void test__geteuid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = geteuid(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sendto__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sendto(arg1, arg2, x, arg4, arg5, arg6);
+void test__geteuid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  geteuid();
 }
 
-void test__sendto__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sendto(arg1, arg2, arg3, x, arg5, arg6);
+void test__geteuid__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = geteuid();
+  // cppcheck-suppress memleak
 }
 
-void test__sendmsg__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sendmsg(x, arg2, arg3);
+void test__getppid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getppid(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sendmsg__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sendmsg(arg1, x, arg3);
+void test__getppid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getppid();
 }
 
-void test__sendmsg__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sendmsg(arg1, arg2, x);
+void test__getppid__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getppid();
+  // cppcheck-suppress memleak
 }
 
-void test__mmap__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = mmap(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getpid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getpid(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mmap__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    mmap(arg1, arg2, arg3, arg4, arg5, arg6);
+void test__getpid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getpid();
 }
 
-void test__mmap__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = mmap(p, arg2, arg3, arg4, arg5, arg6);
-    // cppcheck-suppress memleak
+void test__getpid__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getpid();
+  // cppcheck-suppress memleak
 }
 
-void test__mmap__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = mmap(x, arg2, arg3, arg4, arg5, arg6);
+void test__getpgrp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getpgrp(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mmap__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = mmap(arg1, x, arg3, arg4, arg5, arg6);
+void test__getpgrp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getpgrp();
 }
 
-void test__mmap__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = mmap(arg1, arg2, x, arg4, arg5, arg6);
+void test__getpgrp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getpgrp();
+  // cppcheck-suppress memleak
 }
 
-void test__mmap__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = mmap(arg1, arg2, arg3, x, arg5, arg6);
+void test__getpgid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getpgid(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mmap__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = mmap(arg1, arg2, arg3, arg4, x, arg6);
+void test__getpgid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getpgid(arg1);
 }
 
-void test__mmap__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = mmap(arg1, arg2, arg3, arg4, arg5, x);
+void test__getpgid__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getpgid(p);
+  // cppcheck-suppress memleak
 }
 
-void test__mmap64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = mmap64(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getpgid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getpgid(x);
 }
 
-void test__mmap64__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    mmap64(arg1, arg2, arg3, arg4, arg5, arg6);
+void test__setuid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = setuid(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mmap64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = mmap64(p, arg2, arg3, arg4, arg5, arg6);
-    // cppcheck-suppress memleak
+void test__setuid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  setuid(arg1);
 }
 
-void test__mmap64__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = mmap64(x, arg2, arg3, arg4, arg5, arg6);
+void test__setuid__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = setuid(p);
+  // cppcheck-suppress memleak
 }
 
-void test__mmap64__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = mmap64(arg1, x, arg3, arg4, arg5, arg6);
+void test__setuid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = setuid(x);
 }
 
-void test__mmap64__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = mmap64(arg1, arg2, x, arg4, arg5, arg6);
+void test__seteuid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = seteuid(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mmap64__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = mmap64(arg1, arg2, arg3, x, arg5, arg6);
+void test__seteuid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  seteuid(arg1);
 }
 
-void test__mmap64__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = mmap64(arg1, arg2, arg3, arg4, x, arg6);
+void test__seteuid__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = seteuid(p);
+  // cppcheck-suppress memleak
 }
 
-void test__mmap64__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = mmap64(arg1, arg2, arg3, arg4, arg5, x);
+void test__seteuid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = seteuid(x);
 }
 
-void test__munmap__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        munmap(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__setgid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = setgid(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__munmap__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    munmap(NULL, arg2);
+void test__setgid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  setgid(arg1);
 }
 
-void test__munmap__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    munmap(x, arg2);
+void test__setgid__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = setgid(p);
+  // cppcheck-suppress memleak
 }
 
-void test__munmap__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    munmap(arg1, x);
+void test__setgid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = setgid(x);
 }
 
-void test__openlog__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        openlog(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__setegid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = setegid(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__openlog__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    openlog(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__setegid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  setegid(arg1);
 }
 
-void test__openlog__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    openlog(x, arg2, arg3);
+void test__setegid__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = setegid(p);
+  // cppcheck-suppress memleak
 }
 
-void test__openlog__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    openlog(arg1, x, arg3);
+void test__setegid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = setegid(x);
 }
 
-void test__openlog__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    openlog(arg1, arg2, x);
+void test__setpgid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setpgid(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fcntl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fcntl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__setpgid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setpgid(x, arg2);
+}
 
-void test__fcntl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fcntl(p, arg2);
-    // cppcheck-suppress memleak
+void test__setpgid__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setpgid(arg1, x);
 }
 
-void test__fcntl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fcntl(x, arg2);
-}
-
-void test__fcntl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fcntl(arg1, x);
-}
-
-void test__ioctl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ioctl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__ioctl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ioctl(p, arg2);
-    // cppcheck-suppress memleak
-}
+void test__pipe__noreturn() {
+  int x = 1;
+  if (cond) { x=100; pipe(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__ioctl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ioctl(x, arg2);
-}
-
-void test__ioctl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ioctl(arg1, x);
-}
-
-void test__syslog__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        syslog(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__setpgrp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setpgrp(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__syslog__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    syslog(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__syslog__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    syslog(x, arg2);
-}
-
-void test__vsyslog__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vsyslog(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__vsyslog__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vsyslog(p, arg2);
-    // cppcheck-suppress memleak
+void test__setregid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setregid(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__vsyslog__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    vsyslog(x, arg2);
-}
-
-void test__getgid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getgid();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__getgid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getgid();
-}
-
-void test__getegid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getegid();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__getegid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getegid();
+
+void test__setregid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setregid(x, arg2);
 }
-
-void test__getuid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getuid();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__getuid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getuid();
-}
-
-void test__getuid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getuid();
-    // cppcheck-suppress memleak
+
+void test__setregid__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setregid(arg1, x);
 }
-
-void test__getsid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getsid(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__getsid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getsid(arg1);
-}
-
-void test__getsid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getsid(p);
-    // cppcheck-suppress memleak
+
+void test__setreuid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setreuid(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getsid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getsid(x);
-}
+void test__setreuid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setreuid(x, arg2);
+}
+
+void test__setreuid__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setreuid(arg1, x);
+}
+
+void test__setfsuid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setfsuid(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setfsuid__leakignore() {
+  char *p = malloc(10); *p=0;
+  setfsuid(p);
+  // cppcheck-suppress memleak
+}
 
-void test__geteuid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = geteuid();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__geteuid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    geteuid();
-}
+void test__setfsuid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setfsuid(x);
+}
 
-void test__geteuid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = geteuid();
-    // cppcheck-suppress memleak
-}
+void test__setfsgid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setfsgid(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setfsgid__leakignore() {
+  char *p = malloc(10); *p=0;
+  setfsgid(p);
+  // cppcheck-suppress memleak
+}
+
+void test__setfsgid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setfsgid(x);
+}
+
+void test__setsid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setsid(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__getppid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getppid();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getwd__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getwd(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getppid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getppid();
-}
-
-void test__getppid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getppid();
-    // cppcheck-suppress memleak
+void test__getwd__leakignore() {
+  char *p = malloc(10); *p=0;
+  getwd(p);
+  // cppcheck-suppress memleak
 }
 
-void test__getpid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getpid();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__getpid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getpid();
+void test__getwd__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getwd(NULL);
 }
 
-void test__getpid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getpid();
-    // cppcheck-suppress memleak
-}
+void test__htonl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; htonl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__getpgrp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getpgrp();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__getpgrp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getpgrp();
+void test__htonl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  htonl(x);
 }
 
-void test__getpgrp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getpgrp();
-    // cppcheck-suppress memleak
+void test__htons__noreturn() {
+  int x = 1;
+  if (cond) { x=100; htons(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__getpgid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getpgid(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__htons__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  htons(x);
 }
-
-void test__getpgid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getpgid(arg1);
+
+void test__ntohl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ntohl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__getpgid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getpgid(p);
-    // cppcheck-suppress memleak
+
+void test__ntohl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ntohl(x);
 }
-
-void test__getpgid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getpgid(x);
+
+void test__ntohs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ntohs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__setuid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = setuid(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__setuid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    setuid(arg1);
+void test__ntohs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ntohs(x);
 }
 
-void test__setuid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = setuid(p);
-    // cppcheck-suppress memleak
+void test__mq_close__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mq_close(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__setuid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = setuid(x);
+void test__mq_close__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mq_close(x);
 }
 
-void test__seteuid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = seteuid(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mq_getattr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mq_getattr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__seteuid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    seteuid(arg1);
+
+void test__mq_getattr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mq_getattr(x, arg2);
 }
 
-void test__seteuid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = seteuid(p);
-    // cppcheck-suppress memleak
+void test__mq_notify__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mq_notify(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__seteuid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = seteuid(x);
-}
+void test__mq_notify__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mq_notify(NULL, arg2);
+}
 
-void test__setgid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = setgid(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__mq_notify__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mq_notify(x, arg2);
+}
 
-void test__setgid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    setgid(arg1);
-}
-
-void test__setgid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = setgid(p);
-    // cppcheck-suppress memleak
-}
-
-void test__setgid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = setgid(x);
-}
-
-void test__setegid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = setegid(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__setegid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    setegid(arg1);
-}
-
-void test__setegid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = setegid(p);
-    // cppcheck-suppress memleak
-}
-
-void test__setegid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = setegid(x);
-}
-
-void test__setpgid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setpgid(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__setpgid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setpgid(x, arg2);
-}
-
-void test__setpgid__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setpgid(arg1, x);
-}
-
-void test__pipe__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        pipe();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__setpgrp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setpgrp();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__setregid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setregid(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__setregid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setregid(x, arg2);
-}
-
-void test__setregid__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setregid(arg1, x);
-}
-
-void test__setreuid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setreuid(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__setreuid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setreuid(x, arg2);
-}
-
-void test__setreuid__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setreuid(arg1, x);
-}
-
-void test__setfsuid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setfsuid(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__setfsuid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setfsuid(p);
-    // cppcheck-suppress memleak
-}
-
-void test__setfsuid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setfsuid(x);
-}
-
-void test__setfsgid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setfsgid(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__setfsgid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setfsgid(p);
-    // cppcheck-suppress memleak
-}
-
-void test__setfsgid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setfsgid(x);
-}
-
-void test__setsid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setsid();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__getwd__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getwd(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__getwd__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getwd(p);
-    // cppcheck-suppress memleak
-}
-
-void test__getwd__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getwd(NULL);
-}
-
-void test__htonl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        htonl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__htonl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    htonl(x);
-}
-
-void test__htons__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        htons(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__htons__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    htons(x);
-}
-
-void test__ntohl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ntohl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__ntohl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ntohl(x);
-}
-
-void test__ntohs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ntohs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__ntohs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ntohs(x);
-}
-
-void test__mq_close__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mq_close(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__mq_close__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mq_close(x);
-}
-
-void test__mq_getattr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mq_getattr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__mq_getattr__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mq_getattr(x, arg2);
-}
-
-void test__mq_notify__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mq_notify(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__mq_notify__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mq_notify(NULL, arg2);
-}
-
-void test__mq_notify__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    mq_notify(x, arg2);
-}
-
-void test__mq_open__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mq_open();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__mq_receive__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mq_receive(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__mq_receive__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mq_receive(x, arg2, arg3, arg4);
-}
-
-void test__mq_send__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mq_send(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__mq_send__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mq_send(x, arg2, arg3, arg4);
-}
-
-void test__mq_setattr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mq_setattr(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__mq_setattr__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mq_setattr(x, arg2, arg3);
-}
-
-void test__mq_timedreceive__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mq_timedreceive(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__mq_timedreceive__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mq_timedreceive(x, arg2, arg3, arg4, arg5);
-}
-
-void test__mq_timedsend__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mq_timedsend(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__mq_timedsend__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mq_timedsend(x, arg2, arg3, arg4, arg5);
-}
-
-void test__mq_unlink__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mq_unlink(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__mq_unlink__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mq_unlink(NULL);
-}
-
-void test__mq_unlink__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    mq_unlink(x);
-}
-
-void test__dbm_clearerr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        dbm_clearerr(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mq_open__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mq_open(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__dbm_clearerr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    dbm_clearerr(NULL);
-}
-
-void test__dbm_clearerr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    dbm_clearerr(x);
-}
-
-void test__dbm_close__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        dbm_close(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mq_receive__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mq_receive(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__dbm_close__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    dbm_close(NULL);
+void test__mq_receive__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mq_receive(x, arg2, arg3, arg4);
 }
 
-void test__dbm_close__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    dbm_close(x);
+void test__mq_send__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mq_send(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__dbm_delete__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        dbm_delete(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mq_send__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mq_send(x, arg2, arg3, arg4);
 }
 
-void test__dbm_delete__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    dbm_delete(NULL, arg2);
+void test__mq_setattr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mq_setattr(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__dbm_delete__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    dbm_delete(x, arg2);
+void test__mq_setattr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mq_setattr(x, arg2, arg3);
 }
 
-void test__dbm_delete__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    dbm_delete(arg1, x);
+void test__mq_timedreceive__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mq_timedreceive(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__dbm_error__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = dbm_error(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mq_timedreceive__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mq_timedreceive(x, arg2, arg3, arg4, arg5);
 }
 
-void test__dbm_error__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    dbm_error(arg1);
+void test__mq_timedsend__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mq_timedsend(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__dbm_error__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = dbm_error(NULL);
+void test__mq_timedsend__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mq_timedsend(x, arg2, arg3, arg4, arg5);
 }
 
-void test__dbm_error__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = dbm_error(x);
+void test__mq_unlink__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mq_unlink(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__dbm_fetch__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = dbm_fetch(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mq_unlink__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mq_unlink(NULL);
 }
 
-void test__dbm_fetch__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    dbm_fetch(arg1, arg2);
+void test__mq_unlink__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mq_unlink(x);
 }
 
-void test__dbm_fetch__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = dbm_fetch(NULL, arg2);
+void test__dbm_clearerr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; dbm_clearerr(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__dbm_fetch__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = dbm_fetch(x, arg2);
+void test__dbm_clearerr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  dbm_clearerr(NULL);
 }
 
-void test__dbm_fetch__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = dbm_fetch(arg1, x);
+void test__dbm_clearerr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  dbm_clearerr(x);
 }
 
-void test__dbm_firstkey__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = dbm_firstkey(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__dbm_close__noreturn() {
+  int x = 1;
+  if (cond) { x=100; dbm_close(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__dbm_firstkey__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    dbm_firstkey(arg1);
+void test__dbm_close__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  dbm_close(NULL);
 }
 
-void test__dbm_firstkey__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = dbm_firstkey(NULL);
+void test__dbm_close__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  dbm_close(x);
 }
 
-void test__dbm_firstkey__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = dbm_firstkey(x);
+void test__dbm_delete__noreturn() {
+  int x = 1;
+  if (cond) { x=100; dbm_delete(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__dbm_nextkey__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = dbm_nextkey(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__dbm_delete__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  dbm_delete(NULL, arg2);
 }
 
-void test__dbm_nextkey__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    dbm_nextkey(arg1);
+void test__dbm_delete__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  dbm_delete(x, arg2);
 }
 
-void test__dbm_nextkey__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = dbm_nextkey(NULL);
+void test__dbm_delete__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dbm_delete(arg1, x);
 }
 
-void test__dbm_nextkey__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = dbm_nextkey(x);
+void test__dbm_error__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = dbm_error(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__dbm_open__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        dbm_open(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__dbm_error__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  dbm_error(arg1);
 }
 
-void test__dbm_open__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    dbm_open(NULL, arg2, arg3);
+void test__dbm_error__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = dbm_error(NULL);
 }
 
-void test__dbm_open__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    dbm_open(x, arg2, arg3);
+void test__dbm_error__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = dbm_error(x);
 }
 
-void test__dbm_open__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    dbm_open(arg1, x, arg3);
+void test__dbm_fetch__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = dbm_fetch(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__dbm_open__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    dbm_open(arg1, arg2, x);
+void test__dbm_fetch__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  dbm_fetch(arg1, arg2);
 }
 
-void test__dbm_store__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        dbm_store(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__dbm_fetch__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = dbm_fetch(NULL, arg2);
 }
 
-void test__dbm_store__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    dbm_store(NULL, arg2, arg3, arg4);
+void test__dbm_fetch__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = dbm_fetch(x, arg2);
 }
 
-void test__dbm_store__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    dbm_store(x, arg2, arg3, arg4);
+void test__dbm_fetch__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = dbm_fetch(arg1, x);
 }
 
-void test__dbm_store__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    dbm_store(arg1, x, arg3, arg4);
+void test__dbm_firstkey__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = dbm_firstkey(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__dbm_store__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    dbm_store(arg1, arg2, x, arg4);
+void test__dbm_firstkey__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  dbm_firstkey(arg1);
 }
 
-void test__dbm_store__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    dbm_store(arg1, arg2, arg3, x);
+void test__dbm_firstkey__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = dbm_firstkey(NULL);
 }
 
-void test__freeaddrinfo__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        freeaddrinfo(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__dbm_firstkey__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = dbm_firstkey(x);
 }
 
-void test__freeaddrinfo__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    freeaddrinfo(NULL);
+void test__dbm_nextkey__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = dbm_nextkey(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__freeaddrinfo__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    freeaddrinfo(x);
+
+void test__dbm_nextkey__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  dbm_nextkey(arg1);
 }
 
-void test__getaddrinfo__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getaddrinfo(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__getaddrinfo__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getaddrinfo(x, arg2, arg3, arg4);
-}
-
-void test__getaddrinfo__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getaddrinfo(arg1, x, arg3, arg4);
-}
-
-void test__getaddrinfo__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getaddrinfo(arg1, arg2, x, arg4);
-}
-
-void test__getaddrinfo__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getaddrinfo(arg1, arg2, arg3, x);
+void test__dbm_nextkey__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = dbm_nextkey(NULL);
 }
 
-void test__endhostent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        endhostent();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sethostent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sethostent(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sethostent__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sethostent(x);
-}
-
-void test__uname__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        uname(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__uname__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    uname(NULL);
+void test__dbm_nextkey__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = dbm_nextkey(x);
 }
 
-void test__endpwent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        endpwent();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__getpwent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getpwent();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__dbm_open__noreturn() {
+  int x = 1;
+  if (cond) { x=100; dbm_open(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getpwent__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getpwent();
+void test__dbm_open__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  dbm_open(NULL, arg2, arg3);
 }
 
-void test__getpwnam__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getpwnam(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__dbm_open__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  dbm_open(x, arg2, arg3);
 }
 
-void test__getpwnam__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getpwnam(arg1);
-}
+void test__dbm_open__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dbm_open(arg1, x, arg3);
+}
 
-void test__getpwnam__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getpwnam(x);
+void test__dbm_open__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dbm_open(arg1, arg2, x);
 }
 
-void test__strtok_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strtok_r(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__dbm_store__noreturn() {
+  int x = 1;
+  if (cond) { x=100; dbm_store(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strtok_r__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((strtok_r(arg1, arg2, arg3) > 10) || (strtok_r(arg1, arg2, arg3) < 100)) {}
-}
+void test__dbm_store__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  dbm_store(NULL, arg2, arg3, arg4);
+}
 
-void test__strtok_r__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strtok_r(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__dbm_store__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  dbm_store(x, arg2, arg3, arg4);
 }
 
-void test__strtok_r__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strtok_r(x, arg2, arg3);
+void test__dbm_store__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dbm_store(arg1, x, arg3, arg4);
 }
 
-void test__strtok_r__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strtok_r(arg1, NULL, arg3);
+void test__dbm_store__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dbm_store(arg1, arg2, x, arg4);
 }
 
-void test__strtok_r__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strtok_r(arg1, x, arg3);
+void test__dbm_store__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dbm_store(arg1, arg2, arg3, x);
 }
 
-void test__strtok_r__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strtok_r(arg1, arg2, NULL);
-}
-
-void test__getpwnam_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getpwnam_r(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__freeaddrinfo__noreturn() {
+  int x = 1;
+  if (cond) { x=100; freeaddrinfo(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getpwnam_r__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getpwnam_r(arg1, arg2, arg3, arg4, arg5);
+void test__freeaddrinfo__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  freeaddrinfo(NULL);
 }
 
-void test__getpwnam_r__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getpwnam_r(x, arg2, arg3, arg4, arg5);
+void test__freeaddrinfo__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  freeaddrinfo(x);
 }
 
-void test__getpwnam_r__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getpwnam_r(arg1, arg2, arg3, x, arg5);
+void test__getaddrinfo__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getaddrinfo(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getpwuid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getpwuid(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getaddrinfo__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getaddrinfo(x, arg2, arg3, arg4);
 }
 
-void test__getpwuid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getpwuid(arg1);
+void test__getaddrinfo__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getaddrinfo(arg1, x, arg3, arg4);
 }
 
-void test__getpwuid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getpwuid(x);
+void test__getaddrinfo__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getaddrinfo(arg1, arg2, x, arg4);
 }
 
-void test__getpwuid_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getpwuid_r(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getaddrinfo__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getaddrinfo(arg1, arg2, arg3, x);
 }
 
-void test__getpwuid_r__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getpwuid_r(x, arg2, arg3, arg4, arg5);
+void test__endhostent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; endhostent(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getpwuid_r__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getpwuid_r(arg1, arg2, arg3, x, arg5);
+void test__sethostent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sethostent(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__setpwent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setpwent();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sethostent__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sethostent(x);
 }
 
-void test__catclose__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        catclose(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__catclose__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    catclose(x);
+void test__uname__noreturn() {
+  int x = 1;
+  if (cond) { x=100; uname(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__catgets__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = catgets(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__uname__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  uname(NULL);
 }
 
-void test__catgets__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    catgets(arg1, arg2, arg3, arg4);
-}
-
-void test__catgets__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = catgets(x, arg2, arg3, arg4);
-}
-
-void test__catgets__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = catgets(arg1, x, arg3, arg4);
+void test__endpwent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; endpwent(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__catgets__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = catgets(arg1, arg2, x, arg4);
+void test__getpwent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getpwent(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__catgets__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = catgets(arg1, arg2, arg3, x);
+void test__getpwent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getpwent();
 }
 
-void test__catopen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        catopen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getpwnam__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getpwnam(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__catopen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    catopen(NULL, arg2);
+void test__getpwnam__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getpwnam(arg1);
 }
 
-void test__catopen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    catopen(x, arg2);
+void test__getpwnam__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getpwnam(x);
 }
 
-void test__catopen__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    catopen(arg1, x);
+void test__strtok_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strtok_r(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__poll__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        poll(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strtok_r__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strtok_r(arg1, arg2, arg3) > 10) || (strtok_r(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__poll__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    poll(x, arg2, arg3);
+void test__strtok_r__leakignore() {
+  char *p = malloc(10); *p=0;
+  strtok_r(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__poll__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    poll(arg1, x, arg3);
+void test__strtok_r__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtok_r(x, arg2, arg3);
 }
 
-void test__poll__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    poll(arg1, arg2, x);
+void test__strtok_r__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strtok_r(arg1, NULL, arg3);
 }
 
-void test__regcomp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        regcomp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strtok_r__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtok_r(arg1, x, arg3);
 }
 
-void test__regcomp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    regcomp(NULL, arg2, arg3);
+void test__strtok_r__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  strtok_r(arg1, arg2, NULL);
 }
 
-void test__regcomp__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    regcomp(arg1, x, arg3);
+void test__getpwnam_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getpwnam_r(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__regcomp__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    regcomp(arg1, arg2, x);
+void test__getpwnam_r__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getpwnam_r(arg1, arg2, arg3, arg4, arg5);
 }
 
-void test__regerror__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        regerror(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getpwnam_r__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getpwnam_r(x, arg2, arg3, arg4, arg5);
 }
 
-void test__regerror__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    regerror(x, arg2, arg3, arg4);
+void test__getpwnam_r__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getpwnam_r(arg1, arg2, arg3, x, arg5);
 }
 
-void test__regerror__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    regerror(arg1, x, arg3, arg4);
+void test__getpwuid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getpwuid(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__regerror__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    regerror(arg1, arg2, arg3, x);
+void test__getpwuid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getpwuid(arg1);
 }
 
-void test__regexec__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        regexec(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getpwuid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getpwuid(x);
 }
 
-void test__regexec__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    regexec(NULL, arg2, arg3, arg4, arg5);
+void test__getpwuid_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getpwuid_r(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__regexec__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    regexec(x, arg2, arg3, arg4, arg5);
+void test__getpwuid_r__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getpwuid_r(x, arg2, arg3, arg4, arg5);
 }
 
-void test__regexec__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    regexec(arg1, NULL, arg3, arg4, arg5);
+void test__getpwuid_r__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getpwuid_r(arg1, arg2, arg3, x, arg5);
 }
 
-void test__regexec__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    regexec(arg1, x, arg3, arg4, arg5);
+void test__setpwent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setpwent(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__regexec__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    regexec(arg1, arg2, x, arg4, arg5);
+void test__catclose__noreturn() {
+  int x = 1;
+  if (cond) { x=100; catclose(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__regexec__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    regexec(arg1, arg2, arg3, x, arg5);
+void test__catclose__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  catclose(x);
 }
 
-void test__regexec__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    regexec(arg1, arg2, arg3, arg4, x);
+void test__catgets__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = catgets(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__regfree__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        regfree(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__regfree__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    regfree(NULL);
+void test__catgets__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  catgets(arg1, arg2, arg3, arg4);
 }
 
-void test__regfree__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    regfree(x);
+void test__catgets__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = catgets(x, arg2, arg3, arg4);
 }
 
-void test__sched_get_priority_max__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sched_get_priority_max(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__catgets__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = catgets(arg1, x, arg3, arg4);
 }
-
-void test__sched_get_priority_max__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sched_get_priority_max(x);
+
+void test__catgets__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = catgets(arg1, arg2, x, arg4);
 }
-
-void test__sched_get_priority_min__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sched_get_priority_min(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__catgets__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = catgets(arg1, arg2, arg3, x);
 }
 
-void test__sched_get_priority_min__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sched_get_priority_min(x);
-}
-
-void test__sched_getparam__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sched_getparam(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__catopen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; catopen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sched_getparam__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sched_getparam(x, arg2);
+void test__catopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  catopen(NULL, arg2);
 }
 
-void test__sched_getparam__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    sched_getparam(arg1, NULL);
+void test__catopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  catopen(x, arg2);
 }
 
-void test__sched_getscheduler__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sched_getscheduler(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sched_getscheduler__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sched_getscheduler(x);
-}
-
-void test__sched_rr_get_interval__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sched_rr_get_interval(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sched_rr_get_interval__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sched_rr_get_interval(x, arg2);
-}
-
-void test__sched_rr_get_interval__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    sched_rr_get_interval(arg1, NULL);
-}
-
-void test__sched_setparam__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sched_setparam(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sched_setparam__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sched_setparam(x, arg2);
-}
-
-void test__sched_setparam__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sched_setparam(arg1, x);
+void test__catopen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  catopen(arg1, x);
 }
 
-void test__sched_setscheduler__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sched_setscheduler(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__poll__noreturn() {
+  int x = 1;
+  if (cond) { x=100; poll(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__sched_setscheduler__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sched_setscheduler(x, arg2, arg3);
+void test__poll__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  poll(x, arg2, arg3);
 }
 
-void test__sched_setscheduler__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sched_setscheduler(arg1, x, arg3);
+void test__poll__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  poll(arg1, x, arg3);
 }
 
-void test__sched_setscheduler__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sched_setscheduler(arg1, arg2, x);
+void test__poll__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  poll(arg1, arg2, x);
 }
 
-void test__sched_yield__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sched_yield();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__regcomp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; regcomp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ecvt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ecvt(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__regcomp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  regcomp(NULL, arg2, arg3);
 }
 
-void test__ecvt__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ecvt(x, arg2, arg3, arg4);
+void test__regcomp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regcomp(arg1, x, arg3);
 }
 
-void test__ecvt__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ecvt(arg1, x, arg3, arg4);
+void test__regcomp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regcomp(arg1, arg2, x);
 }
 
-void test__ecvt__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ecvt(arg1, arg2, NULL, arg4);
+void test__regerror__noreturn() {
+  int x = 1;
+  if (cond) { x=100; regerror(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ecvt__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ecvt(arg1, arg2, arg3, NULL);
+void test__regerror__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regerror(x, arg2, arg3, arg4);
 }
 
-void test__fcvt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fcvt(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__regerror__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regerror(arg1, x, arg3, arg4);
 }
 
-void test__fcvt__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fcvt(x, arg2, arg3, arg4);
+void test__regerror__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regerror(arg1, arg2, arg3, x);
 }
 
-void test__fcvt__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fcvt(arg1, x, arg3, arg4);
+void test__regexec__noreturn() {
+  int x = 1;
+  if (cond) { x=100; regexec(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fcvt__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fcvt(arg1, arg2, NULL, arg4);
+void test__regexec__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  regexec(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test__fcvt__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fcvt(arg1, arg2, arg3, NULL);
+void test__regexec__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  regexec(x, arg2, arg3, arg4, arg5);
 }
 
-void test__gcvt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        gcvt(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__regexec__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  regexec(arg1, NULL, arg3, arg4, arg5);
 }
 
-void test__gcvt__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    gcvt(x, arg2, arg3);
+void test__regexec__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  regexec(arg1, x, arg3, arg4, arg5);
 }
 
-void test__gcvt__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    gcvt(arg1, x, arg3);
+void test__regexec__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regexec(arg1, arg2, x, arg4, arg5);
 }
 
-void test__gcvt__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    gcvt(arg1, arg2, NULL);
+void test__regexec__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regexec(arg1, arg2, arg3, x, arg5);
 }
 
-void test__lseek__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        lseek(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__regexec__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regexec(arg1, arg2, arg3, arg4, x);
 }
 
-void test__lseek__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    lseek(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__regfree__noreturn() {
+  int x = 1;
+  if (cond) { x=100; regfree(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__lseek__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    lseek(x, arg2, arg3);
+void test__regfree__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  regfree(NULL);
 }
 
-void test__lseek__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    lseek(arg1, x, arg3);
+void test__regfree__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  regfree(x);
 }
 
-void test__lseek__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    lseek(arg1, arg2, x);
+void test__sched_get_priority_max__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sched_get_priority_max(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nanosleep__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        nanosleep(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sched_get_priority_max__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sched_get_priority_max(x);
 }
 
-void test__nanosleep__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    nanosleep(p, arg2);
-    // cppcheck-suppress memleak
+void test__sched_get_priority_min__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sched_get_priority_min(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nanosleep__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    nanosleep(NULL, arg2);
+void test__sched_get_priority_min__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sched_get_priority_min(x);
 }
 
-void test__setkey__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setkey(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sched_getparam__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sched_getparam(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__setkey__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setkey(p);
-    // cppcheck-suppress memleak
+void test__sched_getparam__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sched_getparam(x, arg2);
 }
 
-void test__setkey__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    setkey(NULL);
+void test__sched_getparam__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  sched_getparam(arg1, NULL);
 }
 
-void test__setkey__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    setkey(x);
+void test__sched_getscheduler__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sched_getscheduler(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getpass__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getpass(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sched_getscheduler__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sched_getscheduler(x);
 }
 
-void test__getpass__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getpass(p);
-    // cppcheck-suppress memleak
+void test__sched_rr_get_interval__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sched_rr_get_interval(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getpass__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getpass(NULL);
+void test__sched_rr_get_interval__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sched_rr_get_interval(x, arg2);
 }
 
-void test__drand48__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = drand48();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sched_rr_get_interval__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  sched_rr_get_interval(arg1, NULL);
 }
 
-void test__drand48__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    drand48();
+void test__sched_setparam__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sched_setparam(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__putenv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        putenv(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sched_setparam__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sched_setparam(x, arg2);
 }
 
-void test__putenv__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    putenv(NULL);
+void test__sched_setparam__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sched_setparam(arg1, x);
 }
 
-void test__putenv__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    putenv(x);
+void test__sched_setscheduler__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sched_setscheduler(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__setenv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setenv(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sched_setscheduler__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sched_setscheduler(x, arg2, arg3);
 }
 
-void test__setenv__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    setenv(NULL, arg2, arg3);
+void test__sched_setscheduler__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sched_setscheduler(arg1, x, arg3);
 }
 
-void test__setenv__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    setenv(x, arg2, arg3);
+void test__sched_setscheduler__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sched_setscheduler(arg1, arg2, x);
 }
 
-void test__setenv__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    setenv(arg1, NULL, arg3);
+void test__sched_yield__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sched_yield(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__setenv__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    setenv(arg1, x, arg3);
+void test__ecvt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ecvt(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__setenv__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setenv(arg1, arg2, x);
+void test__ecvt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ecvt(x, arg2, arg3, arg4);
 }
 
-void test__unsetenv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        unsetenv(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ecvt__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ecvt(arg1, x, arg3, arg4);
 }
 
-void test__unsetenv__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    unsetenv(NULL);
+void test__ecvt__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  ecvt(arg1, arg2, NULL, arg4);
 }
 
-void test__unsetenv__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    unsetenv(x);
+void test__ecvt__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  ecvt(arg1, arg2, arg3, NULL);
 }
 
-void test__localtime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        localtime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fcvt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fcvt(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__localtime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    localtime(p);
-    // cppcheck-suppress memleak
+void test__fcvt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fcvt(x, arg2, arg3, arg4);
 }
 
-void test__localtime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    localtime(NULL);
+void test__fcvt__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fcvt(arg1, x, arg3, arg4);
 }
 
-void test__localtime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    localtime(x);
+void test__fcvt__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  fcvt(arg1, arg2, NULL, arg4);
 }
 
-void test__std__localtime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::localtime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fcvt__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  fcvt(arg1, arg2, arg3, NULL);
 }
 
-void test__std__localtime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::localtime(NULL);
+void test__gcvt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; gcvt(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__localtime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::localtime(x);
+void test__gcvt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  gcvt(x, arg2, arg3);
 }
 
-void test__localtime_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        localtime_r(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__gcvt__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  gcvt(arg1, x, arg3);
 }
 
-void test__localtime_r__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    localtime_r(p, arg2);
-    // cppcheck-suppress memleak
+void test__gcvt__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  gcvt(arg1, arg2, NULL);
 }
 
-void test__localtime_r__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    localtime_r(NULL, arg2);
+void test__lseek__noreturn() {
+  int x = 1;
+  if (cond) { x=100; lseek(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__localtime_r__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    localtime_r(x, arg2);
+void test__lseek__leakignore() {
+  char *p = malloc(10); *p=0;
+  lseek(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__localtime_r__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    localtime_r(arg1, NULL);
+void test__lseek__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  lseek(x, arg2, arg3);
 }
 
-void test__readdir__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        readdir(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__lseek__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  lseek(arg1, x, arg3);
 }
 
-void test__readdir__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    readdir(p);
-    // cppcheck-suppress memleak
+void test__lseek__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  lseek(arg1, arg2, x);
 }
 
-void test__readdir__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    readdir(NULL);
+void test__nanosleep__noreturn() {
+  int x = 1;
+  if (cond) { x=100; nanosleep(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__readdir__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    readdir(x);
+void test__nanosleep__leakignore() {
+  char *p = malloc(10); *p=0;
+  nanosleep(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__readdir_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        readdir_r(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__nanosleep__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  nanosleep(NULL, arg2);
 }
 
-void test__readdir_r__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    readdir_r(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__setkey__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setkey(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__readdir_r__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    readdir_r(NULL, arg2, arg3);
+void test__setkey__leakignore() {
+  char *p = malloc(10); *p=0;
+  setkey(p);
+  // cppcheck-suppress memleak
 }
 
-void test__readdir_r__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    readdir_r(x, arg2, arg3);
+void test__setkey__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  setkey(NULL);
 }
 
-void test__readdir_r__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    readdir_r(arg1, NULL, arg3);
+void test__setkey__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  setkey(x);
 }
 
-void test__readdir_r__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    readdir_r(arg1, arg2, NULL);
+void test__getpass__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getpass(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__readlink__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        readlink(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getpass__leakignore() {
+  char *p = malloc(10); *p=0;
+  getpass(p);
+  // cppcheck-suppress memleak
 }
 
-void test__readlink__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    readlink(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__getpass__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getpass(NULL);
 }
 
-void test__readlink__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    readlink(NULL, arg2, arg3);
+void test__drand48__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = drand48(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__readlink__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    readlink(x, arg2, arg3);
+void test__drand48__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  drand48();
 }
 
-void test__readlink__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    readlink(arg1, NULL, arg3);
+void test__putenv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; putenv(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__readlink__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    readlink(arg1, arg2, x);
+void test__putenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  putenv(NULL);
 }
 
-void test__readlinkat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        readlinkat(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__putenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  putenv(x);
 }
 
-void test__readlinkat__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    readlinkat(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__setenv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setenv(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__readlinkat__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    readlinkat(x, arg2, arg3, arg4);
+void test__setenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  setenv(NULL, arg2, arg3);
 }
 
-void test__readlinkat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    readlinkat(arg1, NULL, arg3, arg4);
+void test__setenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  setenv(x, arg2, arg3);
 }
 
-void test__readlinkat__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    readlinkat(arg1, x, arg3, arg4);
+void test__setenv__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  setenv(arg1, NULL, arg3);
 }
 
-void test__readlinkat__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    readlinkat(arg1, arg2, NULL, arg4);
+void test__setenv__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  setenv(arg1, x, arg3);
 }
 
-void test__readlinkat__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    readlinkat(arg1, arg2, arg3, x);
+void test__setenv__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setenv(arg1, arg2, x);
 }
 
-void test__asctime_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        asctime_r(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__unsetenv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; unsetenv(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__asctime_r__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    asctime_r(p, arg2);
-    // cppcheck-suppress memleak
+void test__unsetenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  unsetenv(NULL);
 }
 
-void test__asctime_r__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    asctime_r(NULL, arg2);
+void test__unsetenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  unsetenv(x);
 }
 
-void test__asctime_r__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    asctime_r(x, arg2);
+void test__localtime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; localtime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__asctime_r__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    asctime_r(arg1, NULL);
+void test__localtime__leakignore() {
+  char *p = malloc(10); *p=0;
+  localtime(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ctime_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ctime_r(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__localtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  localtime(NULL);
 }
 
-void test__ctime_r__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ctime_r(p, arg2);
-    // cppcheck-suppress memleak
+void test__localtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  localtime(x);
 }
 
-void test__ctime_r__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ctime_r(NULL, arg2);
+void test__std__localtime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::localtime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ctime_r__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    ctime_r(x, arg2);
+void test__std__localtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::localtime(NULL);
 }
 
-void test__ctime_r__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ctime_r(arg1, NULL);
+void test__std__localtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::localtime(x);
 }
 
-void test__gmtime_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        gmtime_r(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__localtime_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; localtime_r(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__gmtime_r__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    gmtime_r(p, arg2);
-    // cppcheck-suppress memleak
+void test__localtime_r__leakignore() {
+  char *p = malloc(10); *p=0;
+  localtime_r(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__gmtime_r__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    gmtime_r(NULL, arg2);
+void test__localtime_r__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  localtime_r(NULL, arg2);
 }
 
-void test__gmtime_r__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    gmtime_r(x, arg2);
+void test__localtime_r__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  localtime_r(x, arg2);
 }
 
-void test__gmtime_r__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    gmtime_r(arg1, NULL);
+void test__localtime_r__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  localtime_r(arg1, NULL);
 }
 
-void test__gmtime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = gmtime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__readdir__noreturn() {
+  int x = 1;
+  if (cond) { x=100; readdir(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__gmtime__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    gmtime(arg1);
+void test__readdir__leakignore() {
+  char *p = malloc(10); *p=0;
+  readdir(p);
+  // cppcheck-suppress memleak
 }
 
-void test__gmtime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = gmtime(p);
-    // cppcheck-suppress memleak
+void test__readdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  readdir(NULL);
 }
 
-void test__gmtime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = gmtime(NULL);
+void test__readdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  readdir(x);
 }
 
-void test__gmtime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = gmtime(x);
+void test__readdir_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; readdir_r(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__clock_settime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        clock_settime(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__readdir_r__leakignore() {
+  char *p = malloc(10); *p=0;
+  readdir_r(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__clock_settime__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    clock_settime(x, arg2);
+void test__readdir_r__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  readdir_r(NULL, arg2, arg3);
 }
 
-void test__clock_settime__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    clock_settime(arg1, x);
-}
-
-void test__killpg__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        killpg(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__readdir_r__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  readdir_r(x, arg2, arg3);
 }
 
-void test__killpg__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    killpg(x, arg2);
+void test__readdir_r__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  readdir_r(arg1, NULL, arg3);
 }
 
-void test__killpg__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    killpg(arg1, x);
-}
-
-void test__kill__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        kill(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__kill__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    kill(x, arg2);
-}
-
-void test__kill__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    kill(arg1, x);
-}
-
-void test__clock_gettime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        clock_gettime(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__clock_gettime__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    clock_gettime(x, arg2);
-}
-
-void test__clock_gettime__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    clock_gettime(arg1, NULL);
-}
-
-void test__clock_getres__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        clock_getres(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__readdir_r__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  readdir_r(arg1, arg2, NULL);
 }
 
-void test__clock_getres__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    clock_getres(x, arg2);
+void test__readlink__noreturn() {
+  int x = 1;
+  if (cond) { x=100; readlink(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tmpnam__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        tmpnam(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__tmpnam__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    tmpnam(p);
-    // cppcheck-suppress memleak
+void test__readlink__leakignore() {
+  char *p = malloc(10); *p=0;
+  readlink(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
-
-void test__tmpnam__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    tmpnam(x);
+
+void test__readlink__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  readlink(NULL, arg2, arg3);
 }
-
-void test__tmpnam_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        tmpnam_r(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__tmpnam_r__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    tmpnam_r(p);
-    // cppcheck-suppress memleak
-}
-
-void test__tmpnam_r__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    tmpnam_r(x);
-}
-
-void test__makecontext__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        makecontext(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__makecontext__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    makecontext(p, arg2, arg3);
-    // cppcheck-suppress memleak
-}
-
-void test__makecontext__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    makecontext(NULL, arg2, arg3);
-}
-
-void test__makecontext__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    makecontext(arg1, NULL, arg3);
-}
-
-void test__makecontext__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    makecontext(arg1, x, arg3);
+
+void test__readlink__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  readlink(x, arg2, arg3);
 }
 
-void test__makecontext__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    makecontext(arg1, arg2, x);
-}
+void test__readlink__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  readlink(arg1, NULL, arg3);
+}
 
-void test__swapcontext__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        swapcontext(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__readlink__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  readlink(arg1, arg2, x);
 }
 
-void test__swapcontext__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    swapcontext(p, arg2);
-    // cppcheck-suppress memleak
+void test__readlinkat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; readlinkat(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__swapcontext__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    swapcontext(NULL, arg2);
+void test__readlinkat__leakignore() {
+  char *p = malloc(10); *p=0;
+  readlinkat(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__swapcontext__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    swapcontext(arg1, NULL);
+void test__readlinkat__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  readlinkat(x, arg2, arg3, arg4);
 }
 
-void test__getcontext__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getcontext(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__readlinkat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  readlinkat(arg1, NULL, arg3, arg4);
 }
 
-void test__getcontext__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getcontext(p);
-    // cppcheck-suppress memleak
+void test__readlinkat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  readlinkat(arg1, x, arg3, arg4);
 }
 
-void test__getcontext__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getcontext(NULL);
+void test__readlinkat__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  readlinkat(arg1, arg2, NULL, arg4);
 }
 
-void test__ualarm__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ualarm(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__readlinkat__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  readlinkat(arg1, arg2, arg3, x);
 }
 
-void test__ualarm__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ualarm(p, arg2);
-    // cppcheck-suppress memleak
+void test__asctime_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; asctime_r(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ualarm__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ualarm(x, arg2);
+void test__asctime_r__leakignore() {
+  char *p = malloc(10); *p=0;
+  asctime_r(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__ualarm__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ualarm(arg1, x);
+void test__asctime_r__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  asctime_r(NULL, arg2);
 }
 
-void test__scalb__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = scalb(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__asctime_r__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  asctime_r(x, arg2);
 }
 
-void test__scalb__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    scalb(arg1, arg2);
+void test__asctime_r__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  asctime_r(arg1, NULL);
 }
 
-void test__scalb__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = scalb(p, arg2);
-    // cppcheck-suppress memleak
+void test__ctime_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ctime_r(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__scalb__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = scalb(x, arg2);
+void test__ctime_r__leakignore() {
+  char *p = malloc(10); *p=0;
+  ctime_r(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__scalb__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = scalb(arg1, x);
+void test__ctime_r__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  ctime_r(NULL, arg2);
 }
 
-void test__bcopy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        bcopy(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ctime_r__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ctime_r(x, arg2);
 }
 
-void test__bcopy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    bcopy(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__ctime_r__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  ctime_r(arg1, NULL);
 }
 
-void test__bcopy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    bcopy(NULL, arg2, arg3);
+void test__gmtime_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; gmtime_r(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__bcopy__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    bcopy(x, arg2, arg3);
+void test__gmtime_r__leakignore() {
+  char *p = malloc(10); *p=0;
+  gmtime_r(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__bcopy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    bcopy(arg1, NULL, arg3);
+void test__gmtime_r__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  gmtime_r(NULL, arg2);
 }
 
-void test__bcopy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    bcopy(arg1, arg2, x);
+void test__gmtime_r__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  gmtime_r(x, arg2);
 }
 
-void test__bcmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = bcmp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__gmtime_r__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  gmtime_r(arg1, NULL);
 }
 
-void test__bcmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    bcmp(arg1, arg2, arg3);
+void test__gmtime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = gmtime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__bcmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = bcmp(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__gmtime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  gmtime(arg1);
 }
 
-void test__bcmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = bcmp(NULL, arg2, arg3);
+void test__gmtime__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = gmtime(p);
+  // cppcheck-suppress memleak
 }
 
-void test__bcmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = bcmp(x, arg2, arg3);
+void test__gmtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = gmtime(NULL);
 }
 
-void test__bcmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = bcmp(arg1, NULL, arg3);
+void test__gmtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = gmtime(x);
 }
 
-void test__bcmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = bcmp(arg1, x, arg3);
+void test__clock_settime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; clock_settime(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__bcmp__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = bcmp(arg1, arg2, x);
+void test__clock_settime__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  clock_settime(x, arg2);
 }
 
-void test__bzero__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        bzero(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__clock_settime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  clock_settime(arg1, x);
 }
 
-void test__bzero__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    bzero(p, arg2);
-    // cppcheck-suppress memleak
+void test__killpg__noreturn() {
+  int x = 1;
+  if (cond) { x=100; killpg(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__bzero__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    bzero(NULL, arg2);
+void test__killpg__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  killpg(x, arg2);
 }
 
-void test__bzero__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    bzero(arg1, x);
+void test__killpg__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  killpg(arg1, x);
 }
 
-void test__ftime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ftime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__kill__noreturn() {
+  int x = 1;
+  if (cond) { x=100; kill(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ftime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ftime(p);
-    // cppcheck-suppress memleak
+void test__kill__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  kill(x, arg2);
 }
 
-void test__ftime__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ftime(x);
+void test__kill__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  kill(arg1, x);
 }
 
-void test__wcswcs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcswcs(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__clock_gettime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; clock_gettime(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcswcs__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcswcs(arg1, arg2);
+void test__clock_gettime__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  clock_gettime(x, arg2);
 }
 
-void test__wcswcs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcswcs(p, arg2);
-    // cppcheck-suppress memleak
+void test__clock_gettime__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  clock_gettime(arg1, NULL);
 }
 
-void test__wcswcs__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcswcs(NULL, arg2);
+void test__clock_getres__noreturn() {
+  int x = 1;
+  if (cond) { x=100; clock_getres(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcswcs__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcswcs(x, arg2);
+void test__clock_getres__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  clock_getres(x, arg2);
 }
 
-void test__wcswcs__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcswcs(arg1, NULL);
+void test__tmpnam__noreturn() {
+  int x = 1;
+  if (cond) { x=100; tmpnam(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcswcs__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcswcs(arg1, x);
+void test__tmpnam__leakignore() {
+  char *p = malloc(10); *p=0;
+  tmpnam(p);
+  // cppcheck-suppress memleak
 }
 
-void test__stpcpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        stpcpy(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tmpnam__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tmpnam(x);
 }
 
-void test__stpcpy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    stpcpy(p, arg2);
-    // cppcheck-suppress memleak
+void test__tmpnam_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; tmpnam_r(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stpcpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    stpcpy(NULL, arg2);
+void test__tmpnam_r__leakignore() {
+  char *p = malloc(10); *p=0;
+  tmpnam_r(p);
+  // cppcheck-suppress memleak
 }
 
-void test__stpcpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    stpcpy(arg1, NULL);
+void test__tmpnam_r__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tmpnam_r(x);
 }
 
-void test__stpcpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    stpcpy(arg1, x);
+void test__makecontext__noreturn() {
+  int x = 1;
+  if (cond) { x=100; makecontext(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__index__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = index(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__makecontext__leakignore() {
+  char *p = malloc(10); *p=0;
+  makecontext(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__index__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    index(arg1, arg2);
+void test__makecontext__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  makecontext(NULL, arg2, arg3);
 }
 
-void test__index__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = index(p, arg2);
-    // cppcheck-suppress memleak
+void test__makecontext__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  makecontext(arg1, NULL, arg3);
 }
 
-void test__index__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = index(NULL, arg2);
+void test__makecontext__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  makecontext(arg1, x, arg3);
 }
 
-void test__index__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = index(x, arg2);
+void test__makecontext__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  makecontext(arg1, arg2, x);
 }
 
-void test__index__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = index(arg1, x);
+void test__swapcontext__noreturn() {
+  int x = 1;
+  if (cond) { x=100; swapcontext(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__rindex__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = rindex(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__swapcontext__leakignore() {
+  char *p = malloc(10); *p=0;
+  swapcontext(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__rindex__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    rindex(arg1, arg2);
+void test__swapcontext__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  swapcontext(NULL, arg2);
 }
 
-void test__rindex__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = rindex(p, arg2);
-    // cppcheck-suppress memleak
+void test__swapcontext__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  swapcontext(arg1, NULL);
 }
 
-void test__rindex__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = rindex(NULL, arg2);
+void test__getcontext__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getcontext(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__rindex__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = rindex(x, arg2);
+void test__getcontext__leakignore() {
+  char *p = malloc(10); *p=0;
+  getcontext(p);
+  // cppcheck-suppress memleak
 }
 
-void test__rindex__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = rindex(arg1, x);
-}
-
-void test__bsd_signal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        bsd_signal(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__bsd_signal__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    bsd_signal(p, arg2);
-    // cppcheck-suppress memleak
+void test__getcontext__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getcontext(NULL);
 }
 
-void test__bsd_signal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    bsd_signal(x, arg2);
+void test__ualarm__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ualarm(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__bsd_signal__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    bsd_signal(arg1, x);
+void test__ualarm__leakignore() {
+  char *p = malloc(10); *p=0;
+  ualarm(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__fork__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fork();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__fork__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fork();
-    // cppcheck-suppress memleak
-}
-
-void test__vfork__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vfork();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ualarm__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ualarm(x, arg2);
 }
 
-void test__vfork__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vfork();
-    // cppcheck-suppress memleak
-}
-
-void test__pthread_atfork__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        pthread_atfork(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__pthread_atfork__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    pthread_atfork(p, arg2, arg3);
-    // cppcheck-suppress memleak
-}
-
-void test__pthread_create__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        pthread_create(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__pthread_create__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    pthread_create(NULL, arg2, arg3, arg4);
-}
-
-void test__pthread_create__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    pthread_create(arg1, arg2, NULL, arg4);
-}
-
-void test__pthread_detach__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        pthread_detach(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__pthread_detach__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    pthread_detach(x);
-}
-
-void test__pthread_equal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = pthread_equal(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__pthread_equal__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    pthread_equal(arg1, arg2);
-}
-
-void test__pthread_equal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = pthread_equal(x, arg2);
-}
-
-void test__pthread_equal__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = pthread_equal(arg1, x);
-}
-
-void test__pthread_exit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        pthread_exit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__pthread_join__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        pthread_join(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__pthread_join__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    pthread_join(x, arg2);
-}
-
-void test__pthread_kill__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        pthread_kill(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__pthread_kill__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    pthread_kill(x, arg2);
-}
-
-void test__pthread_kill__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    pthread_kill(arg1, x);
-}
-
-void test__pthread_self__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = pthread_self();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__pthread_self__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    pthread_self();
-}
-
-void test__pthread_attr_destroy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        pthread_attr_destroy(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__ualarm__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ualarm(arg1, x);
+}
 
-void test__pthread_attr_destroy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    pthread_attr_destroy(NULL);
-}
+void test__scalb__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = scalb(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__pthread_attr_init__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        pthread_attr_init(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__scalb__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  scalb(arg1, arg2);
+}
 
-void test__pthread_attr_init__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    pthread_attr_init(NULL);
-}
+void test__scalb__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = scalb(p, arg2);
+  // cppcheck-suppress memleak
+}
 
-void test__pthread_attr_setstackaddr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        pthread_attr_setstackaddr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__scalb__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalb(x, arg2);
 }
 
-void test__pthread_attr_setstackaddr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    pthread_attr_setstackaddr(p, arg2);
-    // cppcheck-suppress memleak
+void test__scalb__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalb(arg1, x);
 }
 
-void test__pthread_attr_setstackaddr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    pthread_attr_setstackaddr(NULL, arg2);
+void test__bcopy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; bcopy(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__pthread_attr_setstackaddr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    pthread_attr_setstackaddr(x, arg2);
+void test__bcopy__leakignore() {
+  char *p = malloc(10); *p=0;
+  bcopy(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__pthread_attr_setstackaddr__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    pthread_attr_setstackaddr(arg1, NULL);
+void test__bcopy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  bcopy(NULL, arg2, arg3);
 }
 
-void test__pthread_attr_setstackaddr__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    pthread_attr_setstackaddr(arg1, x);
+void test__bcopy__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  bcopy(x, arg2, arg3);
 }
 
-void test__pthread_attr_getstackaddr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        pthread_attr_getstackaddr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__bcopy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  bcopy(arg1, NULL, arg3);
 }
 
-void test__pthread_attr_getstackaddr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    pthread_attr_getstackaddr(p, arg2);
-    // cppcheck-suppress memleak
+void test__bcopy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  bcopy(arg1, arg2, x);
 }
 
-void test__pthread_attr_getstackaddr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    pthread_attr_getstackaddr(NULL, arg2);
+void test__bcmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = bcmp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__pthread_attr_getstackaddr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    pthread_attr_getstackaddr(x, arg2);
+void test__bcmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  bcmp(arg1, arg2, arg3);
 }
 
-void test__pthread_attr_getstackaddr__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    pthread_attr_getstackaddr(arg1, NULL);
+void test__bcmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = bcmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__tempnam__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = tempnam(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__bcmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = bcmp(NULL, arg2, arg3);
 }
 
-void test__tempnam__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    tempnam(arg1, arg2);
+void test__bcmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = bcmp(x, arg2, arg3);
 }
 
-void test__tempnam__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = tempnam(p, arg2);
-    // cppcheck-suppress memleak
+void test__bcmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = bcmp(arg1, NULL, arg3);
 }
 
-void test__tempnam__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = tempnam(x, arg2);
+void test__bcmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = bcmp(arg1, x, arg3);
 }
 
-void test__tempnam__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = tempnam(arg1, x);
+void test__bcmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = bcmp(arg1, arg2, x);
 }
 
-void test__crypt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = crypt(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__bzero__noreturn() {
+  int x = 1;
+  if (cond) { x=100; bzero(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__crypt__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    crypt(arg1, arg2);
+void test__bzero__leakignore() {
+  char *p = malloc(10); *p=0;
+  bzero(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__crypt__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = crypt(p, arg2);
-    // cppcheck-suppress memleak
+void test__bzero__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  bzero(NULL, arg2);
 }
 
-void test__crypt__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = crypt(NULL, arg2);
+void test__bzero__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  bzero(arg1, x);
 }
 
-void test__crypt__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = crypt(x, arg2);
+void test__ftime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ftime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__crypt__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = crypt(arg1, NULL);
+void test__ftime__leakignore() {
+  char *p = malloc(10); *p=0;
+  ftime(p);
+  // cppcheck-suppress memleak
 }
 
-void test__crypt__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = crypt(arg1, x);
+void test__ftime__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ftime(x);
 }
 
-void test__ttyname__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ttyname(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcswcs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcswcs(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ttyname__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ttyname(arg1);
+void test__wcswcs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcswcs(arg1, arg2);
 }
 
-void test__ttyname__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ttyname(p);
-    // cppcheck-suppress memleak
+void test__wcswcs__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcswcs(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__ttyname__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ttyname(x);
+void test__wcswcs__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcswcs(NULL, arg2);
 }
 
-void test__getspnam__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getspnam(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcswcs__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcswcs(x, arg2);
 }
 
-void test__getspnam__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getspnam(arg1);
+void test__wcswcs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcswcs(arg1, NULL);
 }
 
-void test__getspnam__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getspnam(p);
-    // cppcheck-suppress memleak
+void test__wcswcs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcswcs(arg1, x);
 }
 
-void test__getspnam__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = getspnam(NULL);
+void test__stpcpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; stpcpy(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getspnam__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = getspnam(x);
+void test__stpcpy__leakignore() {
+  char *p = malloc(10); *p=0;
+  stpcpy(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__getspent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getspent();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__stpcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  stpcpy(NULL, arg2);
 }
 
-void test__getspent__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getspent();
+void test__stpcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  stpcpy(arg1, NULL);
 }
 
-void test__getspent__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getspent();
-    // cppcheck-suppress memleak
+void test__stpcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  stpcpy(arg1, x);
 }
 
-void test__fgetspent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fgetspent(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__index__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = index(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fgetspent__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fgetspent(arg1);
+void test__index__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  index(arg1, arg2);
 }
 
-void test__fgetspent__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fgetspent(p);
-    // cppcheck-suppress memleak
+void test__index__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = index(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__fgetspent__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = fgetspent(NULL);
+void test__index__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = index(NULL, arg2);
 }
 
-void test__fgetspent__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = fgetspent(x);
+void test__index__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = index(x, arg2);
 }
 
-void test__sgetspent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sgetspent(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__index__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = index(arg1, x);
 }
 
-void test__sgetspent__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sgetspent(arg1);
+void test__rindex__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = rindex(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sgetspent__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = sgetspent(p);
-    // cppcheck-suppress memleak
+void test__rindex__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  rindex(arg1, arg2);
 }
 
-void test__sgetspent__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = sgetspent(NULL);
+void test__rindex__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = rindex(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__sgetspent__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = sgetspent(x);
+void test__rindex__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = rindex(NULL, arg2);
 }
 
-void test__fgetpwent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fgetpwent(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__rindex__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = rindex(x, arg2);
 }
 
-void test__fgetpwent__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fgetpwent(arg1);
+void test__rindex__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = rindex(arg1, x);
 }
 
-void test__fgetpwent__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fgetpwent(p);
-    // cppcheck-suppress memleak
+void test__bsd_signal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; bsd_signal(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fgetpwent__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = fgetpwent(NULL);
+void test__bsd_signal__leakignore() {
+  char *p = malloc(10); *p=0;
+  bsd_signal(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__fgetpwent__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = fgetpwent(x);
+void test__bsd_signal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  bsd_signal(x, arg2);
 }
 
-void test__getgrent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getgrent();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__bsd_signal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  bsd_signal(arg1, x);
 }
 
-void test__getgrent__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getgrent();
+void test__fork__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fork(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getgrent__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getgrent();
-    // cppcheck-suppress memleak
+void test__fork__leakignore() {
+  char *p = malloc(10); *p=0;
+  fork();
+  // cppcheck-suppress memleak
 }
 
-void test__getgrent_r__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getgrent_r(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__vfork__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vfork(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getgrent_r__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getgrent_r(arg1, arg2, arg3, arg4);
+void test__vfork__leakignore() {
+  char *p = malloc(10); *p=0;
+  vfork();
+  // cppcheck-suppress memleak
 }
 
-void test__getgrent_r__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getgrent_r(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__pthread_atfork__noreturn() {
+  int x = 1;
+  if (cond) { x=100; pthread_atfork(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getgrent_r__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getgrent_r(arg1, x, arg3, arg4);
+void test__pthread_atfork__leakignore() {
+  char *p = malloc(10); *p=0;
+  pthread_atfork(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__getgrent_r__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getgrent_r(arg1, arg2, x, arg4);
+void test__pthread_create__noreturn() {
+  int x = 1;
+  if (cond) { x=100; pthread_create(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fgetgrent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fgetgrent(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__pthread_create__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  pthread_create(NULL, arg2, arg3, arg4);
 }
 
-void test__fgetgrent__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fgetgrent(arg1);
+void test__pthread_create__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  pthread_create(arg1, arg2, NULL, arg4);
 }
 
-void test__fgetgrent__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fgetgrent(p);
-    // cppcheck-suppress memleak
+void test__pthread_detach__noreturn() {
+  int x = 1;
+  if (cond) { x=100; pthread_detach(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fgetgrent__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = fgetgrent(NULL);
+void test__pthread_detach__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  pthread_detach(x);
 }
 
-void test__fgetgrent__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = fgetgrent(x);
+void test__pthread_equal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = pthread_equal(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getnetgrent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getnetgrent(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__pthread_equal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  pthread_equal(arg1, arg2);
 }
 
-void test__getnetgrent__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getnetgrent(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__pthread_equal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = pthread_equal(x, arg2);
 }
 
-void test__getnetgrent__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getnetgrent(NULL, arg2, arg3);
+void test__pthread_equal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = pthread_equal(arg1, x);
 }
 
-void test__getnetgrent__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getnetgrent(arg1, NULL, arg3);
+void test__pthread_exit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; pthread_exit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getnetgrent__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getnetgrent(arg1, arg2, NULL);
+void test__pthread_join__noreturn() {
+  int x = 1;
+  if (cond) { x=100; pthread_join(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getgrnam__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getgrnam(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__pthread_join__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  pthread_join(x, arg2);
 }
 
-void test__getgrnam__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getgrnam(arg1);
+void test__pthread_kill__noreturn() {
+  int x = 1;
+  if (cond) { x=100; pthread_kill(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getgrnam__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getgrnam(p);
-    // cppcheck-suppress memleak
+void test__pthread_kill__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  pthread_kill(x, arg2);
 }
 
-void test__getgrnam__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = getgrnam(NULL);
+void test__pthread_kill__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  pthread_kill(arg1, x);
 }
 
-void test__getgrnam__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = getgrnam(x);
+void test__pthread_self__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = pthread_self(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getgrgid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getgrgid(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__pthread_self__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  pthread_self();
 }
 
-void test__getgrgid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getgrgid(arg1);
+void test__pthread_attr_destroy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; pthread_attr_destroy(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getgrgid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getgrgid(p);
-    // cppcheck-suppress memleak
+void test__pthread_attr_destroy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  pthread_attr_destroy(NULL);
 }
-
-void test__getgrgid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = getgrgid(x);
+
+void test__pthread_attr_init__noreturn() {
+  int x = 1;
+  if (cond) { x=100; pthread_attr_init(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getlogin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getlogin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__pthread_attr_init__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  pthread_attr_init(NULL);
 }
 
-void test__getlogin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getlogin();
+void test__pthread_attr_setstackaddr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; pthread_attr_setstackaddr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getlogin__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getlogin();
-    // cppcheck-suppress memleak
+void test__pthread_attr_setstackaddr__leakignore() {
+  char *p = malloc(10); *p=0;
+  pthread_attr_setstackaddr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__ctermid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ctermid(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__pthread_attr_setstackaddr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  pthread_attr_setstackaddr(NULL, arg2);
 }
 
-void test__ctermid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ctermid(p);
-    // cppcheck-suppress memleak
+void test__pthread_attr_setstackaddr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  pthread_attr_setstackaddr(x, arg2);
 }
 
-void test__realpath__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        realpath(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__pthread_attr_setstackaddr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  pthread_attr_setstackaddr(arg1, NULL);
 }
-
-void test__realpath__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    realpath(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__realpath__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    realpath(NULL, arg2);
-}
-
-void test__realpath__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    realpath(x, arg2);
+
+void test__pthread_attr_setstackaddr__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  pthread_attr_setstackaddr(arg1, x);
 }
 
-void test__remove__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        remove(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__pthread_attr_getstackaddr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; pthread_attr_getstackaddr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__remove__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    remove(p);
-    // cppcheck-suppress memleak
+void test__pthread_attr_getstackaddr__leakignore() {
+  char *p = malloc(10); *p=0;
+  pthread_attr_getstackaddr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__remove__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    remove(NULL);
-}
-
-void test__remove__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    remove(x);
+void test__pthread_attr_getstackaddr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  pthread_attr_getstackaddr(NULL, arg2);
 }
 
-void test__fileno__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fileno(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__pthread_attr_getstackaddr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  pthread_attr_getstackaddr(x, arg2);
 }
 
-void test__fileno__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fileno(arg1);
+void test__pthread_attr_getstackaddr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  pthread_attr_getstackaddr(arg1, NULL);
 }
 
-void test__fileno__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fileno(p);
-    // cppcheck-suppress memleak
+void test__tempnam__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = tempnam(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fileno__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = fileno(NULL);
+void test__tempnam__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tempnam(arg1, arg2);
 }
 
-void test__fileno__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = fileno(x);
+void test__tempnam__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = tempnam(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__fseeko__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fseeko(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tempnam__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tempnam(x, arg2);
 }
 
-void test__fseeko__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fseeko(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__tempnam__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tempnam(arg1, x);
 }
 
-void test__fseeko__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fseeko(NULL, arg2, arg3);
+void test__crypt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = crypt(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fseeko__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fseeko(x, arg2, arg3);
+void test__crypt__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  crypt(arg1, arg2);
 }
 
-void test__fseeko__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fseeko(arg1, x, arg3);
+void test__crypt__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = crypt(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__fseeko__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fseeko(arg1, arg2, x);
+void test__crypt__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = crypt(NULL, arg2);
 }
 
-void test__ftello__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ftello(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__crypt__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = crypt(x, arg2);
 }
 
-void test__ftello__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ftello(arg1);
+void test__crypt__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = crypt(arg1, NULL);
 }
 
-void test__ftello__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ftello(p);
-    // cppcheck-suppress memleak
+void test__crypt__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = crypt(arg1, x);
 }
 
-void test__ftello__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = ftello(NULL);
+void test__ttyname__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ttyname(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ftello__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = ftello(x);
+void test__ttyname__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ttyname(arg1);
 }
 
-void test__execv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        execv(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ttyname__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ttyname(p);
+  // cppcheck-suppress memleak
 }
 
-void test__execv__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    execv(p, arg2);
-    // cppcheck-suppress memleak
+void test__ttyname__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ttyname(x);
 }
 
-void test__execv__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    execv(NULL, arg2);
+void test__getspnam__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getspnam(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__execv__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    execv(x, arg2);
+void test__getspnam__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getspnam(arg1);
 }
 
-void test__execv__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    execv(arg1, x);
+void test__getspnam__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getspnam(p);
+  // cppcheck-suppress memleak
 }
 
-void test__execvp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        execvp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getspnam__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = getspnam(NULL);
 }
 
-void test__execvp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    execvp(p, arg2);
-    // cppcheck-suppress memleak
+void test__getspnam__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = getspnam(x);
 }
 
-void test__execvp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    execvp(NULL, arg2);
+void test__getspent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getspent(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__execvp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    execvp(x, arg2);
+void test__getspent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getspent();
 }
 
-void test__execvp__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    execvp(arg1, x);
+void test__getspent__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getspent();
+  // cppcheck-suppress memleak
 }
 
-void test__wait__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wait(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fgetspent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fgetspent(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wait__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wait(p);
-    // cppcheck-suppress memleak
+void test__fgetspent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fgetspent(arg1);
 }
 
-void test__waitpid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        waitpid(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fgetspent__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fgetspent(p);
+  // cppcheck-suppress memleak
 }
 
-void test__waitpid__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    waitpid(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__fgetspent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fgetspent(NULL);
 }
 
-void test__waitpid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    waitpid(x, arg2, arg3);
+void test__fgetspent__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fgetspent(x);
 }
 
-void test__waitpid__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    waitpid(arg1, arg2, x);
+void test__sgetspent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sgetspent(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strnlen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strnlen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sgetspent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sgetspent(arg1);
 }
 
-void test__strnlen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strnlen(arg1, arg2);
+void test__sgetspent__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = sgetspent(p);
+  // cppcheck-suppress memleak
 }
 
-void test__strnlen__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = strnlen(p, arg2);
-    // cppcheck-suppress memleak
+void test__sgetspent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = sgetspent(NULL);
 }
 
-void test__strnlen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strnlen(NULL, arg2);
+void test__sgetspent__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = sgetspent(x);
 }
 
-void test__strnlen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strnlen(x, arg2);
+void test__fgetpwent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fgetpwent(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strnlen__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = strnlen(arg1, x);
+void test__fgetpwent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fgetpwent(arg1);
 }
 
-void test__wcsnlen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcsnlen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fgetpwent__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fgetpwent(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wcsnlen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcsnlen(arg1, arg2);
+void test__fgetpwent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fgetpwent(NULL);
 }
 
-void test__wcsnlen__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcsnlen(p, arg2);
-    // cppcheck-suppress memleak
+void test__fgetpwent__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fgetpwent(x);
 }
 
-void test__wcsnlen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcsnlen(NULL, arg2);
+void test__getgrent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getgrent(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsnlen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcsnlen(x, arg2);
+void test__getgrent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getgrent();
 }
 
-void test__wcsnlen__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wcsnlen(arg1, x);
+void test__getgrent__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getgrent();
+  // cppcheck-suppress memleak
 }
 
-void test__ffs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ffs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getgrent_r__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getgrent_r(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ffs__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ffs(arg1);
+void test__getgrent_r__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getgrent_r(arg1, arg2, arg3, arg4);
 }
 
-void test__ffs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ffs(p);
-    // cppcheck-suppress memleak
+void test__getgrent_r__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getgrent_r(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__ffs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ffs(x);
+void test__getgrent_r__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getgrent_r(arg1, x, arg3, arg4);
 }
 
-void test__shmctl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        shmctl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getgrent_r__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getgrent_r(arg1, arg2, x, arg4);
 }
 
-void test__shmctl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    shmctl(p, arg2);
-    // cppcheck-suppress memleak
+void test__fgetgrent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fgetgrent(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__shmctl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    shmctl(x, arg2);
+void test__fgetgrent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fgetgrent(arg1);
 }
 
-void test__shmctl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    shmctl(arg1, x);
+void test__fgetgrent__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fgetgrent(p);
+  // cppcheck-suppress memleak
 }
 
-void test__shmget__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        shmget(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__fgetgrent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fgetgrent(NULL);
+}
 
-void test__shmget__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    shmget(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__fgetgrent__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fgetgrent(x);
 }
 
-void test__shmget__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    shmget(x, arg2, arg3);
+void test__getnetgrent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getnetgrent(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__shmget__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    shmget(arg1, x, arg3);
-}
-
-void test__shmget__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    shmget(arg1, arg2, x);
-}
-
-void test__shmat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        shmat(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getnetgrent__leakignore() {
+  char *p = malloc(10); *p=0;
+  getnetgrent(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__shmat__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    shmat(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__getnetgrent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getnetgrent(NULL, arg2, arg3);
 }
 
-void test__shmat__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    shmat(x, arg2, arg3);
+void test__getnetgrent__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getnetgrent(arg1, NULL, arg3);
 }
 
-void test__shmat__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    shmat(arg1, arg2, x);
-}
-
-void test__shmdt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        shmdt(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getnetgrent__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  getnetgrent(arg1, arg2, NULL);
 }
 
-void test__shmdt__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    shmdt(p);
-    // cppcheck-suppress memleak
+void test__getgrnam__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getgrnam(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getrlimit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getrlimit(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getgrnam__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getgrnam(arg1);
 }
 
-void test__getrlimit__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getrlimit(p, arg2);
-    // cppcheck-suppress memleak
+void test__getgrnam__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getgrnam(p);
+  // cppcheck-suppress memleak
 }
 
-void test__getrlimit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getrlimit(x, arg2);
+void test__getgrnam__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = getgrnam(NULL);
 }
 
-void test__getrlimit__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getrlimit(arg1, NULL);
+void test__getgrnam__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = getgrnam(x);
 }
 
-void test__setrlimit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setrlimit(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getgrgid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getgrgid(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__setrlimit__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setrlimit(p, arg2);
-    // cppcheck-suppress memleak
+void test__getgrgid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getgrgid(arg1);
 }
 
-void test__setrlimit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setrlimit(x, arg2);
+void test__getgrgid__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getgrgid(p);
+  // cppcheck-suppress memleak
 }
 
-void test__setrlimit__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    setrlimit(arg1, NULL);
+void test__getgrgid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getgrgid(x);
 }
 
-void test__setrlimit__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    setrlimit(arg1, x);
+void test__getlogin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getlogin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__glob__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        glob(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getlogin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getlogin();
 }
 
-void test__glob__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    glob(NULL, arg2, arg3, arg4);
+void test__getlogin__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getlogin();
+  // cppcheck-suppress memleak
 }
 
-void test__glob__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    glob(x, arg2, arg3, arg4);
+void test__ctermid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ctermid(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__glob__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    glob(arg1, x, arg3, arg4);
+void test__ctermid__leakignore() {
+  char *p = malloc(10); *p=0;
+  ctermid(p);
+  // cppcheck-suppress memleak
 }
 
-void test__glob__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    glob(arg1, arg2, x, arg4);
+void test__realpath__noreturn() {
+  int x = 1;
+  if (cond) { x=100; realpath(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__glob__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    glob(arg1, arg2, arg3, NULL);
+void test__realpath__leakignore() {
+  char *p = malloc(10); *p=0;
+  realpath(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__globfree__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        globfree(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__realpath__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  realpath(NULL, arg2);
 }
 
-void test__globfree__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    globfree(NULL);
+void test__realpath__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  realpath(x, arg2);
 }
 
-void test__globfree__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    globfree(x);
+void test__remove__noreturn() {
+  int x = 1;
+  if (cond) { x=100; remove(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcpncpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcpncpy(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__remove__leakignore() {
+  char *p = malloc(10); *p=0;
+  remove(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wcpncpy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcpncpy(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__remove__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  remove(NULL);
 }
 
-void test__wcpncpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcpncpy(NULL, arg2, arg3);
+void test__remove__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  remove(x);
 }
 
-void test__wcpncpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcpncpy(arg1, NULL, arg3);
+void test__fileno__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fileno(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcpncpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcpncpy(arg1, x, arg3);
+void test__fileno__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fileno(arg1);
 }
 
-void test__wcpncpy__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wcpncpy(arg1, arg2, !x);
+void test__fileno__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fileno(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wcpncpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wcpncpy(arg1, arg2, x);
+void test__fileno__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fileno(NULL);
 }
 
-void test__stpncpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        stpncpy(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fileno__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fileno(x);
 }
 
-void test__stpncpy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    stpncpy(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__fseeko__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fseeko(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stpncpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    stpncpy(NULL, arg2, arg3);
+void test__fseeko__leakignore() {
+  char *p = malloc(10); *p=0;
+  fseeko(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__stpncpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    stpncpy(arg1, NULL, arg3);
+void test__fseeko__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fseeko(NULL, arg2, arg3);
 }
 
-void test__stpncpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    stpncpy(arg1, x, arg3);
+void test__fseeko__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fseeko(x, arg2, arg3);
 }
 
-void test__stpncpy__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    stpncpy(arg1, arg2, !x);
+void test__fseeko__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fseeko(arg1, x, arg3);
 }
 
-void test__stpncpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    stpncpy(arg1, arg2, x);
+void test__fseeko__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fseeko(arg1, arg2, x);
 }
 
-void test__memccpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        memccpy(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ftello__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ftello(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__memccpy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    memccpy(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__ftello__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ftello(arg1);
 }
 
-void test__memccpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    memccpy(NULL, arg2, arg3, arg4);
+void test__ftello__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ftello(p);
+  // cppcheck-suppress memleak
 }
 
-void test__memccpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    memccpy(arg1, NULL, arg3, arg4);
+void test__ftello__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = ftello(NULL);
 }
 
-void test__memccpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    memccpy(arg1, x, arg3, arg4);
+void test__ftello__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = ftello(x);
 }
 
-void test__memccpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    memccpy(arg1, arg2, x, arg4);
+void test__execv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; execv(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__memccpy__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    memccpy(arg1, arg2, arg3, x);
+void test__execv__leakignore() {
+  char *p = malloc(10); *p=0;
+  execv(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__getopt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getopt(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__execv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  execv(NULL, arg2);
 }
 
-void test__getopt__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getopt(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__execv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  execv(x, arg2);
 }
 
-void test__getopt__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getopt(x, arg2, arg3);
+void test__execv__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  execv(arg1, x);
 }
 
-void test__getopt__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getopt(arg1, NULL, arg3);
+void test__execvp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; execvp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getopt__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    getopt(arg1, x, arg3);
+void test__execvp__leakignore() {
+  char *p = malloc(10); *p=0;
+  execvp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__getopt__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getopt(arg1, arg2, NULL);
+void test__execvp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  execvp(NULL, arg2);
 }
 
-void test__getopt__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    getopt(arg1, arg2, x);
+void test__execvp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  execvp(x, arg2);
 }
 
-void test__getitimer__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getitimer(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__execvp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  execvp(arg1, x);
 }
 
-void test__getitimer__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getitimer(p, arg2);
-    // cppcheck-suppress memleak
+void test__wait__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wait(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getitimer__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getitimer(x, arg2);
+void test__wait__leakignore() {
+  char *p = malloc(10); *p=0;
+  wait(p);
+  // cppcheck-suppress memleak
 }
 
-void test__getitimer__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getitimer(arg1, NULL);
+void test__waitpid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; waitpid(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getitimer__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    getitimer(arg1, x);
+void test__waitpid__leakignore() {
+  char *p = malloc(10); *p=0;
+  waitpid(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__setitimer__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setitimer(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__waitpid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  waitpid(x, arg2, arg3);
 }
 
-void test__setitimer__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setitimer(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__waitpid__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  waitpid(arg1, arg2, x);
 }
 
-void test__setitimer__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setitimer(x, arg2, arg3);
+void test__strnlen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strnlen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__setitimer__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setitimer(arg1, x, arg3);
+void test__strnlen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strnlen(arg1, arg2);
 }
 
-void test__setitimer__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setitimer(arg1, arg2, x);
+void test__strnlen__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = strnlen(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__sigaction__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sigaction(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sigaction__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sigaction(p, arg2, arg3);
-    // cppcheck-suppress memleak
-}
-
-void test__sigaction__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sigaction(x, arg2, arg3);
-}
-
-void test__sigaltstack__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sigaltstack(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sigaltstack__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sigaltstack(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__sigaltstack__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sigaltstack(x, arg2);
-}
-
-void test__siglongjmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        siglongjmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__siglongjmp__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    siglongjmp(x, arg2);
-}
-
-void test__siglongjmp__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    siglongjmp(arg1, x);
-}
-
-void test___longjmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _longjmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test___longjmp__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _longjmp(x, arg2);
-}
-
-void test___longjmp__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _longjmp(arg1, x);
-}
-
-void test__sigsetjmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sigsetjmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sigsetjmp__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sigsetjmp(arg1, x);
-}
-
-void test___setjmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _setjmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test___setjmp__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _setjmp(arg1, x);
-}
-
-void test__sigsuspend__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sigsuspend(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sigsuspend__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sigsuspend(p);
-    // cppcheck-suppress memleak
-}
-
-void test__sigsuspend__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    sigsuspend(NULL);
+void test__strnlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strnlen(NULL, arg2);
 }
-
-void test__pthread_sigmask__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        pthread_sigmask(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__pthread_sigmask__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    pthread_sigmask(x, arg2, arg3);
-}
-
-void test__pthread_sigmask__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    pthread_sigmask(arg1, x, arg3);
+
+void test__strnlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strnlen(x, arg2);
 }
-
-void test__pthread_sigmask__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    pthread_sigmask(arg1, arg2, x);
-}
-
-void test__sigprocmask__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sigprocmask(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sigprocmask__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sigprocmask(x, arg2, arg3);
+
+void test__strnlen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strnlen(arg1, x);
 }
-
-void test__sigprocmask__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sigprocmask(arg1, x, arg3);
-}
-
-void test__sigprocmask__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sigprocmask(arg1, arg2, x);
-}
-
-void test__getrusage__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getrusage(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__wcsnlen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcsnlen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__getrusage__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getrusage(p, arg2);
-    // cppcheck-suppress memleak
+
+void test__wcsnlen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcsnlen(arg1, arg2);
 }
 
-void test__getrusage__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getrusage(x, arg2);
+void test__wcsnlen__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcsnlen(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__getrusage__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getrusage(arg1, NULL);
-}
-
-void test__sigemptyset__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sigemptyset(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsnlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsnlen(NULL, arg2);
 }
 
-void test__sigemptyset__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sigemptyset(p);
-    // cppcheck-suppress memleak
+void test__wcsnlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsnlen(x, arg2);
 }
 
-void test__sigemptyset__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    sigemptyset(NULL);
-}
+void test__wcsnlen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcsnlen(arg1, x);
+}
 
-void test__sigfillset__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sigfillset(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ffs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ffs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__sigfillset__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sigfillset(p);
-    // cppcheck-suppress memleak
+
+void test__ffs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ffs(arg1);
 }
 
-void test__sigfillset__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    sigfillset(NULL);
+void test__ffs__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ffs(p);
+  // cppcheck-suppress memleak
 }
 
-void test__sigaddset__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sigaddset(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ffs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ffs(x);
 }
-
-void test__sigaddset__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sigaddset(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__sigaddset__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    sigaddset(NULL, arg2);
-}
-
-void test__sigaddset__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sigaddset(arg1, x);
-}
-
-void test__sigdelset__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sigdelset(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sigdelset__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sigdelset(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__sigdelset__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    sigdelset(NULL, arg2);
-}
-
-void test__sigdelset__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sigdelset(arg1, x);
-}
-
-void test__sigismember__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sigismember(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__shmctl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; shmctl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__sigismember__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sigismember(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__sigismember__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    sigismember(NULL, arg2);
-}
-
-void test__sigismember__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sigismember(arg1, x);
-}
-
-void test__posix_spawn__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        posix_spawn(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__shmctl__leakignore() {
+  char *p = malloc(10); *p=0;
+  shmctl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__shmctl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  shmctl(x, arg2);
+}
+
+void test__shmctl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  shmctl(arg1, x);
+}
+
+void test__shmget__noreturn() {
+  int x = 1;
+  if (cond) { x=100; shmget(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__shmget__leakignore() {
+  char *p = malloc(10); *p=0;
+  shmget(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__shmget__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  shmget(x, arg2, arg3);
+}
+
+void test__shmget__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  shmget(arg1, x, arg3);
+}
+
+void test__shmget__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  shmget(arg1, arg2, x);
+}
+
+void test__shmat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; shmat(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__shmat__leakignore() {
+  char *p = malloc(10); *p=0;
+  shmat(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__shmat__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  shmat(x, arg2, arg3);
+}
+
+void test__shmat__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  shmat(arg1, arg2, x);
+}
+
+void test__shmdt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; shmdt(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__shmdt__leakignore() {
+  char *p = malloc(10); *p=0;
+  shmdt(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getrlimit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getrlimit(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getrlimit__leakignore() {
+  char *p = malloc(10); *p=0;
+  getrlimit(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__getrlimit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getrlimit(x, arg2);
+}
+
+void test__getrlimit__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getrlimit(arg1, NULL);
+}
+
+void test__setrlimit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setrlimit(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setrlimit__leakignore() {
+  char *p = malloc(10); *p=0;
+  setrlimit(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__setrlimit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setrlimit(x, arg2);
+}
+
+void test__setrlimit__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  setrlimit(arg1, NULL);
+}
+
+void test__setrlimit__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  setrlimit(arg1, x);
+}
+
+void test__glob__noreturn() {
+  int x = 1;
+  if (cond) { x=100; glob(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__glob__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  glob(NULL, arg2, arg3, arg4);
+}
+
+void test__glob__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  glob(x, arg2, arg3, arg4);
+}
+
+void test__glob__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  glob(arg1, x, arg3, arg4);
+}
+
+void test__glob__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  glob(arg1, arg2, x, arg4);
+}
+
+void test__glob__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  glob(arg1, arg2, arg3, NULL);
+}
+
+void test__globfree__noreturn() {
+  int x = 1;
+  if (cond) { x=100; globfree(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__globfree__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  globfree(NULL);
+}
+
+void test__globfree__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  globfree(x);
+}
+
+void test__wcpncpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcpncpy(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcpncpy__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcpncpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcpncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcpncpy(NULL, arg2, arg3);
+}
+
+void test__wcpncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcpncpy(arg1, NULL, arg3);
+}
+
+void test__wcpncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcpncpy(arg1, x, arg3);
+}
+
+void test__wcpncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wcpncpy(arg1, arg2, !x);
+}
+
+void test__wcpncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcpncpy(arg1, arg2, x);
+}
+
+void test__stpncpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; stpncpy(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__stpncpy__leakignore() {
+  char *p = malloc(10); *p=0;
+  stpncpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__stpncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  stpncpy(NULL, arg2, arg3);
+}
+
+void test__stpncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  stpncpy(arg1, NULL, arg3);
+}
+
+void test__stpncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  stpncpy(arg1, x, arg3);
+}
+
+void test__stpncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  stpncpy(arg1, arg2, !x);
+}
+
+void test__stpncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  stpncpy(arg1, arg2, x);
+}
+
+void test__memccpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; memccpy(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__memccpy__leakignore() {
+  char *p = malloc(10); *p=0;
+  memccpy(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__memccpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  memccpy(NULL, arg2, arg3, arg4);
+}
+
+void test__memccpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  memccpy(arg1, NULL, arg3, arg4);
+}
+
+void test__memccpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  memccpy(arg1, x, arg3, arg4);
+}
+
+void test__memccpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memccpy(arg1, arg2, x, arg4);
+}
+
+void test__memccpy__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memccpy(arg1, arg2, arg3, x);
+}
+
+void test__getopt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getopt(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getopt__leakignore() {
+  char *p = malloc(10); *p=0;
+  getopt(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__getopt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getopt(x, arg2, arg3);
+}
+
+void test__getopt__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getopt(arg1, NULL, arg3);
+}
+
+void test__getopt__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getopt(arg1, x, arg3);
+}
+
+void test__getopt__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  getopt(arg1, arg2, NULL);
+}
+
+void test__getopt__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getopt(arg1, arg2, x);
+}
+
+void test__getitimer__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getitimer(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getitimer__leakignore() {
+  char *p = malloc(10); *p=0;
+  getitimer(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__getitimer__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getitimer(x, arg2);
+}
+
+void test__getitimer__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getitimer(arg1, NULL);
+}
+
+void test__getitimer__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getitimer(arg1, x);
+}
+
+void test__setitimer__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setitimer(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setitimer__leakignore() {
+  char *p = malloc(10); *p=0;
+  setitimer(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__setitimer__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setitimer(x, arg2, arg3);
+}
+
+void test__setitimer__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setitimer(arg1, x, arg3);
+}
+
+void test__setitimer__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setitimer(arg1, arg2, x);
+}
+
+void test__sigaction__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sigaction(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigaction__leakignore() {
+  char *p = malloc(10); *p=0;
+  sigaction(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__sigaction__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sigaction(x, arg2, arg3);
+}
+
+void test__sigaltstack__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sigaltstack(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigaltstack__leakignore() {
+  char *p = malloc(10); *p=0;
+  sigaltstack(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__sigaltstack__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sigaltstack(x, arg2);
+}
+
+void test__siglongjmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; siglongjmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__siglongjmp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  siglongjmp(x, arg2);
+}
+
+void test__siglongjmp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  siglongjmp(arg1, x);
+}
+
+void test___longjmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _longjmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___longjmp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _longjmp(x, arg2);
+}
+
+void test___longjmp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _longjmp(arg1, x);
+}
+
+void test__sigsetjmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sigsetjmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigsetjmp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sigsetjmp(arg1, x);
+}
+
+void test___setjmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _setjmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___setjmp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _setjmp(arg1, x);
+}
+
+void test__sigsuspend__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sigsuspend(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigsuspend__leakignore() {
+  char *p = malloc(10); *p=0;
+  sigsuspend(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sigsuspend__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  sigsuspend(NULL);
+}
+
+void test__pthread_sigmask__noreturn() {
+  int x = 1;
+  if (cond) { x=100; pthread_sigmask(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__pthread_sigmask__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  pthread_sigmask(x, arg2, arg3);
+}
+
+void test__pthread_sigmask__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  pthread_sigmask(arg1, x, arg3);
+}
+
+void test__pthread_sigmask__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  pthread_sigmask(arg1, arg2, x);
+}
+
+void test__sigprocmask__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sigprocmask(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigprocmask__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sigprocmask(x, arg2, arg3);
+}
+
+void test__sigprocmask__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sigprocmask(arg1, x, arg3);
+}
+
+void test__sigprocmask__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sigprocmask(arg1, arg2, x);
+}
+
+void test__getrusage__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getrusage(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getrusage__leakignore() {
+  char *p = malloc(10); *p=0;
+  getrusage(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__getrusage__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getrusage(x, arg2);
+}
+
+void test__getrusage__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getrusage(arg1, NULL);
+}
+
+void test__sigemptyset__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sigemptyset(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigemptyset__leakignore() {
+  char *p = malloc(10); *p=0;
+  sigemptyset(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sigemptyset__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  sigemptyset(NULL);
+}
+
+void test__sigfillset__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sigfillset(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigfillset__leakignore() {
+  char *p = malloc(10); *p=0;
+  sigfillset(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sigfillset__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  sigfillset(NULL);
+}
+
+void test__sigaddset__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sigaddset(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigaddset__leakignore() {
+  char *p = malloc(10); *p=0;
+  sigaddset(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__sigaddset__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  sigaddset(NULL, arg2);
+}
+
+void test__sigaddset__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sigaddset(arg1, x);
+}
+
+void test__sigdelset__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sigdelset(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigdelset__leakignore() {
+  char *p = malloc(10); *p=0;
+  sigdelset(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__sigdelset__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  sigdelset(NULL, arg2);
+}
+
+void test__sigdelset__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sigdelset(arg1, x);
+}
+
+void test__sigismember__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sigismember(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigismember__leakignore() {
+  char *p = malloc(10); *p=0;
+  sigismember(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__sigismember__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  sigismember(NULL, arg2);
+}
+
+void test__sigismember__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sigismember(arg1, x);
+}
+
+void test__posix_spawn__noreturn() {
+  int x = 1;
+  if (cond) { x=100; posix_spawn(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__posix_spawn__leakignore() {
+  char *p = malloc(10); *p=0;
+  posix_spawn(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__posix_spawnp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; posix_spawnp(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__posix_spawnp__leakignore() {
+  char *p = malloc(10); *p=0;
+  posix_spawnp(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__msgctl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; msgctl(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__posix_spawn__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    posix_spawn(p, arg2, arg3, arg4, arg5, arg6);
-    // cppcheck-suppress memleak
-}
-
-void test__posix_spawnp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        posix_spawnp(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__posix_spawnp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    posix_spawnp(p, arg2, arg3, arg4, arg5, arg6);
-    // cppcheck-suppress memleak
-}
-
-void test__msgctl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        msgctl(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__msgctl__leakignore() {
+  char *p = malloc(10); *p=0;
+  msgctl(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__msgctl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    msgctl(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__msgctl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  msgctl(x, arg2, arg3);
 }
 
-void test__msgctl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    msgctl(x, arg2, arg3);
+void test__msgctl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  msgctl(arg1, x, arg3);
 }
 
-void test__msgctl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    msgctl(arg1, x, arg3);
-}
-
-void test__msgctl__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    msgctl(arg1, arg2, x);
+void test__msgctl__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  msgctl(arg1, arg2, x);
 }
 
-void test__msgget__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = msgget(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__msgget__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = msgget(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__msgget__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    msgget(arg1, arg2);
+void test__msgget__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  msgget(arg1, arg2);
 }
 
-void test__msgget__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = msgget(x, arg2);
+void test__msgget__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = msgget(x, arg2);
 }
 
-void test__msgget__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = msgget(arg1, x);
+void test__msgget__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = msgget(arg1, x);
 }
 
-void test__msgrcv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        msgrcv(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__msgrcv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; msgrcv(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__msgrcv__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    msgrcv(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test__msgrcv__leakignore() {
+  char *p = malloc(10); *p=0;
+  msgrcv(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test__msgrcv__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    msgrcv(x, arg2, arg3, arg4, arg5);
+void test__msgrcv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  msgrcv(x, arg2, arg3, arg4, arg5);
 }
 
-void test__msgrcv__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    msgrcv(arg1, NULL, arg3, arg4, arg5);
+void test__msgrcv__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  msgrcv(arg1, NULL, arg3, arg4, arg5);
 }
 
-void test__msgrcv__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    msgrcv(arg1, arg2, x, arg4, arg5);
+void test__msgrcv__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  msgrcv(arg1, arg2, x, arg4, arg5);
 }
 
-void test__msgrcv__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    msgrcv(arg1, arg2, arg3, x, arg5);
+void test__msgrcv__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  msgrcv(arg1, arg2, arg3, x, arg5);
 }
 
-void test__msgrcv__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    msgrcv(arg1, arg2, arg3, arg4, x);
+void test__msgrcv__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  msgrcv(arg1, arg2, arg3, arg4, x);
 }
 
-void test__msgsnd__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        msgsnd(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__msgsnd__noreturn() {
+  int x = 1;
+  if (cond) { x=100; msgsnd(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__msgsnd__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    msgsnd(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__msgsnd__leakignore() {
+  char *p = malloc(10); *p=0;
+  msgsnd(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__msgsnd__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    msgsnd(x, arg2, arg3, arg4);
+void test__msgsnd__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  msgsnd(x, arg2, arg3, arg4);
 }
 
-void test__msgsnd__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    msgsnd(arg1, NULL, arg3, arg4);
+void test__msgsnd__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  msgsnd(arg1, NULL, arg3, arg4);
 }
 
-void test__msgsnd__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    msgsnd(arg1, arg2, x, arg4);
+void test__msgsnd__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  msgsnd(arg1, arg2, x, arg4);
 }
 
-void test__msgsnd__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    msgsnd(arg1, arg2, arg3, x);
+void test__msgsnd__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  msgsnd(arg1, arg2, arg3, x);
 }
 
-void test__tcflow__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        tcflow(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tcflow__noreturn() {
+  int x = 1;
+  if (cond) { x=100; tcflow(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tcflow__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    tcflow(p, arg2);
-    // cppcheck-suppress memleak
+void test__tcflow__leakignore() {
+  char *p = malloc(10); *p=0;
+  tcflow(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__tcflow__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    tcflow(x, arg2);
+void test__tcflow__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tcflow(x, arg2);
 }
 
-void test__tcflow__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    tcflow(arg1, x);
+void test__tcflow__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tcflow(arg1, x);
 }
 
-void test__tcflush__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        tcflush(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tcflush__noreturn() {
+  int x = 1;
+  if (cond) { x=100; tcflush(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tcflush__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    tcflush(p, arg2);
-    // cppcheck-suppress memleak
+void test__tcflush__leakignore() {
+  char *p = malloc(10); *p=0;
+  tcflush(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__tcflush__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    tcflush(x, arg2);
+void test__tcflush__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tcflush(x, arg2);
 }
 
-void test__tcflush__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    tcflush(arg1, x);
+void test__tcflush__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tcflush(arg1, x);
 }
 
-void test__tcsendbreak__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        tcsendbreak(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tcsendbreak__noreturn() {
+  int x = 1;
+  if (cond) { x=100; tcsendbreak(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tcsendbreak__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    tcsendbreak(p, arg2);
-    // cppcheck-suppress memleak
+void test__tcsendbreak__leakignore() {
+  char *p = malloc(10); *p=0;
+  tcsendbreak(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__tcsendbreak__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    tcsendbreak(x, arg2);
+void test__tcsendbreak__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tcsendbreak(x, arg2);
 }
 
-void test__tcsendbreak__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    tcsendbreak(arg1, NULL);
+void test__tcsendbreak__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  tcsendbreak(arg1, NULL);
 }
 
-void test__tcgetattr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        tcgetattr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tcgetattr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; tcgetattr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tcgetattr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    tcgetattr(p, arg2);
-    // cppcheck-suppress memleak
+void test__tcgetattr__leakignore() {
+  char *p = malloc(10); *p=0;
+  tcgetattr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__tcgetattr__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    tcgetattr(x, arg2);
+void test__tcgetattr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tcgetattr(x, arg2);
 }
 
-void test__tcgetattr__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    tcgetattr(arg1, NULL);
+void test__tcgetattr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  tcgetattr(arg1, NULL);
 }
 
-void test__tcsetattr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        tcsetattr(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tcsetattr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; tcsetattr(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tcsetattr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    tcsetattr(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__tcsetattr__leakignore() {
+  char *p = malloc(10); *p=0;
+  tcsetattr(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__tcsetattr__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    tcsetattr(x, arg2, arg3);
+void test__tcsetattr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tcsetattr(x, arg2, arg3);
 }
 
-void test__tcsetattr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    tcsetattr(arg1, x, arg3);
+void test__tcsetattr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tcsetattr(arg1, x, arg3);
 }
 
-void test__tcsetattr__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    tcsetattr(arg1, arg2, NULL);
+void test__tcsetattr__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  tcsetattr(arg1, arg2, NULL);
 }
 
-void test__tcsetattr__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    tcsetattr(arg1, arg2, x);
+void test__tcsetattr__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  tcsetattr(arg1, arg2, x);
 }
 
-void test__cfsetospeed__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        cfsetospeed(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cfsetospeed__noreturn() {
+  int x = 1;
+  if (cond) { x=100; cfsetospeed(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cfsetospeed__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    cfsetospeed(p, arg2);
-    // cppcheck-suppress memleak
+void test__cfsetospeed__leakignore() {
+  char *p = malloc(10); *p=0;
+  cfsetospeed(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__cfsetospeed__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    cfsetospeed(NULL, arg2);
+void test__cfsetospeed__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  cfsetospeed(NULL, arg2);
 }
 
-void test__cfsetospeed__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    cfsetospeed(x, arg2);
+void test__cfsetospeed__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  cfsetospeed(x, arg2);
 }
 
-void test__cfsetospeed__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    cfsetospeed(arg1, x);
+void test__cfsetospeed__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  cfsetospeed(arg1, x);
 }
 
-void test__cfsetispeed__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        cfsetispeed(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cfsetispeed__noreturn() {
+  int x = 1;
+  if (cond) { x=100; cfsetispeed(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cfsetispeed__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    cfsetispeed(p, arg2);
-    // cppcheck-suppress memleak
+void test__cfsetispeed__leakignore() {
+  char *p = malloc(10); *p=0;
+  cfsetispeed(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__cfsetispeed__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    cfsetispeed(NULL, arg2);
+void test__cfsetispeed__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  cfsetispeed(NULL, arg2);
 }
 
-void test__cfsetispeed__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    cfsetispeed(x, arg2);
+void test__cfsetispeed__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  cfsetispeed(x, arg2);
 }
 
-void test__cfsetispeed__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    cfsetispeed(arg1, x);
+void test__cfsetispeed__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  cfsetispeed(arg1, x);
 }
 
-void test__tcdrain__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        tcdrain(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tcdrain__noreturn() {
+  int x = 1;
+  if (cond) { x=100; tcdrain(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tcdrain__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    tcdrain(p);
-    // cppcheck-suppress memleak
+void test__tcdrain__leakignore() {
+  char *p = malloc(10); *p=0;
+  tcdrain(p);
+  // cppcheck-suppress memleak
 }
 
-void test__tcdrain__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    tcdrain(x);
+void test__tcdrain__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tcdrain(x);
 }
 
diff --git a/test/cfg/generated-cfg-tests-qt.cpp b/test/cfg/generated-cfg-tests-qt.cpp
index 68a848ea7..c52cacda4 100644
--- a/test/cfg/generated-cfg-tests-qt.cpp
+++ b/test/cfg/generated-cfg-tests-qt.cpp
@@ -8,2092 +8,1541 @@
 // => 'unmatched suppression' warnings are false negatives.
 //
 
-void test__connect__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        connect(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__connect__noreturn() {
+  int x = 1;
+  if (cond) { x=100; connect(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__connect__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    connect(NULL, arg2, arg3, arg4);
+void test__connect__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  connect(NULL, arg2, arg3, arg4);
 }
 
-void test__connect__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    connect(x, arg2, arg3, arg4);
+void test__connect__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  connect(x, arg2, arg3, arg4);
 }
 
-void test__connect__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    connect(arg1, x, arg3, arg4);
+void test__connect__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  connect(arg1, x, arg3, arg4);
 }
 
-void test__connect__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    connect(arg1, arg2, NULL, arg4);
+void test__connect__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  connect(arg1, arg2, NULL, arg4);
 }
 
-void test__connect__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    connect(arg1, arg2, x, arg4);
+void test__connect__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  connect(arg1, arg2, x, arg4);
 }
 
-void test__connect__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    connect(arg1, arg2, arg3, x);
+void test__connect__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  connect(arg1, arg2, arg3, x);
 }
 
-void test__disconnect__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        disconnect(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__disconnect__noreturn() {
+  int x = 1;
+  if (cond) { x=100; disconnect(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__disconnect__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    disconnect(NULL, arg2, arg3, arg4);
+void test__disconnect__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  disconnect(NULL, arg2, arg3, arg4);
 }
 
-void test__disconnect__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    disconnect(x, arg2, arg3, arg4);
+void test__disconnect__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  disconnect(x, arg2, arg3, arg4);
 }
 
-void test__disconnect__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    disconnect(arg1, x, arg3, arg4);
+void test__disconnect__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  disconnect(arg1, x, arg3, arg4);
 }
 
-void test__disconnect__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    disconnect(arg1, arg2, NULL, arg4);
+void test__disconnect__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  disconnect(arg1, arg2, NULL, arg4);
 }
 
-void test__disconnect__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    disconnect(arg1, arg2, x, arg4);
+void test__disconnect__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  disconnect(arg1, arg2, x, arg4);
 }
 
-void test__disconnect__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    disconnect(arg1, arg2, arg3, x);
+void test__disconnect__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  disconnect(arg1, arg2, arg3, x);
 }
 
-void test__tr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = tr(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = tr(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    tr(arg1, arg2, arg3);
+void test__tr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tr(arg1, arg2, arg3);
 }
 
-void test__tr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = tr(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__tr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = tr(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__tr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = tr(NULL, arg2, arg3);
+void test__tr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = tr(NULL, arg2, arg3);
 }
 
-void test__tr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = tr(x, arg2, arg3);
+void test__tr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = tr(x, arg2, arg3);
 }
 
-void test__tr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = tr(arg1, x, arg3);
+void test__tr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tr(arg1, x, arg3);
 }
 
-void test__tr__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = tr(arg1, arg2, x);
+void test__tr__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tr(arg1, arg2, x);
 }
 
-void test__QObject__tr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QObject::tr(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QObject__tr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QObject::tr(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QObject__tr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QObject::tr(arg1, arg2, arg3);
+void test__QObject__tr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QObject::tr(arg1, arg2, arg3);
 }
 
-void test__QObject__tr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = QObject::tr(NULL, arg2, arg3);
+void test__QObject__tr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = QObject::tr(NULL, arg2, arg3);
 }
 
-void test__QObject__tr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = QObject::tr(x, arg2, arg3);
+void test__QObject__tr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = QObject::tr(x, arg2, arg3);
 }
 
-void test__QObject__tr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QObject::tr(arg1, x, arg3);
+void test__QObject__tr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QObject::tr(arg1, x, arg3);
 }
 
-void test__QObject__tr__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QObject::tr(arg1, arg2, x);
+void test__QObject__tr__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QObject::tr(arg1, arg2, x);
 }
 
-void test__QSettings__setValue__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        QSettings::setValue(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QSettings__setValue__noreturn() {
+  int x = 1;
+  if (cond) { x=100; QSettings::setValue(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QSettings__setValue__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    QSettings::setValue(NULL, arg2);
+void test__QSettings__setValue__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  QSettings::setValue(NULL, arg2);
 }
 
-void test__QSettings__setValue__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    QSettings::setValue(x, arg2);
+void test__QSettings__setValue__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  QSettings::setValue(x, arg2);
 }
 
-void test__QSettings__setValue__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    QSettings::setValue(arg1, x);
+void test__QSettings__setValue__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  QSettings::setValue(arg1, x);
 }
 
-void test__QSettings__value__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QSettings::value(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QSettings__value__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QSettings::value(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QSettings__value__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QSettings::value(arg1, arg2);
+void test__QSettings__value__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QSettings::value(arg1, arg2);
 }
 
-void test__QSettings__value__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = QSettings::value(NULL, arg2);
+void test__QSettings__value__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = QSettings::value(NULL, arg2);
 }
 
-void test__QSettings__value__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = QSettings::value(x, arg2);
+void test__QSettings__value__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = QSettings::value(x, arg2);
 }
 
-void test__QSettings__value__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QSettings::value(arg1, x);
+void test__QSettings__value__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QSettings::value(arg1, x);
 }
 
-void test__QString__sprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        QString::sprintf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QString__sprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; QString::sprintf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__sprintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    QString::sprintf(x);
+void test__QString__sprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  QString::sprintf(x);
 }
 
-void test__QString__asprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        QString::asprintf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QString__asprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; QString::asprintf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__asprintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    QString::asprintf(x);
-}
+void test__QString__asprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  QString::asprintf(x);
+}
+
+void test__QList__at__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::at(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__at__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::at(arg1);
+}
+
+void test__QList__at__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QList::at(x);
+}
+
+void test__QString__at__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::at(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__at__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::at(arg1);
+}
+
+void test__QString__at__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::at(x);
+}
+
+void test__QStringList__at__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::at(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__at__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::at(arg1);
+}
+
+void test__QStringList__at__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QStringList::at(x);
+}
+
+void test__QString__capacity__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::capacity(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__capacity__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::capacity();
+}
+
+void test__QList__begin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::begin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__begin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::begin();
+}
+
+void test__QList__end__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::end(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__end__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::end();
+}
+
+void test__QList__cbegin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::cbegin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__cbegin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::cbegin();
+}
+
+void test__QList__cend__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::cend(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__cend__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::cend();
+}
+
+void test__QList__constBegin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::constBegin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__constBegin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::constBegin();
+}
+
+void test__QList__constEnd__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::constEnd(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__constEnd__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::constEnd();
+}
+
+void test__QList__rbegin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::rbegin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__rbegin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::rbegin();
+}
+
+void test__QList__rend__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::rend(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__rend__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::rend();
+}
+
+void test__QList__crbegin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::crbegin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__crbegin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::crbegin();
+}
+
+void test__QList__crend__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::crend(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__crend__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::crend();
+}
+
+void test__QString__begin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::begin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__begin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::begin();
+}
+
+void test__QString__end__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::end(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__end__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::end();
+}
+
+void test__QString__cbegin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::cbegin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__cbegin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::cbegin();
+}
+
+void test__QString__cend__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::cend(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__cend__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::cend();
+}
+
+void test__QString__constBegin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::constBegin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__constBegin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::constBegin();
+}
+
+void test__QString__constEnd__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::constEnd(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__constEnd__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::constEnd();
+}
+
+void test__QString__rbegin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::rbegin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__rbegin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::rbegin();
+}
+
+void test__QString__rend__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::rend(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__rend__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::rend();
+}
+
+void test__QString__crbegin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::crbegin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__crbegin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::crbegin();
+}
+
+void test__QString__crend__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::crend(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__crend__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::crend();
+}
+
+void test__QStringList__begin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::begin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__begin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::begin();
+}
+
+void test__QStringList__end__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::end(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__end__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::end();
+}
+
+void test__QStringList__cbegin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::cbegin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__cbegin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::cbegin();
+}
+
+void test__QStringList__cend__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::cend(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__cend__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::cend();
+}
+
+void test__QStringList__constBegin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::constBegin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__constBegin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::constBegin();
+}
+
+void test__QStringList__constEnd__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::constEnd(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__constEnd__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::constEnd();
+}
+
+void test__QStringList__rbegin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::rbegin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__rbegin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::rbegin();
+}
+
+void test__QStringList__rend__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::rend(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__rend__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::rend();
+}
+
+void test__QStringList__crbegin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::crbegin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__crbegin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::crbegin();
+}
 
-void test__QList__at__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::at(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QStringList__crend__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::crend(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QList__at__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::at(arg1);
-}
+void test__QStringList__crend__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::crend();
+}
+
+void test__QString__chop__noreturn() {
+  int x = 1;
+  if (cond) { x=100; QString::chop(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__chop__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  QString::chop(x);
+}
+
+void test__QList__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; QList::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; QString::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__compare__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::compare(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__compare__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::compare(arg1, arg2, arg3);
+}
+
+void test__QString__compare__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::compare(x, arg2, arg3);
+}
+
+void test__QString__compare__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::compare(arg1, x, arg3);
+}
+
+void test__QString__compare__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::compare(arg1, arg2, x);
+}
+
+void test__QList__contains__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::contains(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__contains__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::contains(arg1);
+}
+
+void test__QList__contains__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QList::contains(x);
+}
+
+void test__QList__startsWith__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::startsWith(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__startsWith__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::startsWith(arg1);
+}
+
+void test__QList__startsWith__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QList::startsWith(x);
+}
+
+void test__QList__endsWith__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::endsWith(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__endsWith__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::endsWith(arg1);
+}
 
-void test__QList__at__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QList::at(x);
+void test__QList__endsWith__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QList::endsWith(x);
 }
 
-void test__QString__at__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::at(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QString__contains__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::contains(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__at__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::at(arg1);
+void test__QString__contains__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::contains(arg1, arg2);
 }
 
-void test__QString__at__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::at(x);
-}
-
-void test__QStringList__at__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::at(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__at__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::at(arg1);
-}
-
-void test__QStringList__at__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QStringList::at(x);
-}
-
-void test__QString__capacity__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::capacity();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__capacity__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::capacity();
-}
-
-void test__QList__begin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::begin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__begin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::begin();
-}
-
-void test__QList__end__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::end();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__end__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::end();
-}
-
-void test__QList__cbegin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::cbegin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__cbegin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::cbegin();
-}
-
-void test__QList__cend__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::cend();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__cend__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::cend();
-}
-
-void test__QList__constBegin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::constBegin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__constBegin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::constBegin();
-}
-
-void test__QList__constEnd__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::constEnd();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__constEnd__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::constEnd();
-}
-
-void test__QList__rbegin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::rbegin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__rbegin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::rbegin();
-}
-
-void test__QList__rend__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::rend();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__rend__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::rend();
-}
-
-void test__QList__crbegin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::crbegin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__crbegin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::crbegin();
-}
-
-void test__QList__crend__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::crend();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__crend__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::crend();
-}
-
-void test__QString__begin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::begin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__begin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::begin();
-}
-
-void test__QString__end__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::end();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__end__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::end();
-}
-
-void test__QString__cbegin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::cbegin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__cbegin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::cbegin();
-}
-
-void test__QString__cend__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::cend();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__cend__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::cend();
-}
-
-void test__QString__constBegin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::constBegin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__constBegin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::constBegin();
-}
-
-void test__QString__constEnd__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::constEnd();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__constEnd__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::constEnd();
-}
-
-void test__QString__rbegin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::rbegin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__rbegin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::rbegin();
-}
-
-void test__QString__rend__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::rend();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__rend__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::rend();
-}
-
-void test__QString__crbegin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::crbegin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__crbegin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::crbegin();
-}
-
-void test__QString__crend__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::crend();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__crend__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::crend();
-}
-
-void test__QStringList__begin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::begin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__begin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::begin();
-}
-
-void test__QStringList__end__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::end();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__end__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::end();
-}
-
-void test__QStringList__cbegin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::cbegin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__cbegin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::cbegin();
-}
-
-void test__QStringList__cend__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::cend();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__cend__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::cend();
-}
-
-void test__QStringList__constBegin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::constBegin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__constBegin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::constBegin();
-}
-
-void test__QStringList__constEnd__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::constEnd();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__constEnd__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::constEnd();
-}
-
-void test__QStringList__rbegin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::rbegin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__rbegin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::rbegin();
-}
-
-void test__QStringList__rend__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::rend();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__rend__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::rend();
-}
-
-void test__QStringList__crbegin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::crbegin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__crbegin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::crbegin();
-}
-
-void test__QStringList__crend__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::crend();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__crend__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::crend();
-}
-
-void test__QString__chop__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        QString::chop(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__chop__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    QString::chop(x);
-}
-
-void test__QList__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        QList::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        QString::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__compare__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::compare(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__compare__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::compare(arg1, arg2, arg3);
-}
-
-void test__QString__compare__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::compare(x, arg2, arg3);
-}
-
-void test__QString__compare__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::compare(arg1, x, arg3);
-}
-
-void test__QString__compare__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::compare(arg1, arg2, x);
-}
-
-void test__QList__contains__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::contains(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__contains__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::contains(arg1);
-}
-
-void test__QList__contains__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QList::contains(x);
-}
-
-void test__QList__startsWith__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::startsWith(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QString__contains__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::contains(x, arg2);
 }
 
-void test__QList__startsWith__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::startsWith(arg1);
-}
-
-void test__QList__startsWith__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QList::startsWith(x);
+void test__QString__contains__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::contains(arg1, x);
 }
 
-void test__QList__endsWith__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::endsWith(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QString__startsWith__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::startsWith(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QList__endsWith__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::endsWith(arg1);
+void test__QString__startsWith__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::startsWith(arg1, arg2);
 }
 
-void test__QList__endsWith__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QList::endsWith(x);
+void test__QString__startsWith__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::startsWith(x, arg2);
 }
 
-void test__QString__contains__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::contains(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QString__startsWith__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::startsWith(arg1, x);
 }
 
-void test__QString__contains__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::contains(arg1, arg2);
+void test__QString__endsWith__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::endsWith(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__contains__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::contains(x, arg2);
+void test__QString__endsWith__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::endsWith(arg1, arg2);
 }
 
-void test__QString__contains__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::contains(arg1, x);
+void test__QString__endsWith__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::endsWith(x, arg2);
 }
 
-void test__QString__startsWith__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::startsWith(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QString__endsWith__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::endsWith(arg1, x);
 }
 
-void test__QString__startsWith__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::startsWith(arg1, arg2);
+void test__QStringList__contains__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::contains(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__startsWith__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::startsWith(x, arg2);
+void test__QStringList__contains__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::contains(arg1);
 }
 
-void test__QString__startsWith__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::startsWith(arg1, x);
+void test__QStringList__contains__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QStringList::contains(x);
 }
 
-void test__QString__endsWith__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::endsWith(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QStringList__startsWith__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::startsWith(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__endsWith__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::endsWith(arg1, arg2);
+void test__QStringList__startsWith__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::startsWith(arg1);
 }
 
-void test__QString__endsWith__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::endsWith(x, arg2);
+void test__QStringList__startsWith__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QStringList::startsWith(x);
 }
 
-void test__QString__endsWith__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::endsWith(arg1, x);
+void test__QStringList__endsWith__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::endsWith(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QStringList__contains__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::contains(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QStringList__endsWith__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::endsWith(arg1);
 }
 
-void test__QStringList__contains__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::contains(arg1);
+void test__QStringList__endsWith__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QStringList::endsWith(x);
 }
 
-void test__QStringList__contains__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QStringList::contains(x);
+void test__QList__count__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::count(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QStringList__startsWith__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::startsWith(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QList__count__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::count();
 }
 
-void test__QStringList__startsWith__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::startsWith(arg1);
+void test__QList__length__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::length(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QStringList__startsWith__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QStringList::startsWith(x);
+void test__QList__length__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::length();
 }
 
-void test__QStringList__endsWith__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::endsWith(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QList__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QStringList__endsWith__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::endsWith(arg1);
-}
-
-void test__QStringList__endsWith__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QStringList::endsWith(x);
-}
-
-void test__QList__count__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::count();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__count__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::count();
-}
-
-void test__QList__length__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::length();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__length__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::length();
-}
-
-void test__QList__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::size();
-}
-
-void test__QString__count__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::count();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__count__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::count();
-}
-
-void test__QString__length__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::length();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__length__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::length();
-}
-
-void test__QString__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::size();
-}
-
-void test__QStringList__count__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::count();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__count__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::count();
-}
-
-void test__QStringList__length__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::length();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__length__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::length();
-}
-
-void test__QStringList__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::size();
-}
-
-void test__QList__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::empty();
-}
-
-void test__QList__isEmpty__QString__isEmpty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::isEmpty::QString::isEmpty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__isEmpty__QString__isEmpty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::isEmpty::QString::isEmpty();
-}
-
-void test__QString__isNull__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::isNull();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__isNull__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::isNull();
-}
-
-void test__QStringList__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::empty();
-}
-
-void test__QStringList__isEmpty____noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::isEmpty::();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__isEmpty____useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::isEmpty::();
-}
-
-void test__QString__fromStdString__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::fromStdString(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__fromStdString__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::fromStdString(arg1);
-}
-
-void test__QList__indexOf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::indexOf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QList__indexOf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::indexOf(arg1);
-}
-
-void test__QList__indexOf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QList::indexOf(x);
-}
+void test__QList__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::size();
+}
+
+void test__QString__count__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::count(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__count__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::count();
+}
+
+void test__QString__length__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::length(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__length__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::length();
+}
 
-void test__QStringList__indexOf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::indexOf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QStringList__indexOf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::indexOf(arg1);
+void test__QString__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QStringList__indexOf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QStringList::indexOf(x);
+void test__QString__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::size();
 }
 
-void test__QString__indexOf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::indexOf();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QStringList__count__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::count(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__indexOf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::indexOf();
+void test__QStringList__count__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::count();
 }
 
-void test__QString__isRightToLeft__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::isRightToLeft();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QStringList__length__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::length(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__isRightToLeft__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::isRightToLeft();
+void test__QStringList__length__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::length();
 }
 
-void test__QList__lastIndexOf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::lastIndexOf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QStringList__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QList__lastIndexOf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::lastIndexOf(arg1, arg2);
+void test__QStringList__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::size();
 }
 
-void test__QList__lastIndexOf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QList::lastIndexOf(x, arg2);
+void test__QList__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QList__lastIndexOf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QList::lastIndexOf(arg1, x);
+void test__QList__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::empty();
 }
 
-void test__QStringList__lastIndexOf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::lastIndexOf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QList__isEmpty__QString__isEmpty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::isEmpty::QString::isEmpty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QStringList__lastIndexOf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::lastIndexOf(arg1, arg2);
+void test__QList__isEmpty__QString__isEmpty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::isEmpty::QString::isEmpty();
 }
 
-void test__QStringList__lastIndexOf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QStringList::lastIndexOf(x, arg2);
+void test__QString__isNull__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::isNull(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QStringList__lastIndexOf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QStringList::lastIndexOf(arg1, x);
+void test__QString__isNull__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::isNull();
 }
 
-void test__QString__lastIndexOf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::lastIndexOf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QStringList__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__lastIndexOf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::lastIndexOf(arg1, arg2, arg3);
+void test__QStringList__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::empty();
 }
 
-void test__QString__lastIndexOf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::lastIndexOf(x, arg2, arg3);
+void test__QStringList__isEmpty____noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::isEmpty::(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__lastIndexOf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::lastIndexOf(arg1, x, arg3);
+void test__QStringList__isEmpty____useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::isEmpty::();
 }
 
-void test__QString__lastIndexOf__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::lastIndexOf(arg1, arg2, x);
+void test__QString__fromStdString__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::fromStdString(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__left__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::left(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QString__fromStdString__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::fromStdString(arg1);
 }
 
-void test__QString__left__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::left(arg1);
+void test__QList__indexOf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::indexOf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__left__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::left(x);
+void test__QList__indexOf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::indexOf(arg1);
 }
 
-void test__QList__mid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QList::mid(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QList__indexOf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QList::indexOf(x);
 }
 
-void test__QList__mid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QList::mid(arg1, arg2);
+void test__QStringList__indexOf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::indexOf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QList__mid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QList::mid(x, arg2);
+void test__QStringList__indexOf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::indexOf(arg1);
 }
 
-void test__QList__mid__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QList::mid(arg1, x);
+void test__QStringList__indexOf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QStringList::indexOf(x);
 }
 
-void test__QString__mid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::mid(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QString__indexOf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::indexOf(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__mid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::mid(arg1, arg2);
+void test__QString__indexOf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::indexOf();
 }
 
-void test__QString__mid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::mid(x, arg2);
+void test__QString__isRightToLeft__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::isRightToLeft(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__mid__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::mid(arg1, x);
+void test__QString__isRightToLeft__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::isRightToLeft();
 }
 
-void test__QStringList__mid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QStringList::mid(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QList__lastIndexOf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::lastIndexOf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QStringList__mid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QStringList::mid(arg1, arg2);
+void test__QList__lastIndexOf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::lastIndexOf(arg1, arg2);
 }
 
-void test__QStringList__mid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QStringList::mid(x, arg2);
+void test__QList__lastIndexOf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QList::lastIndexOf(x, arg2);
 }
 
-void test__QStringList__mid__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QStringList::mid(arg1, x);
+void test__QList__lastIndexOf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QList::lastIndexOf(arg1, x);
 }
 
-void test__QString__number__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::number();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QStringList__lastIndexOf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::lastIndexOf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__number__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::number();
+void test__QStringList__lastIndexOf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::lastIndexOf(arg1, arg2);
 }
 
-void test__QString__right__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::right(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QStringList__lastIndexOf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QStringList::lastIndexOf(x, arg2);
 }
 
-void test__QString__right__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::right(arg1);
+void test__QStringList__lastIndexOf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QStringList::lastIndexOf(arg1, x);
 }
 
-void test__QString__right__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = QString::right(!x);
+void test__QString__lastIndexOf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::lastIndexOf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__right__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::right(x);
+void test__QString__lastIndexOf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::lastIndexOf(arg1, arg2, arg3);
 }
 
-void test__QString__split__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::split(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QString__lastIndexOf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::lastIndexOf(x, arg2, arg3);
 }
 
-void test__QString__split__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::split(arg1);
-}
+void test__QString__lastIndexOf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::lastIndexOf(arg1, x, arg3);
+}
+
+void test__QString__lastIndexOf__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::lastIndexOf(arg1, arg2, x);
+}
+
+void test__QString__left__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::left(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__left__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::left(arg1);
+}
+
+void test__QString__left__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::left(x);
+}
 
-void test__QString__split__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::split(x);
+void test__QList__mid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QList::mid(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QString__toInt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::toInt(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QList__mid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::mid(arg1, arg2);
 }
 
-void test__QString__toInt__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::toInt(arg1, arg2);
+void test__QList__mid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QList::mid(x, arg2);
 }
 
-void test__QString__toInt__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::toInt(x, arg2);
-}
-
-void test__QString__toInt__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QString::toInt(arg1, x);
-}
-
-void test__QString__toLower__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::toLower();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__toLower__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::toLower();
-}
-
-void test__QString__toStdString__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::toStdString();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QList__mid__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QList::mid(arg1, x);
 }
 
-void test__QString__toStdString__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::toStdString();
-}
-
-void test__QString__toUpper__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::toUpper();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QString__mid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::mid(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__QString__toUpper__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::toUpper();
+
+void test__QString__mid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::mid(arg1, arg2);
+}
+
+void test__QString__mid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::mid(x, arg2);
+}
+
+void test__QString__mid__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::mid(arg1, x);
+}
+
+void test__QStringList__mid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QStringList::mid(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__mid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::mid(arg1, arg2);
+}
+
+void test__QStringList__mid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QStringList::mid(x, arg2);
+}
+
+void test__QStringList__mid__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QStringList::mid(arg1, x);
+}
+
+void test__QString__number__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::number(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__number__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::number();
 }
 
-void test__QString__toUtf8__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::toUtf8();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QString__right__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::right(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__QString__toUtf8__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::toUtf8();
-}
-
-void test__QString__trimmed__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QString::trimmed();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QString__trimmed__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QString::trimmed();
-}
-
-void test__QMetaObject__connectSlotsByName__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        QMetaObject::connectSlotsByName(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QMetaObject__connectSlotsByName__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    QMetaObject::connectSlotsByName(NULL);
-}
-
-void test__QDir__fromNativeSeparators__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QDir::fromNativeSeparators(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QDir__fromNativeSeparators__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QDir::fromNativeSeparators(arg1);
-}
-
-void test__QDir__fromNativeSeparators__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QDir::fromNativeSeparators(x);
-}
-
-void test__QDir__toNativeSeparators__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QDir::toNativeSeparators(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QDir__toNativeSeparators__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QDir::toNativeSeparators(arg1);
-}
-
-void test__QDir__toNativeSeparators__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QDir::toNativeSeparators(x);
-}
-
-void test__QFile__open__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        QFile::open();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QFile__remove__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        QFile::remove();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QFile__rename__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        QFile::rename();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QFile__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QFile::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QFile__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QFile::size();
-}
-
-void test__QIODevice__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QIODevice::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__QIODevice__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QIODevice::size();
+
+void test__QString__right__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::right(arg1);
+}
+
+void test__QString__right__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = QString::right(!x);
+}
+
+void test__QString__right__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::right(x);
+}
+
+void test__QString__split__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::split(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__split__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::split(arg1);
+}
+
+void test__QString__split__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::split(x);
+}
+
+void test__QString__toInt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::toInt(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__toInt__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::toInt(arg1, arg2);
+}
+
+void test__QString__toInt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::toInt(x, arg2);
+}
+
+void test__QString__toInt__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::toInt(arg1, x);
+}
+
+void test__QString__toLower__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::toLower(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__toLower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::toLower();
+}
+
+void test__QString__toStdString__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::toStdString(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__toStdString__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::toStdString();
+}
+
+void test__QString__toUpper__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::toUpper(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__toUpper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::toUpper();
+}
+
+void test__QString__toUtf8__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::toUtf8(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__toUtf8__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::toUtf8();
+}
+
+void test__QString__trimmed__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QString::trimmed(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__trimmed__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::trimmed();
+}
+
+void test__QMetaObject__connectSlotsByName__noreturn() {
+  int x = 1;
+  if (cond) { x=100; QMetaObject::connectSlotsByName(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QMetaObject__connectSlotsByName__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  QMetaObject::connectSlotsByName(NULL);
+}
+
+void test__QDir__fromNativeSeparators__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QDir::fromNativeSeparators(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QDir__fromNativeSeparators__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QDir::fromNativeSeparators(arg1);
+}
+
+void test__QDir__fromNativeSeparators__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QDir::fromNativeSeparators(x);
+}
+
+void test__QDir__toNativeSeparators__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QDir::toNativeSeparators(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QDir__toNativeSeparators__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QDir::toNativeSeparators(arg1);
+}
+
+void test__QDir__toNativeSeparators__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QDir::toNativeSeparators(x);
+}
+
+void test__QFile__open__noreturn() {
+  int x = 1;
+  if (cond) { x=100; QFile::open(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QFile__remove__noreturn() {
+  int x = 1;
+  if (cond) { x=100; QFile::remove(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QFile__rename__noreturn() {
+  int x = 1;
+  if (cond) { x=100; QFile::rename(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QFile__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QFile::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QFile__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QFile::size();
+}
+
+void test__QIODevice__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QIODevice::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QIODevice__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QIODevice::size();
 }
 
diff --git a/test/cfg/generated-cfg-tests-sdl.cpp b/test/cfg/generated-cfg-tests-sdl.cpp
index 8a3ec088e..60627e0da 100644
--- a/test/cfg/generated-cfg-tests-sdl.cpp
+++ b/test/cfg/generated-cfg-tests-sdl.cpp
@@ -8,153 +8,115 @@
 // => 'unmatched suppression' warnings are false negatives.
 //
 
-void test__SDL_mutexP__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SDL_mutexP(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SDL_mutexP__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SDL_mutexP(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SDL_mutexP__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    SDL_mutexP(!x);
+void test__SDL_mutexP__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  SDL_mutexP(!x);
 }
 
-void test__SDL_mutexP__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SDL_mutexP(NULL);
+void test__SDL_mutexP__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SDL_mutexP(NULL);
 }
 
-void test__SDL_mutexV__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SDL_mutexV(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SDL_mutexV__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SDL_mutexV(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SDL_mutexV__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    SDL_mutexV(!x);
+void test__SDL_mutexV__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  SDL_mutexV(!x);
 }
 
-void test__SDL_mutexV__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SDL_mutexV(NULL);
+void test__SDL_mutexV__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SDL_mutexV(NULL);
 }
 
-void test__SDL_RWsize__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SDL_RWsize(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SDL_RWsize__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SDL_RWsize(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SDL_RWsize__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    SDL_RWsize(!x);
+void test__SDL_RWsize__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  SDL_RWsize(!x);
 }
 
-void test__SDL_RWsize__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SDL_RWsize(NULL);
+void test__SDL_RWsize__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SDL_RWsize(NULL);
 }
 
-void test__SDL_RWread__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SDL_RWread(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SDL_RWread__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SDL_RWread(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SDL_RWread__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    SDL_RWread(!x, arg2);
+void test__SDL_RWread__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  SDL_RWread(!x, arg2);
 }
 
-void test__SDL_RWread__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SDL_RWread(NULL, arg2);
+void test__SDL_RWread__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SDL_RWread(NULL, arg2);
 }
 
-void test__SDL_RWread__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    SDL_RWread(arg1, !x);
+void test__SDL_RWread__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  SDL_RWread(arg1, !x);
 }
 
-void test__SDL_RWread__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SDL_RWread(arg1, NULL);
+void test__SDL_RWread__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  SDL_RWread(arg1, NULL);
 }
 
-void test__IMG_isPNG__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        IMG_isPNG(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__IMG_isPNG__noreturn() {
+  int x = 1;
+  if (cond) { x=100; IMG_isPNG(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__IMG_isPNG__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    IMG_isPNG(!x);
+void test__IMG_isPNG__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  IMG_isPNG(!x);
 }
 
-void test__IMG_isPNG__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    IMG_isPNG(NULL);
+void test__IMG_isPNG__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  IMG_isPNG(NULL);
 }
 
-void test__IMG_isJPG__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        IMG_isJPG(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__IMG_isJPG__noreturn() {
+  int x = 1;
+  if (cond) { x=100; IMG_isJPG(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__IMG_isJPG__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    IMG_isJPG(!x);
+void test__IMG_isJPG__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  IMG_isJPG(!x);
 }
 
-void test__IMG_isJPG__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    IMG_isJPG(NULL);
+void test__IMG_isJPG__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  IMG_isJPG(NULL);
 }
 
diff --git a/test/cfg/generated-cfg-tests-sfml.cpp b/test/cfg/generated-cfg-tests-sfml.cpp
index cea9f8b49..e4909f49d 100644
--- a/test/cfg/generated-cfg-tests-sfml.cpp
+++ b/test/cfg/generated-cfg-tests-sfml.cpp
@@ -8,1856 +8,1350 @@
 // => 'unmatched suppression' warnings are false negatives.
 //
 
-void test__sf__err__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::err();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__err__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::err();
-}
-
-void test__sf__sleep__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::sleep(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__sleep__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::sleep(x);
-}
-
-void test__sf__Time__asSeconds__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::Time::asSeconds();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Time__asSeconds__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::Time::asSeconds();
-}
-
-void test__sf__Time__asMilliseconds__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::Time::asMilliseconds();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Time__asMilliseconds__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::Time::asMilliseconds();
-}
-
-void test__sf__Time__asMicroseconds__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::Time::asMicroseconds();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Time__asMicroseconds__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::Time::asMicroseconds();
-}
-
-void test__sf__String__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::String::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__String__isEmpty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::String::isEmpty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__String__isEmpty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::String::isEmpty();
-}
-
-void test__sf__String__getSize__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::String::getSize();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__String__getSize__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::String::getSize();
-}
-
-void test__sf__String__find__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::String::find(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__String__find__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    sf::String::find(NULL, arg2);
-}
-
-void test__sf__String__find__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    sf::String::find(x, arg2);
-}
-
-void test__sf__String__find__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::String::find(arg1, x);
-}
-
-void test__sf__String__substring__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::String::substring(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__String__substring__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::String::substring(arg1, arg2);
-}
-
-void test__sf__String__substring__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::String::substring(x, arg2);
-}
-
-void test__sf__String__substring__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::String::substring(arg1, x);
-}
-
-void test__sf__String__erase__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::String::erase(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__String__erase__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::String::erase(x, arg2);
-}
-
-void test__sf__String__erase__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::String::erase(arg1, x);
-}
-
-void test__sf__RenderTarget__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderTarget::clear(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTarget__clear__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderTarget::clear(x);
-}
-
-void test__sf__RenderWindow__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::clear(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__clear__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::clear(x);
-}
-
-void test__sf__RenderTexture__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderTexture::clear(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTexture__clear__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderTexture::clear(x);
-}
-
-void test__sf__RenderTarget__setView__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderTarget::setView(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTarget__setView__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderTarget::setView(x);
-}
-
-void test__sf__RenderWindow__setView__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::setView(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__setView__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::setView(x);
-}
-
-void test__sf__RenderTexture__setView__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderTexture::setView(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTexture__setView__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderTexture::setView(x);
-}
-
-void test__sf__RenderTarget__getView__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderTarget::getView();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTarget__getView__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderTarget::getView();
-}
-
-void test__sf__RenderTarget__getDefaultView__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderTarget::getDefaultView();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTarget__getDefaultView__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderTarget::getDefaultView();
-}
-
-void test__sf__RenderWindow__getView__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderWindow::getView();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__getView__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderWindow::getView();
-}
-
-void test__sf__RenderWindow__getDefaultView__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderWindow::getDefaultView();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__getDefaultView__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderWindow::getDefaultView();
-}
-
-void test__sf__RenderTexture__getView__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderTexture::getView();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTexture__getView__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderTexture::getView();
-}
-
-void test__sf__RenderTexture__getDefaultView__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderTexture::getDefaultView();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTexture__getDefaultView__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderTexture::getDefaultView();
-}
-
-void test__sf__RenderTarget__getViewport__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderTarget::getViewport(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTarget__getViewport__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderTarget::getViewport(arg1);
-}
-
-void test__sf__RenderTarget__getViewport__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::RenderTarget::getViewport(x);
+void test__sf__err__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::err(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderWindow__getViewport__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderWindow::getViewport(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sf__err__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::err();
 }
 
-void test__sf__RenderWindow__getViewport__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderWindow::getViewport(arg1);
+void test__sf__sleep__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::sleep(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderWindow__getViewport__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::RenderWindow::getViewport(x);
+void test__sf__sleep__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::sleep(x);
 }
 
-void test__sf__RenderTexture__getViewport__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderTexture::getViewport(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sf__Time__asSeconds__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::Time::asSeconds(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderTexture__getViewport__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderTexture::getViewport(arg1);
+void test__sf__Time__asSeconds__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::Time::asSeconds();
 }
 
-void test__sf__RenderTexture__getViewport__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::RenderTexture::getViewport(x);
+void test__sf__Time__asMilliseconds__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::Time::asMilliseconds(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderTarget__mapPixelToCoords__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderTarget::mapPixelToCoords(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sf__Time__asMilliseconds__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::Time::asMilliseconds();
 }
 
-void test__sf__RenderTarget__mapPixelToCoords__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderTarget::mapPixelToCoords(arg1, arg2);
+void test__sf__Time__asMicroseconds__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::Time::asMicroseconds(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderTarget__mapPixelToCoords__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::RenderTarget::mapPixelToCoords(x, arg2);
+void test__sf__Time__asMicroseconds__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::Time::asMicroseconds();
 }
 
-void test__sf__RenderTarget__mapPixelToCoords__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::RenderTarget::mapPixelToCoords(arg1, x);
+void test__sf__String__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::String::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderTarget__mapCoordsToPixel__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderTarget::mapCoordsToPixel(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sf__String__isEmpty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::String::isEmpty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderTarget__mapCoordsToPixel__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderTarget::mapCoordsToPixel(arg1, arg2);
+void test__sf__String__isEmpty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::String::isEmpty();
 }
 
-void test__sf__RenderTarget__mapCoordsToPixel__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::RenderTarget::mapCoordsToPixel(x, arg2);
+void test__sf__String__getSize__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::String::getSize(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderTarget__mapCoordsToPixel__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::RenderTarget::mapCoordsToPixel(arg1, x);
+void test__sf__String__getSize__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::String::getSize();
 }
 
-void test__sf__RenderWindow__mapPixelToCoords__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderWindow::mapPixelToCoords(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sf__String__find__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::String::find(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderWindow__mapPixelToCoords__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderWindow::mapPixelToCoords(arg1, arg2);
+void test__sf__String__find__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  sf::String::find(NULL, arg2);
 }
 
-void test__sf__RenderWindow__mapPixelToCoords__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::RenderWindow::mapPixelToCoords(x, arg2);
+void test__sf__String__find__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  sf::String::find(x, arg2);
 }
 
-void test__sf__RenderWindow__mapPixelToCoords__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::RenderWindow::mapPixelToCoords(arg1, x);
+void test__sf__String__find__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::String::find(arg1, x);
 }
 
-void test__sf__RenderWindow__mapCoordsToPixel__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderWindow::mapCoordsToPixel(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sf__String__substring__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::String::substring(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderWindow__mapCoordsToPixel__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderWindow::mapCoordsToPixel(arg1, arg2);
+void test__sf__String__substring__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::String::substring(arg1, arg2);
 }
 
-void test__sf__RenderWindow__mapCoordsToPixel__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::RenderWindow::mapCoordsToPixel(x, arg2);
+void test__sf__String__substring__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::String::substring(x, arg2);
 }
 
-void test__sf__RenderWindow__mapCoordsToPixel__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::RenderWindow::mapCoordsToPixel(arg1, x);
+void test__sf__String__substring__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::String::substring(arg1, x);
 }
 
-void test__sf__RenderTexture__mapPixelToCoords__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderTexture::mapPixelToCoords(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sf__String__erase__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::String::erase(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderTexture__mapPixelToCoords__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderTexture::mapPixelToCoords(arg1, arg2);
+void test__sf__String__erase__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::String::erase(x, arg2);
 }
 
-void test__sf__RenderTexture__mapPixelToCoords__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::RenderTexture::mapPixelToCoords(x, arg2);
+void test__sf__String__erase__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::String::erase(arg1, x);
 }
 
-void test__sf__RenderTexture__mapPixelToCoords__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::RenderTexture::mapPixelToCoords(arg1, x);
+void test__sf__RenderTarget__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderTarget::clear(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderTexture__mapCoordsToPixel__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderTexture::mapCoordsToPixel(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sf__RenderTarget__clear__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTarget::clear(x);
 }
 
-void test__sf__RenderTexture__mapCoordsToPixel__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderTexture::mapCoordsToPixel(arg1, arg2);
+void test__sf__RenderWindow__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::clear(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderTexture__mapCoordsToPixel__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::RenderTexture::mapCoordsToPixel(x, arg2);
+void test__sf__RenderWindow__clear__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::clear(x);
 }
 
-void test__sf__RenderTexture__mapCoordsToPixel__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sf::RenderTexture::mapCoordsToPixel(arg1, x);
+void test__sf__RenderTexture__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderTexture::clear(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderTarget__draw__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderTarget::draw(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sf__RenderTexture__clear__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTexture::clear(x);
 }
 
-void test__sf__RenderTarget__draw__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderTarget::draw(x, arg2, arg3, arg4);
+void test__sf__RenderTarget__setView__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderTarget::setView(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderTarget__draw__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderTarget::draw(arg1, x, arg3, arg4);
+void test__sf__RenderTarget__setView__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTarget::setView(x);
 }
 
-void test__sf__RenderTarget__draw__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderTarget::draw(arg1, arg2, x, arg4);
+void test__sf__RenderWindow__setView__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::setView(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderTarget__draw__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderTarget::draw(arg1, arg2, arg3, x);
+void test__sf__RenderWindow__setView__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setView(x);
 }
 
-void test__sf__RenderWindow__draw__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::draw(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sf__RenderTexture__setView__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderTexture::setView(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderWindow__draw__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::draw(x, arg2, arg3, arg4);
+void test__sf__RenderTexture__setView__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTexture::setView(x);
 }
 
-void test__sf__RenderWindow__draw__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::draw(arg1, x, arg3, arg4);
+void test__sf__RenderTarget__getView__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderTarget::getView(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderWindow__draw__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::draw(arg1, arg2, x, arg4);
+void test__sf__RenderTarget__getView__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderTarget::getView();
 }
 
-void test__sf__RenderWindow__draw__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::draw(arg1, arg2, arg3, x);
+void test__sf__RenderTarget__getDefaultView__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderTarget::getDefaultView(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderTexture__draw__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderTexture::draw(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sf__RenderTarget__getDefaultView__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderTarget::getDefaultView();
 }
 
-void test__sf__RenderTexture__draw__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderTexture::draw(x, arg2, arg3, arg4);
-}
-
-void test__sf__RenderTexture__draw__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderTexture::draw(arg1, x, arg3, arg4);
-}
-
-void test__sf__RenderTexture__draw__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderTexture::draw(arg1, arg2, x, arg4);
+void test__sf__RenderWindow__getView__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderWindow::getView(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sf__RenderTexture__draw__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderTexture::draw(arg1, arg2, arg3, x);
+void test__sf__RenderWindow__getView__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderWindow::getView();
 }
 
-void test__sf__RenderTarget__getSize__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderTarget::getSize();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTarget__getSize__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderTarget::getSize();
-}
-
-void test__sf__RenderWindow__getSize__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderWindow::getSize();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__getSize__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderWindow::getSize();
-}
-
-void test__sf__RenderTexture__getSize__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderTexture::getSize();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTexture__getSize__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderTexture::getSize();
-}
-
-void test__sf__RenderTarget__setActive__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderTarget::setActive(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTarget__setActive__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderTarget::setActive(x);
-}
-
-void test__sf__RenderWindow__setActive__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::setActive(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__setActive__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::setActive(x);
-}
-
-void test__sf__RenderTexture__setActive__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderTexture::setActive(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTexture__setActive__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderTexture::setActive(x);
-}
-
-void test__sf__Window__setActive__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::setActive(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__setActive__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::setActive(x);
-}
-
-void test__sf__RenderTarget__pushGLStates__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderTarget::pushGLStates();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTarget__popGLStates__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderTarget::popGLStates();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTarget__resetGLStates__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderTarget::resetGLStates();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__pushGLStates__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::pushGLStates();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__popGLStates__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::popGLStates();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__resetGLStates__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::resetGLStates();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTexture__pushGLStates__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderTexture::pushGLStates();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTexture__popGLStates__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderTexture::popGLStates();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderTexture__resetGLStates__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderTexture::resetGLStates();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__create__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::create(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__create__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::create(x, arg2, arg3, arg4);
-}
-
-void test__sf__Window__create__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::create(arg1, x, arg3, arg4);
-}
-
-void test__sf__Window__create__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::create(arg1, arg2, x, arg4);
-}
-
-void test__sf__Window__create__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::create(arg1, arg2, arg3, x);
-}
-
-void test__sf__RenderWindow__create__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::create(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__create__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::create(x, arg2, arg3, arg4);
-}
-
-void test__sf__RenderWindow__create__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::create(arg1, x, arg3, arg4);
-}
-
-void test__sf__RenderWindow__create__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::create(arg1, arg2, x, arg4);
-}
-
-void test__sf__RenderWindow__create__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::create(arg1, arg2, arg3, x);
-}
-
-void test__sf__Window__close__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::close();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__close__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::close();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__isOpen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::Window::isOpen();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__isOpen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::Window::isOpen();
-}
-
-void test__sf__RenderWindow__isOpen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderWindow::isOpen();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__isOpen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderWindow::isOpen();
-}
-
-void test__sf__Window__getSettings__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::Window::getSettings();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__getSettings__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::Window::getSettings();
-}
-
-void test__sf__RenderWindow__getSettings__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderWindow::getSettings();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__getSettings__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderWindow::getSettings();
-}
-
-void test__sf__Window__pollEvent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::pollEvent(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__waitEvent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::waitEvent(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__pollEvent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::pollEvent(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__waitEvent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::waitEvent(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__getPosition__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::Window::getPosition();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__getPosition__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::Window::getPosition();
-}
-
-void test__sf__RenderWindow__getPosition__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderWindow::getPosition();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__getPosition__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderWindow::getPosition();
-}
-
-void test__sf__Window__setPosition__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::setPosition(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__setPosition__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::setPosition(x);
-}
-
-void test__sf__RenderWindow__setPosition__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::setPosition(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__setPosition__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::setPosition(x);
-}
-
-void test__sf__Window__getSize__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::Window::getSize();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__getSize__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::Window::getSize();
-}
-
-void test__sf__RenderWindow__getSize__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderWindow::getSize();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__getSize__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderWindow::getSize();
-}
-
-void test__sf__Window__setSize__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::setSize(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__setSize__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::setSize(x);
-}
-
-void test__sf__RenderWindow__setSize__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::setSize(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__setSize__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::setSize(x);
-}
-
-void test__sf__Window__setTitle__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::setTitle(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__setTitle__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::setTitle(x);
-}
-
-void test__sf__RenderWindow__setTitle__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::setTitle(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__setTitle__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::setTitle(x);
-}
-
-void test__sf__Window__setIcon__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::setIcon(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__setIcon__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::setIcon(x, arg2, arg3);
-}
-
-void test__sf__Window__setIcon__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::setIcon(arg1, x, arg3);
-}
-
-void test__sf__Window__setIcon__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    sf::Window::setIcon(arg1, arg2, NULL);
-}
-
-void test__sf__Window__setIcon__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    sf::Window::setIcon(arg1, arg2, x);
-}
-
-void test__sf__RenderWindow__setIcon__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::setIcon(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__setIcon__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::setIcon(x, arg2, arg3);
-}
-
-void test__sf__RenderWindow__setIcon__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::setIcon(arg1, x, arg3);
-}
-
-void test__sf__RenderWindow__setIcon__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    sf::RenderWindow::setIcon(arg1, arg2, NULL);
-}
-
-void test__sf__RenderWindow__setIcon__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::setIcon(arg1, arg2, x);
-}
-
-void test__sf__Window__setVisible__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::setVisible(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__setVisible__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::setVisible(x);
-}
-
-void test__sf__Window__setVerticalSyncEnabled__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::setVerticalSyncEnabled(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__setVerticalSyncEnabled__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::setVerticalSyncEnabled(x);
-}
-
-void test__sf__Window__setMouseCursorVisible__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::setMouseCursorVisible(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__setMouseCursorVisible__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::setMouseCursorVisible(x);
-}
-
-void test__sf__Window__setMouseCursorGrabbed__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::setMouseCursorGrabbed(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__setMouseCursorGrabbed__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::setMouseCursorGrabbed(x);
-}
-
-void test__sf__Window__setKeyRepeatEnabled__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::setKeyRepeatEnabled(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__setKeyRepeatEnabled__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::setKeyRepeatEnabled(x);
-}
-
-void test__sf__RenderWindow__setVisible__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::setVisible(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__setVisible__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::setVisible(x);
-}
-
-void test__sf__RenderWindow__setVerticalSyncEnabled__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::setVerticalSyncEnabled(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__setVerticalSyncEnabled__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::setVerticalSyncEnabled(x);
-}
-
-void test__sf__RenderWindow__setMouseCursorVisible__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::setMouseCursorVisible(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__setMouseCursorVisible__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::setMouseCursorVisible(x);
-}
-
-void test__sf__RenderWindow__setMouseCursorGrabbed__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::setMouseCursorGrabbed(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__setMouseCursorGrabbed__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::setMouseCursorGrabbed(x);
-}
-
-void test__sf__RenderWindow__setKeyRepeatEnabled__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::setKeyRepeatEnabled(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__setKeyRepeatEnabled__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::setKeyRepeatEnabled(x);
-}
-
-void test__sf__Window__setFramerateLimit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::setFramerateLimit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__setFramerateLimit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::setFramerateLimit(x);
-}
-
-void test__sf__RenderWindow__setFramerateLimit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::setFramerateLimit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__setFramerateLimit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::setFramerateLimit(x);
-}
-
-void test__sf__Window__setJoystickThreshold__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::setJoystickThreshold(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__setJoystickThreshold__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::Window::setJoystickThreshold(x);
-}
-
-void test__sf__RenderWindow__setJoystickThreshold__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::setJoystickThreshold(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__setJoystickThreshold__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sf::RenderWindow::setJoystickThreshold(x);
-}
-
-void test__sf__Window__requestFocus__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::requestFocus();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__requestFocus__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::requestFocus();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__hasFocus__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::Window::hasFocus();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__hasFocus__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::Window::hasFocus();
-}
-
-void test__sf__RenderWindow__hasFocus__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderWindow::hasFocus();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__hasFocus__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderWindow::hasFocus();
-}
-
-void test__sf__Window__display__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::Window::display();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__display__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sf::RenderWindow::display();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__getSystemHandle__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::Window::getSystemHandle();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__Window__getSystemHandle__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::Window::getSystemHandle();
-}
-
-void test__sf__RenderWindow__getSystemHandle__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sf::RenderWindow::getSystemHandle();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__sf__RenderWindow__getSystemHandle__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sf::RenderWindow::getSystemHandle();
+void test__sf__RenderWindow__getDefaultView__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderWindow::getDefaultView(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__getDefaultView__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderWindow::getDefaultView();
+}
+
+void test__sf__RenderTexture__getView__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderTexture::getView(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__getView__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderTexture::getView();
+}
+
+void test__sf__RenderTexture__getDefaultView__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderTexture::getDefaultView(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__getDefaultView__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderTexture::getDefaultView();
+}
+
+void test__sf__RenderTarget__getViewport__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderTarget::getViewport(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTarget__getViewport__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderTarget::getViewport(arg1);
+}
+
+void test__sf__RenderTarget__getViewport__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::RenderTarget::getViewport(x);
+}
+
+void test__sf__RenderWindow__getViewport__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderWindow::getViewport(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__getViewport__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderWindow::getViewport(arg1);
+}
+
+void test__sf__RenderWindow__getViewport__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::RenderWindow::getViewport(x);
+}
+
+void test__sf__RenderTexture__getViewport__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderTexture::getViewport(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__getViewport__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderTexture::getViewport(arg1);
+}
+
+void test__sf__RenderTexture__getViewport__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::RenderTexture::getViewport(x);
+}
+
+void test__sf__RenderTarget__mapPixelToCoords__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderTarget::mapPixelToCoords(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTarget__mapPixelToCoords__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderTarget::mapPixelToCoords(arg1, arg2);
+}
+
+void test__sf__RenderTarget__mapPixelToCoords__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::RenderTarget::mapPixelToCoords(x, arg2);
+}
+
+void test__sf__RenderTarget__mapPixelToCoords__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::RenderTarget::mapPixelToCoords(arg1, x);
+}
+
+void test__sf__RenderTarget__mapCoordsToPixel__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderTarget::mapCoordsToPixel(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTarget__mapCoordsToPixel__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderTarget::mapCoordsToPixel(arg1, arg2);
+}
+
+void test__sf__RenderTarget__mapCoordsToPixel__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::RenderTarget::mapCoordsToPixel(x, arg2);
+}
+
+void test__sf__RenderTarget__mapCoordsToPixel__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::RenderTarget::mapCoordsToPixel(arg1, x);
+}
+
+void test__sf__RenderWindow__mapPixelToCoords__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderWindow::mapPixelToCoords(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__mapPixelToCoords__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderWindow::mapPixelToCoords(arg1, arg2);
+}
+
+void test__sf__RenderWindow__mapPixelToCoords__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::RenderWindow::mapPixelToCoords(x, arg2);
+}
+
+void test__sf__RenderWindow__mapPixelToCoords__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::RenderWindow::mapPixelToCoords(arg1, x);
+}
+
+void test__sf__RenderWindow__mapCoordsToPixel__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderWindow::mapCoordsToPixel(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__mapCoordsToPixel__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderWindow::mapCoordsToPixel(arg1, arg2);
+}
+
+void test__sf__RenderWindow__mapCoordsToPixel__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::RenderWindow::mapCoordsToPixel(x, arg2);
+}
+
+void test__sf__RenderWindow__mapCoordsToPixel__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::RenderWindow::mapCoordsToPixel(arg1, x);
+}
+
+void test__sf__RenderTexture__mapPixelToCoords__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderTexture::mapPixelToCoords(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__mapPixelToCoords__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderTexture::mapPixelToCoords(arg1, arg2);
+}
+
+void test__sf__RenderTexture__mapPixelToCoords__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::RenderTexture::mapPixelToCoords(x, arg2);
+}
+
+void test__sf__RenderTexture__mapPixelToCoords__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::RenderTexture::mapPixelToCoords(arg1, x);
+}
+
+void test__sf__RenderTexture__mapCoordsToPixel__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderTexture::mapCoordsToPixel(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__mapCoordsToPixel__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderTexture::mapCoordsToPixel(arg1, arg2);
+}
+
+void test__sf__RenderTexture__mapCoordsToPixel__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::RenderTexture::mapCoordsToPixel(x, arg2);
+}
+
+void test__sf__RenderTexture__mapCoordsToPixel__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sf::RenderTexture::mapCoordsToPixel(arg1, x);
+}
+
+void test__sf__RenderTarget__draw__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderTarget::draw(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTarget__draw__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTarget::draw(x, arg2, arg3, arg4);
+}
+
+void test__sf__RenderTarget__draw__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTarget::draw(arg1, x, arg3, arg4);
+}
+
+void test__sf__RenderTarget__draw__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTarget::draw(arg1, arg2, x, arg4);
+}
+
+void test__sf__RenderTarget__draw__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTarget::draw(arg1, arg2, arg3, x);
+}
+
+void test__sf__RenderWindow__draw__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::draw(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__draw__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::draw(x, arg2, arg3, arg4);
+}
+
+void test__sf__RenderWindow__draw__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::draw(arg1, x, arg3, arg4);
+}
+
+void test__sf__RenderWindow__draw__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::draw(arg1, arg2, x, arg4);
+}
+
+void test__sf__RenderWindow__draw__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::draw(arg1, arg2, arg3, x);
+}
+
+void test__sf__RenderTexture__draw__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderTexture::draw(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__draw__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTexture::draw(x, arg2, arg3, arg4);
+}
+
+void test__sf__RenderTexture__draw__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTexture::draw(arg1, x, arg3, arg4);
+}
+
+void test__sf__RenderTexture__draw__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTexture::draw(arg1, arg2, x, arg4);
+}
+
+void test__sf__RenderTexture__draw__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTexture::draw(arg1, arg2, arg3, x);
+}
+
+void test__sf__RenderTarget__getSize__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderTarget::getSize(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTarget__getSize__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderTarget::getSize();
+}
+
+void test__sf__RenderWindow__getSize__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderWindow::getSize(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__getSize__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderWindow::getSize();
+}
+
+void test__sf__RenderTexture__getSize__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderTexture::getSize(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__getSize__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderTexture::getSize();
+}
+
+void test__sf__RenderTarget__setActive__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderTarget::setActive(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTarget__setActive__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTarget::setActive(x);
+}
+
+void test__sf__RenderWindow__setActive__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::setActive(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setActive__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setActive(x);
+}
+
+void test__sf__RenderTexture__setActive__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderTexture::setActive(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__setActive__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTexture::setActive(x);
+}
+
+void test__sf__Window__setActive__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::setActive(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setActive__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setActive(x);
+}
+
+void test__sf__RenderTarget__pushGLStates__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderTarget::pushGLStates(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTarget__popGLStates__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderTarget::popGLStates(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTarget__resetGLStates__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderTarget::resetGLStates(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__pushGLStates__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::pushGLStates(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__popGLStates__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::popGLStates(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__resetGLStates__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::resetGLStates(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__pushGLStates__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderTexture::pushGLStates(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__popGLStates__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderTexture::popGLStates(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__resetGLStates__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderTexture::resetGLStates(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__create__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::create(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__create__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::create(x, arg2, arg3, arg4);
+}
+
+void test__sf__Window__create__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::create(arg1, x, arg3, arg4);
+}
+
+void test__sf__Window__create__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::create(arg1, arg2, x, arg4);
+}
+
+void test__sf__Window__create__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::create(arg1, arg2, arg3, x);
+}
+
+void test__sf__RenderWindow__create__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::create(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__create__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::create(x, arg2, arg3, arg4);
+}
+
+void test__sf__RenderWindow__create__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::create(arg1, x, arg3, arg4);
+}
+
+void test__sf__RenderWindow__create__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::create(arg1, arg2, x, arg4);
+}
+
+void test__sf__RenderWindow__create__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::create(arg1, arg2, arg3, x);
+}
+
+void test__sf__Window__close__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::close(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__close__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::close(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__isOpen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::Window::isOpen(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__isOpen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::Window::isOpen();
+}
+
+void test__sf__RenderWindow__isOpen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderWindow::isOpen(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__isOpen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderWindow::isOpen();
+}
+
+void test__sf__Window__getSettings__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::Window::getSettings(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__getSettings__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::Window::getSettings();
+}
+
+void test__sf__RenderWindow__getSettings__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderWindow::getSettings(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__getSettings__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderWindow::getSettings();
+}
+
+void test__sf__Window__pollEvent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::pollEvent(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__waitEvent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::waitEvent(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__pollEvent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::pollEvent(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__waitEvent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::waitEvent(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__getPosition__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::Window::getPosition(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__getPosition__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::Window::getPosition();
+}
+
+void test__sf__RenderWindow__getPosition__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderWindow::getPosition(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__getPosition__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderWindow::getPosition();
+}
+
+void test__sf__Window__setPosition__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::setPosition(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setPosition__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setPosition(x);
+}
+
+void test__sf__RenderWindow__setPosition__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::setPosition(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setPosition__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setPosition(x);
+}
+
+void test__sf__Window__getSize__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::Window::getSize(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__getSize__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::Window::getSize();
+}
+
+void test__sf__RenderWindow__getSize__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderWindow::getSize(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__getSize__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderWindow::getSize();
+}
+
+void test__sf__Window__setSize__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::setSize(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setSize__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setSize(x);
+}
+
+void test__sf__RenderWindow__setSize__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::setSize(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setSize__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setSize(x);
+}
+
+void test__sf__Window__setTitle__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::setTitle(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setTitle__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setTitle(x);
+}
+
+void test__sf__RenderWindow__setTitle__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::setTitle(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setTitle__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setTitle(x);
+}
+
+void test__sf__Window__setIcon__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::setIcon(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setIcon__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setIcon(x, arg2, arg3);
+}
+
+void test__sf__Window__setIcon__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setIcon(arg1, x, arg3);
+}
+
+void test__sf__Window__setIcon__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  sf::Window::setIcon(arg1, arg2, NULL);
+}
+
+void test__sf__Window__setIcon__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  sf::Window::setIcon(arg1, arg2, x);
+}
+
+void test__sf__RenderWindow__setIcon__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::setIcon(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setIcon__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setIcon(x, arg2, arg3);
+}
+
+void test__sf__RenderWindow__setIcon__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setIcon(arg1, x, arg3);
+}
+
+void test__sf__RenderWindow__setIcon__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  sf::RenderWindow::setIcon(arg1, arg2, NULL);
+}
+
+void test__sf__RenderWindow__setIcon__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setIcon(arg1, arg2, x);
+}
+
+void test__sf__Window__setVisible__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::setVisible(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setVisible__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setVisible(x);
+}
+
+void test__sf__Window__setVerticalSyncEnabled__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::setVerticalSyncEnabled(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setVerticalSyncEnabled__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setVerticalSyncEnabled(x);
+}
+
+void test__sf__Window__setMouseCursorVisible__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::setMouseCursorVisible(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setMouseCursorVisible__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setMouseCursorVisible(x);
+}
+
+void test__sf__Window__setMouseCursorGrabbed__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::setMouseCursorGrabbed(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setMouseCursorGrabbed__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setMouseCursorGrabbed(x);
+}
+
+void test__sf__Window__setKeyRepeatEnabled__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::setKeyRepeatEnabled(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setKeyRepeatEnabled__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setKeyRepeatEnabled(x);
+}
+
+void test__sf__RenderWindow__setVisible__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::setVisible(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setVisible__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setVisible(x);
+}
+
+void test__sf__RenderWindow__setVerticalSyncEnabled__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::setVerticalSyncEnabled(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setVerticalSyncEnabled__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setVerticalSyncEnabled(x);
+}
+
+void test__sf__RenderWindow__setMouseCursorVisible__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::setMouseCursorVisible(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setMouseCursorVisible__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setMouseCursorVisible(x);
+}
+
+void test__sf__RenderWindow__setMouseCursorGrabbed__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::setMouseCursorGrabbed(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setMouseCursorGrabbed__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setMouseCursorGrabbed(x);
+}
+
+void test__sf__RenderWindow__setKeyRepeatEnabled__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::setKeyRepeatEnabled(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setKeyRepeatEnabled__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setKeyRepeatEnabled(x);
+}
+
+void test__sf__Window__setFramerateLimit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::setFramerateLimit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setFramerateLimit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setFramerateLimit(x);
+}
+
+void test__sf__RenderWindow__setFramerateLimit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::setFramerateLimit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setFramerateLimit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setFramerateLimit(x);
+}
+
+void test__sf__Window__setJoystickThreshold__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::setJoystickThreshold(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setJoystickThreshold__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setJoystickThreshold(x);
+}
+
+void test__sf__RenderWindow__setJoystickThreshold__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::setJoystickThreshold(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setJoystickThreshold__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setJoystickThreshold(x);
+}
+
+void test__sf__Window__requestFocus__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::requestFocus(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__requestFocus__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::requestFocus(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__hasFocus__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::Window::hasFocus(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__hasFocus__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::Window::hasFocus();
+}
+
+void test__sf__RenderWindow__hasFocus__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderWindow::hasFocus(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__hasFocus__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderWindow::hasFocus();
+}
+
+void test__sf__Window__display__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::Window::display(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__display__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sf::RenderWindow::display(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__getSystemHandle__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::Window::getSystemHandle(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__getSystemHandle__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::Window::getSystemHandle();
+}
+
+void test__sf__RenderWindow__getSystemHandle__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sf::RenderWindow::getSystemHandle(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__getSystemHandle__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderWindow::getSystemHandle();
 }
 
diff --git a/test/cfg/generated-cfg-tests-std.cpp b/test/cfg/generated-cfg-tests-std.cpp
index c4f1e81ba..7dbf3b677 100644
--- a/test/cfg/generated-cfg-tests-std.cpp
+++ b/test/cfg/generated-cfg-tests-std.cpp
@@ -8,37878 +8,28959 @@
 // => 'unmatched suppression' warnings are false negatives.
 //
 
-void test__abort__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        abort();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__abort__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::abort();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__abort__noreturn() {
+  int x = 1;
+  if (cond) { x=100; abort(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__abs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = abs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__abort__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::abort(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__abs__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    abs(arg1);
+void test__abs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = abs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__abs__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((abs(arg1) > 10) || (abs(arg1) < 100)) {}
+void test__abs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  abs(arg1);
 }
 
-void test__abs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = abs(p);
-    // cppcheck-suppress memleak
+void test__abs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((abs(arg1) > 10) || (abs(arg1) < 100)) {}
 }
 
-void test__abs__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = abs(!x);
+void test__abs__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = abs(p);
+  // cppcheck-suppress memleak
 }
 
-void test__abs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = abs(x);
+void test__abs__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = abs(!x);
 }
 
-void test__std__abs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::abs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__abs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = abs(x);
 }
 
-void test__std__abs__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::abs(arg1);
+void test__std__abs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::abs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__abs__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::abs(arg1) > 10) || (std::abs(arg1) < 100)) {}
+void test__std__abs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::abs(arg1);
 }
 
-void test__std__abs__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = std::abs(!x);
+void test__std__abs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::abs(arg1) > 10) || (std::abs(arg1) < 100)) {}
 }
 
-void test__std__abs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::abs(x);
+void test__std__abs__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::abs(!x);
 }
 
-void test__imaxabs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = imaxabs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__abs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::abs(x);
 }
 
-void test__imaxabs__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    imaxabs(arg1);
+void test__imaxabs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = imaxabs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__imaxabs__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((imaxabs(arg1) > 10) || (imaxabs(arg1) < 100)) {}
+void test__imaxabs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  imaxabs(arg1);
 }
 
-void test__imaxabs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = imaxabs(p);
-    // cppcheck-suppress memleak
+void test__imaxabs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((imaxabs(arg1) > 10) || (imaxabs(arg1) < 100)) {}
 }
 
-void test__imaxabs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = imaxabs(x);
+void test__imaxabs__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = imaxabs(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__imaxabs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::imaxabs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__imaxabs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = imaxabs(x);
 }
 
-void test__std__imaxabs__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::imaxabs(arg1);
+void test__std__imaxabs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::imaxabs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__imaxabs__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::imaxabs(arg1) > 10) || (std::imaxabs(arg1) < 100)) {}
+void test__std__imaxabs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::imaxabs(arg1);
 }
 
-void test__std__imaxabs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::imaxabs(x);
+void test__std__imaxabs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::imaxabs(arg1) > 10) || (std::imaxabs(arg1) < 100)) {}
 }
 
-void test__std__proj__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::proj(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__imaxabs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::imaxabs(x);
 }
 
-void test__std__proj__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::proj(arg1);
+void test__std__proj__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::proj(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__proj__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::proj(arg1) > 10) || (std::proj(arg1) < 100)) {}
+void test__std__proj__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::proj(arg1);
 }
 
-void test__std__proj__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::proj(x);
+void test__std__proj__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::proj(arg1) > 10) || (std::proj(arg1) < 100)) {}
 }
 
-void test__cproj__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cproj(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__proj__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::proj(x);
 }
 
-void test__cproj__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cproj(arg1);
+void test__cproj__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cproj(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cproj__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cproj(arg1) > 10) || (cproj(arg1) < 100)) {}
+void test__cproj__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cproj(arg1);
 }
 
-void test__cproj__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cproj(p);
-    // cppcheck-suppress memleak
+void test__cproj__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cproj(arg1) > 10) || (cproj(arg1) < 100)) {}
 }
 
-void test__cproj__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cproj(x);
+void test__cproj__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cproj(p);
+  // cppcheck-suppress memleak
 }
 
-void test__cprojf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cprojf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cproj__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cproj(x);
 }
 
-void test__cprojf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cprojf(arg1);
+void test__cprojf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cprojf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cprojf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cprojf(arg1) > 10) || (cprojf(arg1) < 100)) {}
+void test__cprojf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cprojf(arg1);
 }
 
-void test__cprojf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cprojf(p);
-    // cppcheck-suppress memleak
+void test__cprojf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cprojf(arg1) > 10) || (cprojf(arg1) < 100)) {}
 }
 
-void test__cprojf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cprojf(x);
+void test__cprojf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cprojf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__cprojl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cprojl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cprojf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cprojf(x);
 }
 
-void test__cprojl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cprojl(arg1);
+void test__cprojl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cprojl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cprojl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cprojl(arg1) > 10) || (cprojl(arg1) < 100)) {}
+void test__cprojl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cprojl(arg1);
 }
 
-void test__cprojl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cprojl(p);
-    // cppcheck-suppress memleak
+void test__cprojl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cprojl(arg1) > 10) || (cprojl(arg1) < 100)) {}
 }
 
-void test__cprojl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cprojl(x);
+void test__cprojl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cprojl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__creal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = creal(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cprojl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cprojl(x);
 }
 
-void test__creal__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    creal(arg1);
+void test__creal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = creal(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__creal__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((creal(arg1) > 10) || (creal(arg1) < 100)) {}
+void test__creal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  creal(arg1);
 }
 
-void test__creal__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = creal(p);
-    // cppcheck-suppress memleak
+void test__creal__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((creal(arg1) > 10) || (creal(arg1) < 100)) {}
 }
 
-void test__creal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = creal(x);
+void test__creal__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = creal(p);
+  // cppcheck-suppress memleak
 }
 
-void test__crealf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = crealf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__creal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = creal(x);
 }
 
-void test__crealf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    crealf(arg1);
+void test__crealf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = crealf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__crealf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((crealf(arg1) > 10) || (crealf(arg1) < 100)) {}
+void test__crealf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  crealf(arg1);
 }
 
-void test__crealf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = crealf(p);
-    // cppcheck-suppress memleak
+void test__crealf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((crealf(arg1) > 10) || (crealf(arg1) < 100)) {}
 }
 
-void test__crealf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = crealf(x);
+void test__crealf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = crealf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__creall__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = creall(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__crealf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = crealf(x);
 }
 
-void test__creall__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    creall(arg1);
+void test__creall__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = creall(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__creall__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((creall(arg1) > 10) || (creall(arg1) < 100)) {}
+void test__creall__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  creall(arg1);
 }
 
-void test__creall__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = creall(p);
-    // cppcheck-suppress memleak
+void test__creall__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((creall(arg1) > 10) || (creall(arg1) < 100)) {}
 }
 
-void test__creall__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = creall(x);
+void test__creall__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = creall(p);
+  // cppcheck-suppress memleak
 }
 
-void test__acos__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = acos(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__creall__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = creall(x);
 }
 
-void test__acos__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    acos(arg1);
+void test__acos__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = acos(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__acos__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((acos(arg1) > 10) || (acos(arg1) < 100)) {}
+void test__acos__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  acos(arg1);
 }
 
-void test__acos__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = acos(p);
-    // cppcheck-suppress memleak
+void test__acos__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((acos(arg1) > 10) || (acos(arg1) < 100)) {}
 }
 
-void test__acos__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = acos(x);
+void test__acos__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = acos(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__acos__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::acos(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__acos__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = acos(x);
 }
 
-void test__std__acos__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::acos(arg1);
+void test__std__acos__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::acos(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__acos__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::acos(arg1) > 10) || (std::acos(arg1) < 100)) {}
+void test__std__acos__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::acos(arg1);
 }
 
-void test__std__acos__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::acos(x);
+void test__std__acos__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::acos(arg1) > 10) || (std::acos(arg1) < 100)) {}
 }
 
-void test__acosf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = acosf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__acos__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::acos(x);
 }
 
-void test__acosf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    acosf(arg1);
+void test__acosf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = acosf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__acosf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((acosf(arg1) > 10) || (acosf(arg1) < 100)) {}
+void test__acosf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  acosf(arg1);
 }
 
-void test__acosf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = acosf(p);
-    // cppcheck-suppress memleak
+void test__acosf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((acosf(arg1) > 10) || (acosf(arg1) < 100)) {}
 }
 
-void test__acosf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = acosf(x);
+void test__acosf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = acosf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__acosf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::acosf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__acosf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = acosf(x);
 }
 
-void test__std__acosf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::acosf(arg1);
+void test__std__acosf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::acosf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__acosf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::acosf(arg1) > 10) || (std::acosf(arg1) < 100)) {}
+void test__std__acosf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::acosf(arg1);
 }
 
-void test__std__acosf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::acosf(x);
+void test__std__acosf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::acosf(arg1) > 10) || (std::acosf(arg1) < 100)) {}
 }
 
-void test__acosl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = acosl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__acosf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::acosf(x);
 }
 
-void test__acosl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    acosl(arg1);
+void test__acosl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = acosl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__acosl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((acosl(arg1) > 10) || (acosl(arg1) < 100)) {}
+void test__acosl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  acosl(arg1);
 }
 
-void test__acosl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = acosl(p);
-    // cppcheck-suppress memleak
+void test__acosl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((acosl(arg1) > 10) || (acosl(arg1) < 100)) {}
 }
 
-void test__acosl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = acosl(x);
+void test__acosl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = acosl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__acosl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::acosl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__acosl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = acosl(x);
 }
 
-void test__std__acosl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::acosl(arg1);
+void test__std__acosl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::acosl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__acosl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::acosl(arg1) > 10) || (std::acosl(arg1) < 100)) {}
+void test__std__acosl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::acosl(arg1);
 }
 
-void test__std__acosl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::acosl(x);
+void test__std__acosl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::acosl(arg1) > 10) || (std::acosl(arg1) < 100)) {}
 }
 
-void test__acosh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = acosh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__acosl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::acosl(x);
 }
 
-void test__acosh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    acosh(arg1);
+void test__acosh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = acosh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__acosh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((acosh(arg1) > 10) || (acosh(arg1) < 100)) {}
+void test__acosh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  acosh(arg1);
 }
 
-void test__acosh__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = acosh(p);
-    // cppcheck-suppress memleak
+void test__acosh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((acosh(arg1) > 10) || (acosh(arg1) < 100)) {}
 }
 
-void test__acosh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = acosh(x);
+void test__acosh__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = acosh(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__acosh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::acosh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__acosh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = acosh(x);
 }
 
-void test__std__acosh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::acosh(arg1);
+void test__std__acosh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::acosh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__acosh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::acosh(arg1) > 10) || (std::acosh(arg1) < 100)) {}
+void test__std__acosh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::acosh(arg1);
 }
 
-void test__std__acosh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::acosh(x);
+void test__std__acosh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::acosh(arg1) > 10) || (std::acosh(arg1) < 100)) {}
 }
 
-void test__acoshf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = acoshf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__acosh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::acosh(x);
 }
 
-void test__acoshf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    acoshf(arg1);
+void test__acoshf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = acoshf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__acoshf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((acoshf(arg1) > 10) || (acoshf(arg1) < 100)) {}
+void test__acoshf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  acoshf(arg1);
 }
 
-void test__acoshf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = acoshf(p);
-    // cppcheck-suppress memleak
+void test__acoshf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((acoshf(arg1) > 10) || (acoshf(arg1) < 100)) {}
 }
 
-void test__acoshf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = acoshf(x);
+void test__acoshf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = acoshf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__acoshf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::acoshf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__acoshf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = acoshf(x);
 }
 
-void test__std__acoshf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::acoshf(arg1);
+void test__std__acoshf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::acoshf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__acoshf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::acoshf(arg1) > 10) || (std::acoshf(arg1) < 100)) {}
+void test__std__acoshf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::acoshf(arg1);
 }
 
-void test__std__acoshf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::acoshf(x);
+void test__std__acoshf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::acoshf(arg1) > 10) || (std::acoshf(arg1) < 100)) {}
 }
 
-void test__acoshl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = acoshl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__acoshf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::acoshf(x);
 }
 
-void test__acoshl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    acoshl(arg1);
+void test__acoshl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = acoshl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__acoshl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((acoshl(arg1) > 10) || (acoshl(arg1) < 100)) {}
+void test__acoshl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  acoshl(arg1);
 }
 
-void test__acoshl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = acoshl(p);
-    // cppcheck-suppress memleak
+void test__acoshl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((acoshl(arg1) > 10) || (acoshl(arg1) < 100)) {}
 }
 
-void test__acoshl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = acoshl(x);
+void test__acoshl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = acoshl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__acoshl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::acoshl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__acoshl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = acoshl(x);
 }
 
-void test__std__acoshl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::acoshl(arg1);
+void test__std__acoshl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::acoshl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__acoshl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::acoshl(arg1) > 10) || (std::acoshl(arg1) < 100)) {}
+void test__std__acoshl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::acoshl(arg1);
 }
 
-void test__std__acoshl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::acoshl(x);
+void test__std__acoshl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::acoshl(arg1) > 10) || (std::acoshl(arg1) < 100)) {}
 }
 
-void test__asctime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = asctime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__acoshl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::acoshl(x);
 }
 
-void test__asctime__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    asctime(arg1);
+void test__asctime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = asctime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__asctime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = asctime(p);
-    // cppcheck-suppress memleak
+void test__asctime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  asctime(arg1);
 }
 
-void test__asctime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = asctime(NULL);
+void test__asctime__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = asctime(p);
+  // cppcheck-suppress memleak
 }
 
-void test__asctime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = asctime(x);
+void test__asctime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = asctime(NULL);
 }
 
-void test__std__asctime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::asctime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__asctime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = asctime(x);
 }
 
-void test__std__asctime__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::asctime(arg1);
+void test__std__asctime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::asctime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__asctime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::asctime(NULL);
+void test__std__asctime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::asctime(arg1);
 }
 
-void test__std__asctime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::asctime(x);
+void test__std__asctime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::asctime(NULL);
 }
 
-void test__assert__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    assert(p);
-    // cppcheck-suppress memleak
+void test__std__asctime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::asctime(x);
 }
 
-void test__assert__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    assert(x);
+void test__assert__leakignore() {
+  char *p = malloc(10); *p=0;
+  assert(p);
+  // cppcheck-suppress memleak
 }
 
-void test__sqrt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sqrt(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__assert__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  assert(x);
 }
 
-void test__sqrt__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sqrt(arg1);
+void test__sqrt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sqrt(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sqrt__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((sqrt(arg1) > 10) || (sqrt(arg1) < 100)) {}
+void test__sqrt__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sqrt(arg1);
 }
 
-void test__sqrt__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = sqrt(p);
-    // cppcheck-suppress memleak
+void test__sqrt__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((sqrt(arg1) > 10) || (sqrt(arg1) < 100)) {}
 }
 
-void test__sqrt__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sqrt(x);
+void test__sqrt__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = sqrt(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__sqrt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::sqrt(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sqrt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sqrt(x);
 }
 
-void test__std__sqrt__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::sqrt(arg1);
+void test__std__sqrt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::sqrt(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__sqrt__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::sqrt(arg1) > 10) || (std::sqrt(arg1) < 100)) {}
+void test__std__sqrt__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::sqrt(arg1);
 }
 
-void test__std__sqrt__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::sqrt(x);
+void test__std__sqrt__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sqrt(arg1) > 10) || (std::sqrt(arg1) < 100)) {}
 }
 
-void test__sqrtf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sqrtf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__sqrt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sqrt(x);
 }
 
-void test__sqrtf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sqrtf(arg1);
+void test__sqrtf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sqrtf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sqrtf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((sqrtf(arg1) > 10) || (sqrtf(arg1) < 100)) {}
+void test__sqrtf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sqrtf(arg1);
 }
 
-void test__sqrtf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = sqrtf(p);
-    // cppcheck-suppress memleak
+void test__sqrtf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((sqrtf(arg1) > 10) || (sqrtf(arg1) < 100)) {}
 }
 
-void test__sqrtf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sqrtf(x);
+void test__sqrtf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = sqrtf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__sqrtf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::sqrtf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sqrtf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sqrtf(x);
 }
 
-void test__std__sqrtf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::sqrtf(arg1);
+void test__std__sqrtf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::sqrtf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__sqrtf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::sqrtf(arg1) > 10) || (std::sqrtf(arg1) < 100)) {}
+void test__std__sqrtf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::sqrtf(arg1);
 }
 
-void test__std__sqrtf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::sqrtf(x);
+void test__std__sqrtf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sqrtf(arg1) > 10) || (std::sqrtf(arg1) < 100)) {}
 }
 
-void test__sqrtl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sqrtl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__sqrtf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sqrtf(x);
 }
 
-void test__sqrtl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sqrtl(arg1);
+void test__sqrtl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sqrtl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sqrtl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((sqrtl(arg1) > 10) || (sqrtl(arg1) < 100)) {}
+void test__sqrtl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sqrtl(arg1);
 }
 
-void test__sqrtl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = sqrtl(p);
-    // cppcheck-suppress memleak
+void test__sqrtl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((sqrtl(arg1) > 10) || (sqrtl(arg1) < 100)) {}
 }
 
-void test__sqrtl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sqrtl(x);
+void test__sqrtl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = sqrtl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__sqrtl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::sqrtl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sqrtl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sqrtl(x);
 }
 
-void test__std__sqrtl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::sqrtl(arg1);
+void test__std__sqrtl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::sqrtl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__sqrtl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::sqrtl(arg1) > 10) || (std::sqrtl(arg1) < 100)) {}
+void test__std__sqrtl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::sqrtl(arg1);
 }
 
-void test__std__sqrtl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::sqrtl(x);
+void test__std__sqrtl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sqrtl(arg1) > 10) || (std::sqrtl(arg1) < 100)) {}
 }
 
-void test__csqrt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = csqrt(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__sqrtl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sqrtl(x);
 }
 
-void test__csqrt__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    csqrt(arg1);
+void test__csqrt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = csqrt(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__csqrt__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((csqrt(arg1) > 10) || (csqrt(arg1) < 100)) {}
+void test__csqrt__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  csqrt(arg1);
 }
 
-void test__csqrt__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = csqrt(p);
-    // cppcheck-suppress memleak
+void test__csqrt__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((csqrt(arg1) > 10) || (csqrt(arg1) < 100)) {}
 }
 
-void test__csqrt__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = csqrt(x);
+void test__csqrt__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = csqrt(p);
+  // cppcheck-suppress memleak
 }
 
-void test__csqrtf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = csqrtf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__csqrt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csqrt(x);
 }
 
-void test__csqrtf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    csqrtf(arg1);
+void test__csqrtf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = csqrtf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__csqrtf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((csqrtf(arg1) > 10) || (csqrtf(arg1) < 100)) {}
+void test__csqrtf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  csqrtf(arg1);
 }
 
-void test__csqrtf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = csqrtf(p);
-    // cppcheck-suppress memleak
+void test__csqrtf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((csqrtf(arg1) > 10) || (csqrtf(arg1) < 100)) {}
 }
 
-void test__csqrtf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = csqrtf(x);
+void test__csqrtf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = csqrtf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__csqrtl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = csqrtl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__csqrtf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csqrtf(x);
 }
 
-void test__csqrtl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    csqrtl(arg1);
+void test__csqrtl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = csqrtl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__csqrtl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((csqrtl(arg1) > 10) || (csqrtl(arg1) < 100)) {}
+void test__csqrtl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  csqrtl(arg1);
 }
 
-void test__csqrtl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = csqrtl(p);
-    // cppcheck-suppress memleak
+void test__csqrtl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((csqrtl(arg1) > 10) || (csqrtl(arg1) < 100)) {}
 }
 
-void test__csqrtl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = csqrtl(x);
+void test__csqrtl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = csqrtl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__sinh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sinh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__csqrtl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csqrtl(x);
 }
 
-void test__sinh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sinh(arg1);
+void test__sinh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sinh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sinh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((sinh(arg1) > 10) || (sinh(arg1) < 100)) {}
+void test__sinh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sinh(arg1);
 }
 
-void test__sinh__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = sinh(p);
-    // cppcheck-suppress memleak
+void test__sinh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((sinh(arg1) > 10) || (sinh(arg1) < 100)) {}
 }
 
-void test__sinh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sinh(x);
+void test__sinh__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = sinh(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__sinh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::sinh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sinh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sinh(x);
 }
 
-void test__std__sinh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::sinh(arg1);
+void test__std__sinh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::sinh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__sinh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::sinh(arg1) > 10) || (std::sinh(arg1) < 100)) {}
+void test__std__sinh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::sinh(arg1);
 }
 
-void test__std__sinh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::sinh(x);
+void test__std__sinh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sinh(arg1) > 10) || (std::sinh(arg1) < 100)) {}
 }
 
-void test__sinhf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sinhf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__sinh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sinh(x);
 }
 
-void test__sinhf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sinhf(arg1);
+void test__sinhf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sinhf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sinhf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((sinhf(arg1) > 10) || (sinhf(arg1) < 100)) {}
+void test__sinhf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sinhf(arg1);
 }
 
-void test__sinhf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = sinhf(p);
-    // cppcheck-suppress memleak
+void test__sinhf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((sinhf(arg1) > 10) || (sinhf(arg1) < 100)) {}
 }
 
-void test__sinhf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sinhf(x);
+void test__sinhf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = sinhf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__sinhf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::sinhf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sinhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sinhf(x);
 }
 
-void test__std__sinhf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::sinhf(arg1);
+void test__std__sinhf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::sinhf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__sinhf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::sinhf(arg1) > 10) || (std::sinhf(arg1) < 100)) {}
+void test__std__sinhf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::sinhf(arg1);
 }
 
-void test__std__sinhf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::sinhf(x);
+void test__std__sinhf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sinhf(arg1) > 10) || (std::sinhf(arg1) < 100)) {}
 }
 
-void test__sinhl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sinhl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__sinhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sinhf(x);
 }
 
-void test__sinhl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sinhl(arg1);
+void test__sinhl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sinhl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sinhl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((sinhl(arg1) > 10) || (sinhl(arg1) < 100)) {}
+void test__sinhl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sinhl(arg1);
 }
 
-void test__sinhl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = sinhl(p);
-    // cppcheck-suppress memleak
+void test__sinhl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((sinhl(arg1) > 10) || (sinhl(arg1) < 100)) {}
 }
 
-void test__sinhl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sinhl(x);
+void test__sinhl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = sinhl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__sinhl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::sinhl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sinhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sinhl(x);
 }
 
-void test__std__sinhl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::sinhl(arg1);
+void test__std__sinhl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::sinhl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__sinhl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::sinhl(arg1) > 10) || (std::sinhl(arg1) < 100)) {}
+void test__std__sinhl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::sinhl(arg1);
 }
 
-void test__std__sinhl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::sinhl(x);
+void test__std__sinhl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sinhl(arg1) > 10) || (std::sinhl(arg1) < 100)) {}
 }
 
-void test__sin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sin(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__sinhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sinhl(x);
 }
 
-void test__sin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sin(arg1);
+void test__sin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sin(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sin__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((sin(arg1) > 10) || (sin(arg1) < 100)) {}
+void test__sin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sin(arg1);
 }
 
-void test__sin__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = sin(p);
-    // cppcheck-suppress memleak
+void test__sin__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((sin(arg1) > 10) || (sin(arg1) < 100)) {}
 }
 
-void test__sin__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sin(x);
+void test__sin__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = sin(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__sin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::sin(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sin(x);
 }
 
-void test__std__sin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::sin(arg1);
+void test__std__sin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::sin(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__sin__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::sin(arg1) > 10) || (std::sin(arg1) < 100)) {}
+void test__std__sin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::sin(arg1);
 }
 
-void test__std__sin__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::sin(x);
+void test__std__sin__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sin(arg1) > 10) || (std::sin(arg1) < 100)) {}
 }
 
-void test__sinf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sinf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__sin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sin(x);
 }
 
-void test__sinf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sinf(arg1);
+void test__sinf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sinf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sinf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((sinf(arg1) > 10) || (sinf(arg1) < 100)) {}
+void test__sinf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sinf(arg1);
 }
 
-void test__sinf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = sinf(p);
-    // cppcheck-suppress memleak
+void test__sinf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((sinf(arg1) > 10) || (sinf(arg1) < 100)) {}
 }
 
-void test__sinf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sinf(x);
+void test__sinf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = sinf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__sinf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::sinf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sinf(x);
 }
 
-void test__std__sinf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::sinf(arg1);
+void test__std__sinf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::sinf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__sinf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::sinf(arg1) > 10) || (std::sinf(arg1) < 100)) {}
+void test__std__sinf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::sinf(arg1);
 }
 
-void test__std__sinf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::sinf(x);
+void test__std__sinf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sinf(arg1) > 10) || (std::sinf(arg1) < 100)) {}
 }
 
-void test__sinl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = sinl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__sinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sinf(x);
 }
 
-void test__sinl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    sinl(arg1);
+void test__sinl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = sinl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sinl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((sinl(arg1) > 10) || (sinl(arg1) < 100)) {}
+void test__sinl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sinl(arg1);
 }
 
-void test__sinl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = sinl(p);
-    // cppcheck-suppress memleak
+void test__sinl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((sinl(arg1) > 10) || (sinl(arg1) < 100)) {}
 }
 
-void test__sinl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = sinl(x);
+void test__sinl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = sinl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__sinl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::sinl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sinl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sinl(x);
 }
 
-void test__std__sinl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::sinl(arg1);
+void test__std__sinl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::sinl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__sinl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::sinl(arg1) > 10) || (std::sinl(arg1) < 100)) {}
+void test__std__sinl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::sinl(arg1);
 }
 
-void test__std__sinl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::sinl(x);
+void test__std__sinl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sinl(arg1) > 10) || (std::sinl(arg1) < 100)) {}
 }
 
-void test__csin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = csin(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__sinl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sinl(x);
 }
 
-void test__csin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    csin(arg1);
+void test__csin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = csin(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__csin__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((csin(arg1) > 10) || (csin(arg1) < 100)) {}
+void test__csin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  csin(arg1);
 }
 
-void test__csin__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = csin(p);
-    // cppcheck-suppress memleak
+void test__csin__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((csin(arg1) > 10) || (csin(arg1) < 100)) {}
 }
 
-void test__csin__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = csin(x);
+void test__csin__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = csin(p);
+  // cppcheck-suppress memleak
 }
 
-void test__csinf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = csinf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__csin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csin(x);
 }
 
-void test__csinf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    csinf(arg1);
+void test__csinf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = csinf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__csinf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((csinf(arg1) > 10) || (csinf(arg1) < 100)) {}
+void test__csinf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  csinf(arg1);
 }
 
-void test__csinf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = csinf(p);
-    // cppcheck-suppress memleak
+void test__csinf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((csinf(arg1) > 10) || (csinf(arg1) < 100)) {}
 }
 
-void test__csinf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = csinf(x);
+void test__csinf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = csinf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__csinl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = csinl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__csinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csinf(x);
 }
 
-void test__csinl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    csinl(arg1);
+void test__csinl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = csinl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__csinl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((csinl(arg1) > 10) || (csinl(arg1) < 100)) {}
+void test__csinl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  csinl(arg1);
 }
 
-void test__csinl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = csinl(p);
-    // cppcheck-suppress memleak
+void test__csinl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((csinl(arg1) > 10) || (csinl(arg1) < 100)) {}
 }
 
-void test__csinl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = csinl(x);
+void test__csinl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = csinl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__csinh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = csinh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__csinl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csinl(x);
 }
 
-void test__csinh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    csinh(arg1);
+void test__csinh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = csinh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__csinh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((csinh(arg1) > 10) || (csinh(arg1) < 100)) {}
+void test__csinh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  csinh(arg1);
 }
 
-void test__csinh__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = csinh(p);
-    // cppcheck-suppress memleak
+void test__csinh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((csinh(arg1) > 10) || (csinh(arg1) < 100)) {}
 }
 
-void test__csinh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = csinh(x);
+void test__csinh__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = csinh(p);
+  // cppcheck-suppress memleak
 }
 
-void test__csinhf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = csinhf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__csinh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csinh(x);
 }
 
-void test__csinhf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    csinhf(arg1);
+void test__csinhf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = csinhf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__csinhf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((csinhf(arg1) > 10) || (csinhf(arg1) < 100)) {}
+void test__csinhf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  csinhf(arg1);
 }
 
-void test__csinhf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = csinhf(p);
-    // cppcheck-suppress memleak
+void test__csinhf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((csinhf(arg1) > 10) || (csinhf(arg1) < 100)) {}
 }
 
-void test__csinhf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = csinhf(x);
+void test__csinhf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = csinhf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__csinhl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = csinhl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__csinhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csinhf(x);
 }
 
-void test__csinhl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    csinhl(arg1);
+void test__csinhl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = csinhl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__csinhl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((csinhl(arg1) > 10) || (csinhl(arg1) < 100)) {}
+void test__csinhl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  csinhl(arg1);
 }
 
-void test__csinhl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = csinhl(p);
-    // cppcheck-suppress memleak
+void test__csinhl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((csinhl(arg1) > 10) || (csinhl(arg1) < 100)) {}
 }
 
-void test__csinhl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = csinhl(x);
+void test__csinhl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = csinhl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__asin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = asin(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__csinhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csinhl(x);
 }
 
-void test__asin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    asin(arg1);
+void test__asin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = asin(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__asin__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((asin(arg1) > 10) || (asin(arg1) < 100)) {}
+void test__asin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  asin(arg1);
 }
 
-void test__asin__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = asin(p);
-    // cppcheck-suppress memleak
+void test__asin__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((asin(arg1) > 10) || (asin(arg1) < 100)) {}
 }
 
-void test__asin__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = asin(x);
+void test__asin__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = asin(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__asin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::asin(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__asin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = asin(x);
 }
 
-void test__std__asin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::asin(arg1);
+void test__std__asin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::asin(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__asin__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::asin(arg1) > 10) || (std::asin(arg1) < 100)) {}
+void test__std__asin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::asin(arg1);
 }
 
-void test__std__asin__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::asin(x);
+void test__std__asin__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::asin(arg1) > 10) || (std::asin(arg1) < 100)) {}
 }
 
-void test__asinf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = asinf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__asin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::asin(x);
 }
 
-void test__asinf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    asinf(arg1);
+void test__asinf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = asinf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__asinf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((asinf(arg1) > 10) || (asinf(arg1) < 100)) {}
+void test__asinf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  asinf(arg1);
 }
 
-void test__asinf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = asinf(p);
-    // cppcheck-suppress memleak
+void test__asinf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((asinf(arg1) > 10) || (asinf(arg1) < 100)) {}
 }
 
-void test__asinf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = asinf(x);
+void test__asinf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = asinf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__asinf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::asinf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__asinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = asinf(x);
 }
 
-void test__std__asinf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::asinf(arg1);
+void test__std__asinf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::asinf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__asinf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::asinf(arg1) > 10) || (std::asinf(arg1) < 100)) {}
+void test__std__asinf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::asinf(arg1);
 }
 
-void test__std__asinf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::asinf(x);
+void test__std__asinf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::asinf(arg1) > 10) || (std::asinf(arg1) < 100)) {}
 }
 
-void test__asinl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = asinl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__asinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::asinf(x);
 }
 
-void test__asinl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    asinl(arg1);
+void test__asinl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = asinl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__asinl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((asinl(arg1) > 10) || (asinl(arg1) < 100)) {}
+void test__asinl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  asinl(arg1);
 }
 
-void test__asinl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = asinl(p);
-    // cppcheck-suppress memleak
+void test__asinl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((asinl(arg1) > 10) || (asinl(arg1) < 100)) {}
 }
 
-void test__asinl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = asinl(x);
+void test__asinl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = asinl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__asinl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::asinl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__asinl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = asinl(x);
 }
 
-void test__std__asinl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::asinl(arg1);
+void test__std__asinl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::asinl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__asinl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::asinl(arg1) > 10) || (std::asinl(arg1) < 100)) {}
+void test__std__asinl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::asinl(arg1);
 }
 
-void test__std__asinl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::asinl(x);
+void test__std__asinl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::asinl(arg1) > 10) || (std::asinl(arg1) < 100)) {}
 }
 
-void test__casin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = casin(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__asinl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::asinl(x);
 }
 
-void test__casin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    casin(arg1);
+void test__casin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = casin(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__casin__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((casin(arg1) > 10) || (casin(arg1) < 100)) {}
+void test__casin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  casin(arg1);
 }
 
-void test__casin__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = casin(p);
-    // cppcheck-suppress memleak
+void test__casin__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((casin(arg1) > 10) || (casin(arg1) < 100)) {}
 }
 
-void test__casin__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = casin(x);
+void test__casin__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = casin(p);
+  // cppcheck-suppress memleak
 }
 
-void test__casinf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = casinf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__casin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = casin(x);
 }
 
-void test__casinf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    casinf(arg1);
+void test__casinf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = casinf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__casinf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((casinf(arg1) > 10) || (casinf(arg1) < 100)) {}
+void test__casinf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  casinf(arg1);
 }
 
-void test__casinf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = casinf(p);
-    // cppcheck-suppress memleak
+void test__casinf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((casinf(arg1) > 10) || (casinf(arg1) < 100)) {}
 }
 
-void test__casinf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = casinf(x);
+void test__casinf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = casinf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__casinl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = casinl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__casinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = casinf(x);
 }
 
-void test__casinl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    casinl(arg1);
+void test__casinl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = casinl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__casinl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((casinl(arg1) > 10) || (casinl(arg1) < 100)) {}
+void test__casinl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  casinl(arg1);
 }
 
-void test__casinl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = casinl(p);
-    // cppcheck-suppress memleak
+void test__casinl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((casinl(arg1) > 10) || (casinl(arg1) < 100)) {}
 }
 
-void test__casinl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = casinl(x);
+void test__casinl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = casinl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__asinh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = asinh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__casinl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = casinl(x);
 }
 
-void test__asinh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    asinh(arg1);
+void test__asinh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = asinh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__asinh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((asinh(arg1) > 10) || (asinh(arg1) < 100)) {}
+void test__asinh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  asinh(arg1);
 }
 
-void test__asinh__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = asinh(p);
-    // cppcheck-suppress memleak
+void test__asinh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((asinh(arg1) > 10) || (asinh(arg1) < 100)) {}
 }
 
-void test__asinh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = asinh(x);
+void test__asinh__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = asinh(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__asinh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::asinh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__asinh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = asinh(x);
 }
 
-void test__std__asinh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::asinh(arg1);
+void test__std__asinh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::asinh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__asinh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::asinh(arg1) > 10) || (std::asinh(arg1) < 100)) {}
+void test__std__asinh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::asinh(arg1);
 }
 
-void test__std__asinh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::asinh(x);
+void test__std__asinh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::asinh(arg1) > 10) || (std::asinh(arg1) < 100)) {}
 }
 
-void test__asinhf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = asinhf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__asinh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::asinh(x);
 }
 
-void test__asinhf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    asinhf(arg1);
+void test__asinhf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = asinhf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__asinhf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((asinhf(arg1) > 10) || (asinhf(arg1) < 100)) {}
+void test__asinhf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  asinhf(arg1);
 }
 
-void test__asinhf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = asinhf(p);
-    // cppcheck-suppress memleak
+void test__asinhf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((asinhf(arg1) > 10) || (asinhf(arg1) < 100)) {}
 }
 
-void test__asinhf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = asinhf(x);
+void test__asinhf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = asinhf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__asinhf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::asinhf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__asinhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = asinhf(x);
 }
 
-void test__std__asinhf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::asinhf(arg1);
+void test__std__asinhf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::asinhf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__asinhf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::asinhf(arg1) > 10) || (std::asinhf(arg1) < 100)) {}
+void test__std__asinhf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::asinhf(arg1);
 }
 
-void test__std__asinhf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::asinhf(x);
+void test__std__asinhf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::asinhf(arg1) > 10) || (std::asinhf(arg1) < 100)) {}
 }
 
-void test__asinhl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = asinhl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__asinhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::asinhf(x);
 }
 
-void test__asinhl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    asinhl(arg1);
+void test__asinhl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = asinhl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__asinhl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((asinhl(arg1) > 10) || (asinhl(arg1) < 100)) {}
+void test__asinhl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  asinhl(arg1);
 }
 
-void test__asinhl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = asinhl(p);
-    // cppcheck-suppress memleak
+void test__asinhl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((asinhl(arg1) > 10) || (asinhl(arg1) < 100)) {}
 }
 
-void test__asinhl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = asinhl(x);
+void test__asinhl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = asinhl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__asinhl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::asinhl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__asinhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = asinhl(x);
 }
 
-void test__std__asinhl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::asinhl(arg1);
+void test__std__asinhl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::asinhl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__asinhl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::asinhl(arg1) > 10) || (std::asinhl(arg1) < 100)) {}
+void test__std__asinhl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::asinhl(arg1);
 }
 
-void test__std__asinhl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::asinhl(x);
+void test__std__asinhl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::asinhl(arg1) > 10) || (std::asinhl(arg1) < 100)) {}
 }
 
-void test__casinh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = casinh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__asinhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::asinhl(x);
 }
 
-void test__casinh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    casinh(arg1);
+void test__casinh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = casinh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__casinh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((casinh(arg1) > 10) || (casinh(arg1) < 100)) {}
+void test__casinh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  casinh(arg1);
 }
 
-void test__casinh__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = casinh(p);
-    // cppcheck-suppress memleak
+void test__casinh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((casinh(arg1) > 10) || (casinh(arg1) < 100)) {}
 }
 
-void test__casinh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = casinh(x);
+void test__casinh__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = casinh(p);
+  // cppcheck-suppress memleak
 }
 
-void test__casinhf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = casinhf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__casinh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = casinh(x);
 }
 
-void test__casinhf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    casinhf(arg1);
+void test__casinhf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = casinhf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__casinhf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((casinhf(arg1) > 10) || (casinhf(arg1) < 100)) {}
+void test__casinhf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  casinhf(arg1);
 }
 
-void test__casinhf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = casinhf(p);
-    // cppcheck-suppress memleak
+void test__casinhf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((casinhf(arg1) > 10) || (casinhf(arg1) < 100)) {}
 }
 
-void test__casinhf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = casinhf(x);
+void test__casinhf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = casinhf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__casinhl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = casinhl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__casinhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = casinhf(x);
 }
 
-void test__casinhl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    casinhl(arg1);
+void test__casinhl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = casinhl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__casinhl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((casinhl(arg1) > 10) || (casinhl(arg1) < 100)) {}
+void test__casinhl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  casinhl(arg1);
 }
 
-void test__casinhl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = casinhl(p);
-    // cppcheck-suppress memleak
+void test__casinhl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((casinhl(arg1) > 10) || (casinhl(arg1) < 100)) {}
 }
 
-void test__casinhl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = casinhl(x);
+void test__casinhl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = casinhl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wcsftime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcsftime(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__casinhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = casinhl(x);
 }
 
-void test__wcsftime__pure(int arg1,int arg2,int arg3,int arg4)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((wcsftime(arg1, arg2, arg3, arg4) > 10) || (wcsftime(arg1, arg2, arg3, arg4) < 100)) {}
+void test__wcsftime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcsftime(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsftime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcsftime(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__wcsftime__pure(int arg1,int arg2,int arg3,int arg4) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wcsftime(arg1, arg2, arg3, arg4) > 10) || (wcsftime(arg1, arg2, arg3, arg4) < 100)) {}
 }
 
-void test__wcsftime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcsftime(NULL, arg2, arg3, arg4);
+void test__wcsftime__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcsftime(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__wcsftime__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wcsftime(arg1, x, arg3, arg4);
+void test__wcsftime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsftime(NULL, arg2, arg3, arg4);
 }
 
-void test__wcsftime__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcsftime(arg1, arg2, NULL, arg4);
+void test__wcsftime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcsftime(arg1, x, arg3, arg4);
 }
 
-void test__wcsftime__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcsftime(arg1, arg2, x, arg4);
+void test__wcsftime__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsftime(arg1, arg2, NULL, arg4);
 }
 
-void test__wcsftime__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcsftime(arg1, arg2, arg3, NULL);
+void test__wcsftime__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsftime(arg1, arg2, x, arg4);
 }
 
-void test__wcsftime__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcsftime(arg1, arg2, arg3, x);
+void test__wcsftime__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsftime(arg1, arg2, arg3, NULL);
 }
 
-void test__std__wcsftime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wcsftime(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsftime__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsftime(arg1, arg2, arg3, x);
 }
 
-void test__std__wcsftime__pure(int arg1,int arg2,int arg3,int arg4)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::wcsftime(arg1, arg2, arg3, arg4) > 10) || (std::wcsftime(arg1, arg2, arg3, arg4) < 100)) {}
+void test__std__wcsftime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wcsftime(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsftime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcsftime(NULL, arg2, arg3, arg4);
+void test__std__wcsftime__pure(int arg1,int arg2,int arg3,int arg4) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wcsftime(arg1, arg2, arg3, arg4) > 10) || (std::wcsftime(arg1, arg2, arg3, arg4) < 100)) {}
 }
 
-void test__std__wcsftime__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wcsftime(arg1, x, arg3, arg4);
+void test__std__wcsftime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsftime(NULL, arg2, arg3, arg4);
 }
 
-void test__std__wcsftime__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcsftime(arg1, arg2, NULL, arg4);
+void test__std__wcsftime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcsftime(arg1, x, arg3, arg4);
 }
 
-void test__std__wcsftime__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wcsftime(arg1, arg2, x, arg4);
+void test__std__wcsftime__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsftime(arg1, arg2, NULL, arg4);
 }
 
-void test__std__wcsftime__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcsftime(arg1, arg2, arg3, NULL);
+void test__std__wcsftime__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcsftime(arg1, arg2, x, arg4);
 }
 
-void test__std__wcsftime__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wcsftime(arg1, arg2, arg3, x);
+void test__std__wcsftime__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsftime(arg1, arg2, arg3, NULL);
 }
 
-void test__tan__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = tan(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcsftime__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcsftime(arg1, arg2, arg3, x);
 }
 
-void test__tan__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    tan(arg1);
+void test__tan__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = tan(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tan__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((tan(arg1) > 10) || (tan(arg1) < 100)) {}
+void test__tan__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tan(arg1);
 }
 
-void test__tan__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = tan(p);
-    // cppcheck-suppress memleak
+void test__tan__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((tan(arg1) > 10) || (tan(arg1) < 100)) {}
 }
 
-void test__tan__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = tan(x);
+void test__tan__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = tan(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__tan__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::tan(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tan__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tan(x);
 }
 
-void test__std__tan__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::tan(arg1);
+void test__std__tan__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::tan(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__tan__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::tan(arg1) > 10) || (std::tan(arg1) < 100)) {}
+void test__std__tan__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::tan(arg1);
 }
 
-void test__std__tan__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::tan(x);
+void test__std__tan__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::tan(arg1) > 10) || (std::tan(arg1) < 100)) {}
 }
 
-void test__tanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = tanf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__tan__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tan(x);
 }
 
-void test__tanf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    tanf(arg1);
+void test__tanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = tanf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tanf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((tanf(arg1) > 10) || (tanf(arg1) < 100)) {}
+void test__tanf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tanf(arg1);
 }
 
-void test__tanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = tanf(p);
-    // cppcheck-suppress memleak
+void test__tanf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((tanf(arg1) > 10) || (tanf(arg1) < 100)) {}
 }
 
-void test__tanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = tanf(x);
+void test__tanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = tanf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__tanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::tanf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tanf(x);
 }
 
-void test__std__tanf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::tanf(arg1);
+void test__std__tanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::tanf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__tanf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::tanf(arg1) > 10) || (std::tanf(arg1) < 100)) {}
+void test__std__tanf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::tanf(arg1);
 }
 
-void test__std__tanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::tanf(x);
+void test__std__tanf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::tanf(arg1) > 10) || (std::tanf(arg1) < 100)) {}
 }
 
-void test__tanl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = tanl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__tanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tanf(x);
 }
 
-void test__tanl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    tanl(arg1);
+void test__tanl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = tanl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tanl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((tanl(arg1) > 10) || (tanl(arg1) < 100)) {}
+void test__tanl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tanl(arg1);
 }
 
-void test__tanl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = tanl(p);
-    // cppcheck-suppress memleak
+void test__tanl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((tanl(arg1) > 10) || (tanl(arg1) < 100)) {}
 }
 
-void test__tanl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = tanl(x);
+void test__tanl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = tanl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__tanl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::tanl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tanl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tanl(x);
 }
 
-void test__std__tanl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::tanl(arg1);
+void test__std__tanl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::tanl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__tanl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::tanl(arg1) > 10) || (std::tanl(arg1) < 100)) {}
+void test__std__tanl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::tanl(arg1);
 }
 
-void test__std__tanl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::tanl(x);
+void test__std__tanl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::tanl(arg1) > 10) || (std::tanl(arg1) < 100)) {}
 }
 
-void test__ctan__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ctan(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__tanl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tanl(x);
 }
 
-void test__ctan__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ctan(arg1);
+void test__ctan__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ctan(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ctan__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ctan(arg1) > 10) || (ctan(arg1) < 100)) {}
+void test__ctan__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ctan(arg1);
 }
 
-void test__ctan__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ctan(p);
-    // cppcheck-suppress memleak
+void test__ctan__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ctan(arg1) > 10) || (ctan(arg1) < 100)) {}
 }
 
-void test__ctan__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ctan(x);
+void test__ctan__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ctan(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ctanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ctanf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ctan__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ctan(x);
 }
 
-void test__ctanf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ctanf(arg1);
+void test__ctanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ctanf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ctanf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ctanf(arg1) > 10) || (ctanf(arg1) < 100)) {}
+void test__ctanf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ctanf(arg1);
 }
 
-void test__ctanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ctanf(p);
-    // cppcheck-suppress memleak
+void test__ctanf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ctanf(arg1) > 10) || (ctanf(arg1) < 100)) {}
 }
 
-void test__ctanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ctanf(x);
+void test__ctanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ctanf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ctanl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ctanl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ctanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ctanf(x);
 }
 
-void test__ctanl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ctanl(arg1);
+void test__ctanl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ctanl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ctanl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ctanl(arg1) > 10) || (ctanl(arg1) < 100)) {}
+void test__ctanl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ctanl(arg1);
 }
 
-void test__ctanl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ctanl(p);
-    // cppcheck-suppress memleak
+void test__ctanl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ctanl(arg1) > 10) || (ctanl(arg1) < 100)) {}
 }
 
-void test__ctanl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ctanl(x);
+void test__ctanl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ctanl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__tanh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = tanh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ctanl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ctanl(x);
 }
 
-void test__tanh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    tanh(arg1);
+void test__tanh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = tanh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tanh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((tanh(arg1) > 10) || (tanh(arg1) < 100)) {}
+void test__tanh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tanh(arg1);
 }
 
-void test__tanh__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = tanh(p);
-    // cppcheck-suppress memleak
+void test__tanh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((tanh(arg1) > 10) || (tanh(arg1) < 100)) {}
 }
 
-void test__tanh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = tanh(x);
+void test__tanh__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = tanh(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__tanh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::tanh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tanh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tanh(x);
 }
 
-void test__std__tanh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::tanh(arg1);
+void test__std__tanh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::tanh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__tanh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::tanh(arg1) > 10) || (std::tanh(arg1) < 100)) {}
+void test__std__tanh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::tanh(arg1);
 }
 
-void test__std__tanh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::tanh(x);
+void test__std__tanh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::tanh(arg1) > 10) || (std::tanh(arg1) < 100)) {}
 }
 
-void test__tanhf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = tanhf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__tanh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tanh(x);
 }
 
-void test__tanhf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    tanhf(arg1);
+void test__tanhf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = tanhf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tanhf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((tanhf(arg1) > 10) || (tanhf(arg1) < 100)) {}
+void test__tanhf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tanhf(arg1);
 }
 
-void test__tanhf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = tanhf(p);
-    // cppcheck-suppress memleak
+void test__tanhf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((tanhf(arg1) > 10) || (tanhf(arg1) < 100)) {}
 }
 
-void test__tanhf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = tanhf(x);
+void test__tanhf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = tanhf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__tanhf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::tanhf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tanhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tanhf(x);
 }
 
-void test__std__tanhf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::tanhf(arg1);
+void test__std__tanhf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::tanhf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__tanhf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::tanhf(arg1) > 10) || (std::tanhf(arg1) < 100)) {}
+void test__std__tanhf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::tanhf(arg1);
 }
 
-void test__std__tanhf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::tanhf(x);
+void test__std__tanhf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::tanhf(arg1) > 10) || (std::tanhf(arg1) < 100)) {}
 }
 
-void test__tanhl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = tanhl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__tanhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tanhf(x);
 }
 
-void test__tanhl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    tanhl(arg1);
+void test__tanhl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = tanhl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tanhl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((tanhl(arg1) > 10) || (tanhl(arg1) < 100)) {}
+void test__tanhl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tanhl(arg1);
 }
 
-void test__tanhl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = tanhl(p);
-    // cppcheck-suppress memleak
+void test__tanhl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((tanhl(arg1) > 10) || (tanhl(arg1) < 100)) {}
 }
 
-void test__tanhl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = tanhl(x);
+void test__tanhl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = tanhl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__tanhl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::tanhl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tanhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tanhl(x);
 }
 
-void test__std__tanhl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::tanhl(arg1);
+void test__std__tanhl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::tanhl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__tanhl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::tanhl(arg1) > 10) || (std::tanhl(arg1) < 100)) {}
+void test__std__tanhl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::tanhl(arg1);
 }
 
-void test__std__tanhl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::tanhl(x);
+void test__std__tanhl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::tanhl(arg1) > 10) || (std::tanhl(arg1) < 100)) {}
 }
 
-void test__ctanh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ctanh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__tanhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tanhl(x);
 }
 
-void test__ctanh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ctanh(arg1);
+void test__ctanh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ctanh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ctanh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ctanh(arg1) > 10) || (ctanh(arg1) < 100)) {}
+void test__ctanh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ctanh(arg1);
 }
 
-void test__ctanh__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ctanh(p);
-    // cppcheck-suppress memleak
+void test__ctanh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ctanh(arg1) > 10) || (ctanh(arg1) < 100)) {}
 }
 
-void test__ctanh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ctanh(x);
+void test__ctanh__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ctanh(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ctanhf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ctanhf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ctanh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ctanh(x);
 }
 
-void test__ctanhf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ctanhf(arg1);
+void test__ctanhf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ctanhf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ctanhf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ctanhf(arg1) > 10) || (ctanhf(arg1) < 100)) {}
+void test__ctanhf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ctanhf(arg1);
 }
 
-void test__ctanhf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ctanhf(p);
-    // cppcheck-suppress memleak
+void test__ctanhf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ctanhf(arg1) > 10) || (ctanhf(arg1) < 100)) {}
 }
 
-void test__ctanhf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ctanhf(x);
+void test__ctanhf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ctanhf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ctanhl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ctanhl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ctanhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ctanhf(x);
 }
 
-void test__ctanhl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ctanhl(arg1);
+void test__ctanhl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ctanhl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ctanhl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ctanhl(arg1) > 10) || (ctanhl(arg1) < 100)) {}
+void test__ctanhl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ctanhl(arg1);
 }
 
-void test__ctanhl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ctanhl(p);
-    // cppcheck-suppress memleak
+void test__ctanhl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ctanhl(arg1) > 10) || (ctanhl(arg1) < 100)) {}
 }
 
-void test__ctanhl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ctanhl(x);
+void test__ctanhl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ctanhl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__feclearexcept__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        feclearexcept(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ctanhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ctanhl(x);
 }
 
-void test__feclearexcept__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((feclearexcept(arg1) > 10) || (feclearexcept(arg1) < 100)) {}
+void test__feclearexcept__noreturn() {
+  int x = 1;
+  if (cond) { x=100; feclearexcept(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__feclearexcept__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    feclearexcept(p);
-    // cppcheck-suppress memleak
+void test__feclearexcept__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((feclearexcept(arg1) > 10) || (feclearexcept(arg1) < 100)) {}
 }
 
-void test__feclearexcept__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    feclearexcept(x);
+void test__feclearexcept__leakignore() {
+  char *p = malloc(10); *p=0;
+  feclearexcept(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__feclearexcept__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::feclearexcept(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__feclearexcept__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  feclearexcept(x);
 }
 
-void test__std__feclearexcept__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::feclearexcept(arg1) > 10) || (std::feclearexcept(arg1) < 100)) {}
+void test__std__feclearexcept__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::feclearexcept(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__feclearexcept__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::feclearexcept(x);
+void test__std__feclearexcept__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::feclearexcept(arg1) > 10) || (std::feclearexcept(arg1) < 100)) {}
 }
 
-void test__fegetenv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fegetenv(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__feclearexcept__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::feclearexcept(x);
 }
 
-void test__fegetenv__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fegetenv(p);
-    // cppcheck-suppress memleak
+void test__fegetenv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fegetenv(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fegetenv__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fegetenv(NULL);
+void test__fegetenv__leakignore() {
+  char *p = malloc(10); *p=0;
+  fegetenv(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fegetenv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fegetenv(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fegetenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fegetenv(NULL);
 }
 
-void test__std__fegetenv__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fegetenv(NULL);
+void test__std__fegetenv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fegetenv(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fegetexceptflag__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fegetexceptflag(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fegetenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fegetenv(NULL);
 }
 
-void test__fegetexceptflag__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fegetexceptflag(p, arg2);
-    // cppcheck-suppress memleak
+void test__fegetexceptflag__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fegetexceptflag(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__fegetexceptflag__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fegetexceptflag(NULL, arg2);
+
+void test__fegetexceptflag__leakignore() {
+  char *p = malloc(10); *p=0;
+  fegetexceptflag(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fegetexceptflag__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fegetexceptflag(NULL, arg2);
+}
+
+void test__fegetexceptflag__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fegetexceptflag(arg1, x);
+}
+
+void test__std__fegetexceptflag__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fegetexceptflag(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fegetexceptflag__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fegetexceptflag(NULL, arg2);
+}
+
+void test__std__fegetexceptflag__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fegetexceptflag(arg1, x);
+}
+
+void test__fegetround__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fegetround(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fegetround__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fegetround();
+}
+
+void test__fegetround__pure() {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fegetround() > 10) || (fegetround() < 100)) {}
+}
+
+void test__fegetround__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fegetround();
+  // cppcheck-suppress memleak
+}
+
+void test__std__fegetround__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fegetround(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fegetround__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fegetround();
+}
+
+void test__std__fegetround__pure() {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fegetround() > 10) || (std::fegetround() < 100)) {}
+}
+
+void test__feholdexcept__noreturn() {
+  int x = 1;
+  if (cond) { x=100; feholdexcept(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__feholdexcept__leakignore() {
+  char *p = malloc(10); *p=0;
+  feholdexcept(p);
+  // cppcheck-suppress memleak
+}
+
+void test__feholdexcept__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  feholdexcept(NULL);
+}
+
+void test__std__feholdexcept__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::feholdexcept(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__feholdexcept__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::feholdexcept(NULL);
+}
+
+void test__feraiseexcept__noreturn() {
+  int x = 1;
+  if (cond) { x=100; feraiseexcept(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__feraiseexcept__leakignore() {
+  char *p = malloc(10); *p=0;
+  feraiseexcept(p);
+  // cppcheck-suppress memleak
+}
+
+void test__feraiseexcept__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  feraiseexcept(x);
+}
+
+void test__std__feraiseexcept__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::feraiseexcept(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__feraiseexcept__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::feraiseexcept(x);
+}
+
+void test__fesetenv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fesetenv(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fesetenv__leakignore() {
+  char *p = malloc(10); *p=0;
+  fesetenv(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fesetenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fesetenv(NULL);
+}
+
+void test__fesetenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fesetenv(x);
+}
+
+void test__std__fesetenv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fesetenv(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fesetenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fesetenv(NULL);
+}
+
+void test__std__fesetenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fesetenv(x);
+}
+
+void test__fesetexceptflag__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fesetexceptflag(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fesetexceptflag__leakignore() {
+  char *p = malloc(10); *p=0;
+  fesetexceptflag(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fesetexceptflag__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fesetexceptflag(NULL, arg2);
+}
+
+void test__fesetexceptflag__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fesetexceptflag(x, arg2);
+}
+
+void test__fesetexceptflag__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fesetexceptflag(arg1, x);
+}
+
+void test__std__fesetexceptflag__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fesetexceptflag(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fesetexceptflag__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fesetexceptflag(NULL, arg2);
+}
+
+void test__std__fesetexceptflag__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fesetexceptflag(x, arg2);
+}
+
+void test__std__fesetexceptflag__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fesetexceptflag(arg1, x);
+}
+
+void test__fesetround__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fesetround(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fesetround__leakignore() {
+  char *p = malloc(10); *p=0;
+  fesetround(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fesetround__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fesetround(x);
+}
+
+void test__std__fesetround__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fesetround(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fesetround__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fesetround(x);
+}
+
+void test__fetestexcept__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fetestexcept(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fetestexcept__leakignore() {
+  char *p = malloc(10); *p=0;
+  fetestexcept(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fetestexcept__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fetestexcept(x);
+}
+
+void test__std__fetestexcept__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fetestexcept(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fetestexcept__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fetestexcept(x);
+}
+
+void test__feupdateenv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; feupdateenv(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__feupdateenv__leakignore() {
+  char *p = malloc(10); *p=0;
+  feupdateenv(p);
+  // cppcheck-suppress memleak
+}
+
+void test__feupdateenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  feupdateenv(NULL);
+}
+
+void test__feupdateenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  feupdateenv(x);
+}
+
+void test__std__feupdateenv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::feupdateenv(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__feupdateenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::feupdateenv(NULL);
+}
+
+void test__std__feupdateenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::feupdateenv(x);
+}
+
+void test__atan__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = atan(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__atan__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  atan(arg1);
+}
+
+void test__atan__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((atan(arg1) > 10) || (atan(arg1) < 100)) {}
+}
+
+void test__atan__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = atan(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atan__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = atan(x);
+}
+
+void test__std__atan__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::atan(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__atan__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::atan(arg1);
+}
+
+void test__std__atan__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::atan(arg1) > 10) || (std::atan(arg1) < 100)) {}
+}
+
+void test__std__atan__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atan(x);
+}
+
+void test__atanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = atanf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__atanf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  atanf(arg1);
+}
+
+void test__atanf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((atanf(arg1) > 10) || (atanf(arg1) < 100)) {}
+}
+
+void test__atanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = atanf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = atanf(x);
+}
+
+void test__std__atanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::atanf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__atanf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::atanf(arg1);
+}
+
+void test__std__atanf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::atanf(arg1) > 10) || (std::atanf(arg1) < 100)) {}
+}
+
+void test__std__atanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atanf(x);
+}
+
+void test__atanl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = atanl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__atanl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  atanl(arg1);
+}
+
+void test__atanl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((atanl(arg1) > 10) || (atanl(arg1) < 100)) {}
+}
+
+void test__atanl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = atanl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atanl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = atanl(x);
+}
+
+void test__std__atanl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::atanl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__atanl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::atanl(arg1);
+}
+
+void test__std__atanl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::atanl(arg1) > 10) || (std::atanl(arg1) < 100)) {}
+}
+
+void test__std__atanl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atanl(x);
+}
+
+void test__catan__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = catan(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__catan__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  catan(arg1);
+}
+
+void test__catan__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((catan(arg1) > 10) || (catan(arg1) < 100)) {}
+}
+
+void test__catan__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = catan(p);
+  // cppcheck-suppress memleak
+}
+
+void test__catan__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = catan(x);
+}
+
+void test__catanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = catanf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__catanf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  catanf(arg1);
+}
+
+void test__catanf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((catanf(arg1) > 10) || (catanf(arg1) < 100)) {}
+}
+
+void test__catanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = catanf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__catanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = catanf(x);
+}
+
+void test__catanl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = catanl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__catanl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  catanl(arg1);
+}
+
+void test__catanl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((catanl(arg1) > 10) || (catanl(arg1) < 100)) {}
+}
+
+void test__catanl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = catanl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__catanl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = catanl(x);
+}
+
+void test__tgamma__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = tgamma(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tgamma__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tgamma(arg1);
+}
+
+void test__tgamma__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((tgamma(arg1) > 10) || (tgamma(arg1) < 100)) {}
+}
+
+void test__tgamma__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = tgamma(p);
+  // cppcheck-suppress memleak
+}
+
+void test__tgamma__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tgamma(x);
+}
+
+void test__std__tgamma__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::tgamma(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__tgamma__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::tgamma(arg1);
+}
+
+void test__std__tgamma__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::tgamma(arg1) > 10) || (std::tgamma(arg1) < 100)) {}
+}
+
+void test__std__tgamma__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tgamma(x);
+}
+
+void test__tgammaf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = tgammaf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tgammaf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tgammaf(arg1);
+}
+
+void test__tgammaf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((tgammaf(arg1) > 10) || (tgammaf(arg1) < 100)) {}
+}
+
+void test__tgammaf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = tgammaf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__tgammaf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tgammaf(x);
+}
+
+void test__std__tgammaf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::tgammaf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__tgammaf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::tgammaf(arg1);
+}
+
+void test__std__tgammaf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::tgammaf(arg1) > 10) || (std::tgammaf(arg1) < 100)) {}
+}
+
+void test__std__tgammaf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tgammaf(x);
+}
+
+void test__tgammal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = tgammal(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tgammal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tgammal(arg1);
+}
+
+void test__tgammal__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((tgammal(arg1) > 10) || (tgammal(arg1) < 100)) {}
+}
+
+void test__tgammal__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = tgammal(p);
+  // cppcheck-suppress memleak
+}
+
+void test__tgammal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tgammal(x);
+}
+
+void test__std__tgammal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::tgammal(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__tgammal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::tgammal(arg1);
+}
+
+void test__std__tgammal__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::tgammal(arg1) > 10) || (std::tgammal(arg1) < 100)) {}
+}
+
+void test__std__tgammal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tgammal(x);
+}
+
+void test__trunc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = trunc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__trunc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  trunc(arg1);
+}
+
+void test__trunc__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((trunc(arg1) > 10) || (trunc(arg1) < 100)) {}
+}
+
+void test__trunc__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = trunc(p);
+  // cppcheck-suppress memleak
+}
+
+void test__trunc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = trunc(x);
+}
+
+void test__std__trunc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::trunc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__trunc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::trunc(arg1);
+}
+
+void test__std__trunc__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::trunc(arg1) > 10) || (std::trunc(arg1) < 100)) {}
+}
+
+void test__std__trunc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::trunc(x);
+}
+
+void test__truncf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = truncf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__truncf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  truncf(arg1);
+}
+
+void test__truncf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((truncf(arg1) > 10) || (truncf(arg1) < 100)) {}
+}
+
+void test__truncf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = truncf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__truncf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = truncf(x);
+}
+
+void test__std__truncf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::truncf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__truncf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::truncf(arg1);
+}
+
+void test__std__truncf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::truncf(arg1) > 10) || (std::truncf(arg1) < 100)) {}
+}
+
+void test__std__truncf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::truncf(x);
+}
+
+void test__truncl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = truncl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__truncl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  truncl(arg1);
+}
+
+void test__truncl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((truncl(arg1) > 10) || (truncl(arg1) < 100)) {}
+}
+
+void test__truncl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = truncl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__truncl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = truncl(x);
+}
+
+void test__std__truncl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::truncl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__truncl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::truncl(arg1);
+}
+
+void test__std__truncl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::truncl(arg1) > 10) || (std::truncl(arg1) < 100)) {}
+}
+
+void test__std__truncl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::truncl(x);
+}
+
+void test__atanh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = atanh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__atanh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  atanh(arg1);
+}
+
+void test__atanh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((atanh(arg1) > 10) || (atanh(arg1) < 100)) {}
+}
+
+void test__atanh__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = atanh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atanh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = atanh(x);
+}
+
+void test__std__atanh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::atanh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__atanh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::atanh(arg1);
+}
+
+void test__std__atanh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::atanh(arg1) > 10) || (std::atanh(arg1) < 100)) {}
+}
+
+void test__std__atanh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atanh(x);
+}
+
+void test__atanhf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = atanhf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__atanhf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  atanhf(arg1);
+}
+
+void test__atanhf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((atanhf(arg1) > 10) || (atanhf(arg1) < 100)) {}
+}
+
+void test__atanhf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = atanhf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atanhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = atanhf(x);
+}
+
+void test__std__atanhf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::atanhf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__atanhf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::atanhf(arg1);
+}
+
+void test__std__atanhf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::atanhf(arg1) > 10) || (std::atanhf(arg1) < 100)) {}
+}
+
+void test__std__atanhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atanhf(x);
+}
+
+void test__atanhl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = atanhl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__atanhl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  atanhl(arg1);
+}
+
+void test__atanhl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((atanhl(arg1) > 10) || (atanhl(arg1) < 100)) {}
+}
+
+void test__atanhl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = atanhl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atanhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = atanhl(x);
+}
+
+void test__std__atanhl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::atanhl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__atanhl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::atanhl(arg1);
+}
+
+void test__std__atanhl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::atanhl(arg1) > 10) || (std::atanhl(arg1) < 100)) {}
+}
+
+void test__std__atanhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atanhl(x);
+}
+
+void test__catanh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = catanh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__catanh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  catanh(arg1);
+}
+
+void test__catanh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((catanh(arg1) > 10) || (catanh(arg1) < 100)) {}
+}
+
+void test__catanh__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = catanh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__catanh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = catanh(x);
+}
+
+void test__catanhf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = catanhf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__catanhf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  catanhf(arg1);
+}
+
+void test__catanhf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((catanhf(arg1) > 10) || (catanhf(arg1) < 100)) {}
+}
+
+void test__catanhf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = catanhf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__catanhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = catanhf(x);
+}
+
+void test__catanhl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = catanhl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__catanhl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  catanhl(arg1);
+}
+
+void test__catanhl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((catanhl(arg1) > 10) || (catanhl(arg1) < 100)) {}
+}
+
+void test__catanhl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = catanhl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__catanhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = catanhl(x);
+}
+
+void test__atan2__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = atan2(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__atan2__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  atan2(arg1, arg2);
+}
+
+void test__atan2__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((atan2(arg1, arg2) > 10) || (atan2(arg1, arg2) < 100)) {}
+}
+
+void test__atan2__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = atan2(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__atan2__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = atan2(x, arg2);
+}
+
+void test__atan2__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = atan2(arg1, x);
+}
+
+void test__std__atan2__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::atan2(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__atan2__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::atan2(arg1, arg2);
+}
+
+void test__std__atan2__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::atan2(arg1, arg2) > 10) || (std::atan2(arg1, arg2) < 100)) {}
+}
+
+void test__std__atan2__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atan2(x, arg2);
+}
+
+void test__std__atan2__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atan2(arg1, x);
+}
+
+void test__atan2f__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = atan2f(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__atan2f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  atan2f(arg1, arg2);
+}
+
+void test__atan2f__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((atan2f(arg1, arg2) > 10) || (atan2f(arg1, arg2) < 100)) {}
+}
+
+void test__atan2f__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = atan2f(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__atan2f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = atan2f(x, arg2);
+}
+
+void test__atan2f__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = atan2f(arg1, x);
+}
+
+void test__std__atan2f__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::atan2f(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__atan2f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::atan2f(arg1, arg2);
+}
+
+void test__std__atan2f__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::atan2f(arg1, arg2) > 10) || (std::atan2f(arg1, arg2) < 100)) {}
+}
+
+void test__std__atan2f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atan2f(x, arg2);
+}
+
+void test__std__atan2f__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atan2f(arg1, x);
+}
+
+void test__atan2l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = atan2l(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__atan2l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  atan2l(arg1, arg2);
+}
+
+void test__atan2l__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((atan2l(arg1, arg2) > 10) || (atan2l(arg1, arg2) < 100)) {}
+}
+
+void test__atan2l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = atan2l(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__atan2l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = atan2l(x, arg2);
+}
+
+void test__atan2l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = atan2l(arg1, x);
+}
+
+void test__std__atan2l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::atan2l(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__atan2l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::atan2l(arg1, arg2);
+}
+
+void test__std__atan2l__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::atan2l(arg1, arg2) > 10) || (std::atan2l(arg1, arg2) < 100)) {}
+}
+
+void test__std__atan2l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atan2l(x, arg2);
+}
+
+void test__std__atan2l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atan2l(arg1, x);
+}
+
+void test__atexit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; atexit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__atexit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((atexit(arg1) > 10) || (atexit(arg1) < 100)) {}
+}
+
+void test__atexit__leakignore() {
+  char *p = malloc(10); *p=0;
+  atexit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atexit__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  atexit(NULL);
+}
+
+void test__std__atexit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::atexit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__atexit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::atexit(arg1) > 10) || (std::atexit(arg1) < 100)) {}
+}
+
+void test__std__atexit__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::atexit(NULL);
+}
+
+void test__atoi__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = atoi(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__atoi__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  atoi(arg1);
+}
+
+void test__atoi__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((atoi(arg1) > 10) || (atoi(arg1) < 100)) {}
+}
+
+void test__atoi__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = atoi(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atoi__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = atoi(NULL);
+}
+
+void test__atoi__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = atoi(x);
+}
+
+void test__std__atoi__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::atoi(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__atoi__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::atoi(arg1);
+}
+
+void test__std__atoi__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::atoi(arg1) > 10) || (std::atoi(arg1) < 100)) {}
+}
+
+void test__std__atoi__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::atoi(NULL);
+}
+
+void test__std__atoi__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::atoi(x);
+}
+
+void test__atol__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = atol(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__atol__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  atol(arg1);
+}
+
+void test__atol__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((atol(arg1) > 10) || (atol(arg1) < 100)) {}
+}
+
+void test__atol__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = atol(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atol__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = atol(NULL);
+}
+
+void test__atol__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = atol(x);
+}
+
+void test__std__atol__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::atol(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__atol__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::atol(arg1);
+}
+
+void test__std__atol__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::atol(arg1) > 10) || (std::atol(arg1) < 100)) {}
+}
+
+void test__std__atol__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::atol(NULL);
+}
+
+void test__std__atol__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::atol(x);
+}
+
+void test__atoll__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = atoll(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__atoll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  atoll(arg1);
+}
+
+void test__atoll__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((atoll(arg1) > 10) || (atoll(arg1) < 100)) {}
+}
+
+void test__atoll__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = atoll(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = atoll(NULL);
+}
+
+void test__atoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = atoll(x);
+}
+
+void test__std__atoll__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::atoll(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__atoll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::atoll(arg1);
+}
+
+void test__std__atoll__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::atoll(arg1) > 10) || (std::atoll(arg1) < 100)) {}
+}
+
+void test__std__atoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::atoll(NULL);
+}
+
+void test__std__atoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::atoll(x);
+}
+
+void test__atof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = atof(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__atof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  atof(arg1);
+}
+
+void test__atof__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((atof(arg1) > 10) || (atof(arg1) < 100)) {}
+}
+
+void test__atof__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = atof(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = atof(NULL);
+}
+
+void test__atof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = atof(x);
+}
+
+void test__std__atof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::atof(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__atof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::atof(arg1);
+}
+
+void test__std__atof__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::atof(arg1) > 10) || (std::atof(arg1) < 100)) {}
+}
+
+void test__std__atof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::atof(NULL);
+}
+
+void test__std__atof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::atof(x);
+}
+
+void test__calloc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = calloc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__calloc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  calloc(arg1, arg2);
+}
+
+void test__calloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = calloc(x, arg2);
+}
+
+void test__calloc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = calloc(arg1, x);
+}
+
+void test__ceil__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ceil(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ceil__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ceil(arg1);
+}
+
+void test__ceil__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ceil(arg1) > 10) || (ceil(arg1) < 100)) {}
+}
+
+void test__ceil__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ceil(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ceil__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ceil(x);
+}
+
+void test__std__ceil__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ceil(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ceil__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ceil(arg1);
+}
+
+void test__std__ceil__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::ceil(arg1) > 10) || (std::ceil(arg1) < 100)) {}
+}
+
+void test__std__ceil__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ceil(x);
+}
+
+void test__ceilf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ceilf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ceilf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ceilf(arg1);
+}
+
+void test__ceilf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ceilf(arg1) > 10) || (ceilf(arg1) < 100)) {}
+}
+
+void test__ceilf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ceilf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ceilf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ceilf(x);
+}
+
+void test__std__ceilf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ceilf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ceilf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ceilf(arg1);
+}
+
+void test__std__ceilf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::ceilf(arg1) > 10) || (std::ceilf(arg1) < 100)) {}
+}
+
+void test__std__ceilf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ceilf(x);
+}
+
+void test__ceill__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ceill(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ceill__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ceill(arg1);
+}
+
+void test__ceill__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ceill(arg1) > 10) || (ceill(arg1) < 100)) {}
+}
+
+void test__ceill__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ceill(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ceill__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ceill(x);
+}
+
+void test__std__ceill__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ceill(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ceill__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ceill(arg1);
+}
+
+void test__std__ceill__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::ceill(arg1) > 10) || (std::ceill(arg1) < 100)) {}
+}
+
+void test__std__ceill__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ceill(x);
+}
+
+void test__copysign__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = copysign(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__copysign__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  copysign(arg1, arg2);
+}
+
+void test__copysign__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((copysign(arg1, arg2) > 10) || (copysign(arg1, arg2) < 100)) {}
+}
+
+void test__copysign__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = copysign(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__copysign__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = copysign(x, arg2);
+}
+
+void test__copysign__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = copysign(arg1, x);
+}
+
+void test__std__copysign__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::copysign(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__copysign__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::copysign(arg1, arg2);
+}
+
+void test__std__copysign__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::copysign(arg1, arg2) > 10) || (std::copysign(arg1, arg2) < 100)) {}
+}
+
+void test__std__copysign__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::copysign(x, arg2);
+}
+
+void test__std__copysign__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::copysign(arg1, x);
+}
+
+void test__copysignf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = copysignf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__copysignf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  copysignf(arg1, arg2);
+}
+
+void test__copysignf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((copysignf(arg1, arg2) > 10) || (copysignf(arg1, arg2) < 100)) {}
+}
+
+void test__copysignf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = copysignf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__copysignf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = copysignf(x, arg2);
+}
+
+void test__copysignf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = copysignf(arg1, x);
+}
+
+void test__std__copysignf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::copysignf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__copysignf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::copysignf(arg1, arg2);
+}
+
+void test__std__copysignf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::copysignf(arg1, arg2) > 10) || (std::copysignf(arg1, arg2) < 100)) {}
+}
+
+void test__std__copysignf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::copysignf(x, arg2);
+}
+
+void test__std__copysignf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::copysignf(arg1, x);
+}
+
+void test__copysignl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = copysignl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__copysignl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  copysignl(arg1, arg2);
+}
+
+void test__copysignl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((copysignl(arg1, arg2) > 10) || (copysignl(arg1, arg2) < 100)) {}
+}
+
+void test__copysignl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = copysignl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__copysignl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = copysignl(x, arg2);
+}
+
+void test__copysignl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = copysignl(arg1, x);
+}
+
+void test__std__copysignl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::copysignl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__copysignl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::copysignl(arg1, arg2);
+}
+
+void test__std__copysignl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::copysignl(arg1, arg2) > 10) || (std::copysignl(arg1, arg2) < 100)) {}
+}
+
+void test__std__copysignl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::copysignl(x, arg2);
+}
+
+void test__std__copysignl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::copysignl(arg1, x);
+}
+
+void test__clearerr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; clearerr(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__clearerr__leakignore() {
+  char *p = malloc(10); *p=0;
+  clearerr(p);
+  // cppcheck-suppress memleak
+}
+
+void test__clearerr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  clearerr(NULL);
+}
+
+void test__clearerr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  clearerr(x);
+}
+
+void test__std__clearerr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::clearerr(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__clearerr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::clearerr(NULL);
 }
 
-void test__fegetexceptflag__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fegetexceptflag(arg1, x);
+void test__std__clearerr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::clearerr(x);
 }
 
-void test__std__fegetexceptflag__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fegetexceptflag(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__clock__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = clock(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fegetexceptflag__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fegetexceptflag(NULL, arg2);
+void test__clock__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  clock();
 }
 
-void test__std__fegetexceptflag__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fegetexceptflag(arg1, x);
+void test__clock__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = clock();
+  // cppcheck-suppress memleak
 }
 
-void test__fegetround__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fegetround();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cbrt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cbrt(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fegetround__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fegetround();
+void test__cbrt__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cbrt(arg1);
 }
 
-void test__fegetround__pure()
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fegetround() > 10) || (fegetround() < 100)) {}
+void test__cbrt__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cbrt(arg1) > 10) || (cbrt(arg1) < 100)) {}
 }
 
-void test__fegetround__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fegetround();
-    // cppcheck-suppress memleak
-}
-
-void test__std__fegetround__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fegetround();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cbrt__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cbrt(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fegetround__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fegetround();
-}
-
-void test__std__fegetround__pure()
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fegetround() > 10) || (std::fegetround() < 100)) {}
+void test__cbrt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cbrt(x);
 }
 
-void test__feholdexcept__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        feholdexcept(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__std__cbrt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::cbrt(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__feholdexcept__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    feholdexcept(p);
-    // cppcheck-suppress memleak
+void test__std__cbrt__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::cbrt(arg1);
 }
 
-void test__feholdexcept__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    feholdexcept(NULL);
-}
-
-void test__std__feholdexcept__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::feholdexcept(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__cbrt__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::cbrt(arg1) > 10) || (std::cbrt(arg1) < 100)) {}
 }
 
-void test__std__feholdexcept__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::feholdexcept(NULL);
-}
+void test__std__cbrt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::cbrt(x);
+}
 
-void test__feraiseexcept__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        feraiseexcept(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__cbrtf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cbrtf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__feraiseexcept__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    feraiseexcept(p);
-    // cppcheck-suppress memleak
-}
+void test__cbrtf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cbrtf(arg1);
+}
 
-void test__feraiseexcept__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    feraiseexcept(x);
+void test__cbrtf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cbrtf(arg1) > 10) || (cbrtf(arg1) < 100)) {}
 }
 
-void test__std__feraiseexcept__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::feraiseexcept(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__feraiseexcept__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::feraiseexcept(x);
+void test__cbrtf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cbrtf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__fesetenv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fesetenv(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__fesetenv__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fesetenv(p);
-    // cppcheck-suppress memleak
-}
+void test__cbrtf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cbrtf(x);
+}
 
-void test__fesetenv__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fesetenv(NULL);
+void test__std__cbrtf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::cbrtf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fesetenv__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fesetenv(x);
+void test__std__cbrtf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::cbrtf(arg1);
 }
 
-void test__std__fesetenv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fesetenv(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__fesetenv__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fesetenv(NULL);
+void test__std__cbrtf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::cbrtf(arg1) > 10) || (std::cbrtf(arg1) < 100)) {}
 }
 
-void test__std__fesetenv__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fesetenv(x);
+void test__std__cbrtf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::cbrtf(x);
 }
-
-void test__fesetexceptflag__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fesetexceptflag(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__cbrtl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cbrtl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__fesetexceptflag__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fesetexceptflag(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__fesetexceptflag__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fesetexceptflag(NULL, arg2);
+
+void test__cbrtl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cbrtl(arg1);
 }
 
-void test__fesetexceptflag__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fesetexceptflag(x, arg2);
-}
-
-void test__fesetexceptflag__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fesetexceptflag(arg1, x);
-}
-
-void test__std__fesetexceptflag__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fesetexceptflag(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__fesetexceptflag__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fesetexceptflag(NULL, arg2);
-}
-
-void test__std__fesetexceptflag__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fesetexceptflag(x, arg2);
-}
-
-void test__std__fesetexceptflag__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fesetexceptflag(arg1, x);
-}
-
-void test__fesetround__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fesetround(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__fesetround__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fesetround(p);
-    // cppcheck-suppress memleak
-}
-
-void test__fesetround__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fesetround(x);
-}
-
-void test__std__fesetround__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fesetround(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cbrtl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cbrtl(arg1) > 10) || (cbrtl(arg1) < 100)) {}
 }
 
-void test__std__fesetround__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fesetround(x);
-}
+void test__cbrtl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cbrtl(p);
+  // cppcheck-suppress memleak
+}
 
-void test__fetestexcept__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fetestexcept(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__fetestexcept__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fetestexcept(p);
-    // cppcheck-suppress memleak
-}
-
-void test__fetestexcept__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fetestexcept(x);
-}
-
-void test__std__fetestexcept__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fetestexcept(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__fetestexcept__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fetestexcept(x);
-}
-
-void test__feupdateenv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        feupdateenv(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__cbrtl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cbrtl(x);
+}
 
-void test__feupdateenv__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    feupdateenv(p);
-    // cppcheck-suppress memleak
+void test__std__cbrtl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::cbrtl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__feupdateenv__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    feupdateenv(NULL);
+void test__std__cbrtl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::cbrtl(arg1);
 }
 
-void test__feupdateenv__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    feupdateenv(x);
-}
-
-void test__std__feupdateenv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::feupdateenv(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__cbrtl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::cbrtl(arg1) > 10) || (std::cbrtl(arg1) < 100)) {}
 }
 
-void test__std__feupdateenv__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::feupdateenv(NULL);
+void test__std__cbrtl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::cbrtl(x);
 }
 
-void test__std__feupdateenv__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::feupdateenv(x);
+void test__cos__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cos(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atan__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = atan(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cos__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cos(arg1);
 }
 
-void test__atan__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    atan(arg1);
+void test__cos__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cos(arg1) > 10) || (cos(arg1) < 100)) {}
 }
 
-void test__atan__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((atan(arg1) > 10) || (atan(arg1) < 100)) {}
+void test__cos__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cos(p);
+  // cppcheck-suppress memleak
 }
 
-void test__atan__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = atan(p);
-    // cppcheck-suppress memleak
+void test__cos__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cos(x);
 }
 
-void test__atan__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = atan(x);
+void test__std__cos__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::cos(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__atan__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::atan(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__cos__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::cos(arg1);
 }
 
-void test__std__atan__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::atan(arg1);
+void test__std__cos__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::cos(arg1) > 10) || (std::cos(arg1) < 100)) {}
 }
 
-void test__std__atan__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::atan(arg1) > 10) || (std::atan(arg1) < 100)) {}
+void test__std__cos__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::cos(x);
 }
 
-void test__std__atan__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::atan(x);
+void test__cosf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cosf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = atanf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cosf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cosf(arg1);
 }
 
-void test__atanf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    atanf(arg1);
+void test__cosf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cosf(arg1) > 10) || (cosf(arg1) < 100)) {}
 }
 
-void test__atanf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((atanf(arg1) > 10) || (atanf(arg1) < 100)) {}
+void test__cosf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cosf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__atanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = atanf(p);
-    // cppcheck-suppress memleak
+void test__cosf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cosf(x);
 }
 
-void test__atanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = atanf(x);
+void test__std__cosf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::cosf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__atanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::atanf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__cosf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::cosf(arg1);
 }
 
-void test__std__atanf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::atanf(arg1);
+void test__std__cosf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::cosf(arg1) > 10) || (std::cosf(arg1) < 100)) {}
 }
 
-void test__std__atanf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::atanf(arg1) > 10) || (std::atanf(arg1) < 100)) {}
+void test__std__cosf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::cosf(x);
 }
 
-void test__std__atanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::atanf(x);
+void test__cosl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cosl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atanl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = atanl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cosl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cosl(arg1);
 }
 
-void test__atanl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    atanl(arg1);
+void test__cosl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cosl(arg1) > 10) || (cosl(arg1) < 100)) {}
 }
 
-void test__atanl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((atanl(arg1) > 10) || (atanl(arg1) < 100)) {}
+void test__cosl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cosl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__atanl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = atanl(p);
-    // cppcheck-suppress memleak
+void test__cosl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cosl(x);
 }
 
-void test__atanl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = atanl(x);
+void test__std__cosl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::cosl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__atanl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::atanl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__cosl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::cosl(arg1);
 }
 
-void test__std__atanl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::atanl(arg1);
+void test__std__cosl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::cosl(arg1) > 10) || (std::cosl(arg1) < 100)) {}
 }
 
-void test__std__atanl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::atanl(arg1) > 10) || (std::atanl(arg1) < 100)) {}
+void test__std__cosl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::cosl(x);
 }
 
-void test__std__atanl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::atanl(x);
+void test__ccos__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ccos(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__catan__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = catan(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ccos__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ccos(arg1);
 }
 
-void test__catan__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    catan(arg1);
+void test__ccos__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ccos(arg1) > 10) || (ccos(arg1) < 100)) {}
 }
 
-void test__catan__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((catan(arg1) > 10) || (catan(arg1) < 100)) {}
+void test__ccos__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ccos(p);
+  // cppcheck-suppress memleak
 }
 
-void test__catan__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = catan(p);
-    // cppcheck-suppress memleak
+void test__ccos__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ccos(x);
 }
 
-void test__catan__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = catan(x);
+void test__ccosf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ccosf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__catanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = catanf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ccosf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ccosf(arg1);
 }
 
-void test__catanf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    catanf(arg1);
+void test__ccosf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ccosf(arg1) > 10) || (ccosf(arg1) < 100)) {}
 }
 
-void test__catanf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((catanf(arg1) > 10) || (catanf(arg1) < 100)) {}
+void test__ccosf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ccosf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__catanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = catanf(p);
-    // cppcheck-suppress memleak
+void test__ccosf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ccosf(x);
 }
 
-void test__catanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = catanf(x);
+void test__ccosl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ccosl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__catanl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = catanl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ccosl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ccosl(arg1);
 }
 
-void test__catanl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    catanl(arg1);
+void test__ccosl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ccosl(arg1) > 10) || (ccosl(arg1) < 100)) {}
 }
 
-void test__catanl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((catanl(arg1) > 10) || (catanl(arg1) < 100)) {}
+void test__ccosl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ccosl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__catanl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = catanl(p);
-    // cppcheck-suppress memleak
+void test__ccosl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ccosl(x);
 }
 
-void test__catanl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = catanl(x);
+void test__cosh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cosh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tgamma__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = tgamma(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cosh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cosh(arg1);
 }
 
-void test__tgamma__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    tgamma(arg1);
+void test__cosh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cosh(arg1) > 10) || (cosh(arg1) < 100)) {}
 }
 
-void test__tgamma__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((tgamma(arg1) > 10) || (tgamma(arg1) < 100)) {}
+void test__cosh__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cosh(p);
+  // cppcheck-suppress memleak
 }
 
-void test__tgamma__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = tgamma(p);
-    // cppcheck-suppress memleak
+void test__cosh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cosh(x);
 }
 
-void test__tgamma__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = tgamma(x);
+void test__std__cosh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::cosh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__tgamma__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::tgamma(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__cosh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::cosh(arg1);
 }
 
-void test__std__tgamma__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::tgamma(arg1);
+void test__std__cosh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::cosh(arg1) > 10) || (std::cosh(arg1) < 100)) {}
 }
 
-void test__std__tgamma__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::tgamma(arg1) > 10) || (std::tgamma(arg1) < 100)) {}
+void test__std__cosh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::cosh(x);
 }
 
-void test__std__tgamma__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::tgamma(x);
+void test__coshf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = coshf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tgammaf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = tgammaf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__coshf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  coshf(arg1);
 }
 
-void test__tgammaf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    tgammaf(arg1);
+void test__coshf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((coshf(arg1) > 10) || (coshf(arg1) < 100)) {}
 }
 
-void test__tgammaf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((tgammaf(arg1) > 10) || (tgammaf(arg1) < 100)) {}
+void test__coshf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = coshf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__tgammaf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = tgammaf(p);
-    // cppcheck-suppress memleak
+void test__coshf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = coshf(x);
 }
 
-void test__tgammaf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = tgammaf(x);
+void test__std__coshf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::coshf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__tgammaf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::tgammaf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__coshf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::coshf(arg1);
 }
 
-void test__std__tgammaf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::tgammaf(arg1);
+void test__std__coshf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::coshf(arg1) > 10) || (std::coshf(arg1) < 100)) {}
 }
 
-void test__std__tgammaf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::tgammaf(arg1) > 10) || (std::tgammaf(arg1) < 100)) {}
+void test__std__coshf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::coshf(x);
 }
 
-void test__std__tgammaf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::tgammaf(x);
+void test__coshl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = coshl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__tgammal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = tgammal(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__coshl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  coshl(arg1);
 }
 
-void test__tgammal__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    tgammal(arg1);
+void test__coshl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((coshl(arg1) > 10) || (coshl(arg1) < 100)) {}
 }
 
-void test__tgammal__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((tgammal(arg1) > 10) || (tgammal(arg1) < 100)) {}
+void test__coshl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = coshl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__tgammal__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = tgammal(p);
-    // cppcheck-suppress memleak
+void test__coshl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = coshl(x);
 }
 
-void test__tgammal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = tgammal(x);
+void test__std__coshl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::coshl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__tgammal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::tgammal(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__coshl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::coshl(arg1);
 }
 
-void test__std__tgammal__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::tgammal(arg1);
+void test__std__coshl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::coshl(arg1) > 10) || (std::coshl(arg1) < 100)) {}
 }
 
-void test__std__tgammal__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::tgammal(arg1) > 10) || (std::tgammal(arg1) < 100)) {}
+void test__std__coshl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::coshl(x);
 }
 
-void test__std__tgammal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::tgammal(x);
+void test__ccosh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ccosh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__trunc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = trunc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ccosh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ccosh(arg1);
 }
 
-void test__trunc__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    trunc(arg1);
+void test__ccosh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ccosh(arg1) > 10) || (ccosh(arg1) < 100)) {}
 }
 
-void test__trunc__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((trunc(arg1) > 10) || (trunc(arg1) < 100)) {}
+void test__ccosh__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ccosh(p);
+  // cppcheck-suppress memleak
 }
 
-void test__trunc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = trunc(p);
-    // cppcheck-suppress memleak
+void test__ccosh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ccosh(x);
 }
 
-void test__trunc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = trunc(x);
+void test__ccoshf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ccoshf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__trunc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::trunc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ccoshf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ccoshf(arg1);
 }
 
-void test__std__trunc__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::trunc(arg1);
+void test__ccoshf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ccoshf(arg1) > 10) || (ccoshf(arg1) < 100)) {}
 }
 
-void test__std__trunc__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::trunc(arg1) > 10) || (std::trunc(arg1) < 100)) {}
+void test__ccoshf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ccoshf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__trunc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::trunc(x);
+void test__ccoshf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ccoshf(x);
 }
 
-void test__truncf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = truncf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ccoshl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ccoshl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__truncf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    truncf(arg1);
+void test__ccoshl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ccoshl(arg1);
 }
 
-void test__truncf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((truncf(arg1) > 10) || (truncf(arg1) < 100)) {}
+void test__ccoshl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ccoshl(arg1) > 10) || (ccoshl(arg1) < 100)) {}
 }
 
-void test__truncf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = truncf(p);
-    // cppcheck-suppress memleak
+void test__ccoshl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ccoshl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__truncf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = truncf(x);
+void test__ccoshl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ccoshl(x);
 }
 
-void test__std__truncf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::truncf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ctime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ctime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__truncf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::truncf(arg1);
+void test__ctime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ctime(arg1);
 }
 
-void test__std__truncf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::truncf(arg1) > 10) || (std::truncf(arg1) < 100)) {}
+void test__ctime__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ctime(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__truncf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::truncf(x);
+void test__ctime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = ctime(NULL);
 }
 
-void test__truncl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = truncl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ctime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = ctime(x);
 }
 
-void test__truncl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    truncl(arg1);
+void test__std__ctime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ctime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__truncl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((truncl(arg1) > 10) || (truncl(arg1) < 100)) {}
+void test__std__ctime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ctime(arg1);
 }
 
-void test__truncl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = truncl(p);
-    // cppcheck-suppress memleak
+void test__std__ctime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::ctime(NULL);
 }
 
-void test__truncl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = truncl(x);
+void test__std__ctime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::ctime(x);
 }
 
-void test__std__truncl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::truncl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__difftime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = difftime(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__truncl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::truncl(arg1);
+void test__difftime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  difftime(arg1, arg2);
 }
 
-void test__std__truncl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::truncl(arg1) > 10) || (std::truncl(arg1) < 100)) {}
+void test__difftime__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = difftime(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__truncl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::truncl(x);
+void test__difftime__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = difftime(x, arg2);
 }
 
-void test__atanh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = atanh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__difftime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = difftime(arg1, x);
 }
 
-void test__atanh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    atanh(arg1);
+void test__std__difftime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::difftime(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atanh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((atanh(arg1) > 10) || (atanh(arg1) < 100)) {}
+void test__std__difftime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::difftime(arg1, arg2);
 }
 
-void test__atanh__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = atanh(p);
-    // cppcheck-suppress memleak
+void test__std__difftime__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::difftime(x, arg2);
 }
 
-void test__atanh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = atanh(x);
+void test__std__difftime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::difftime(arg1, x);
 }
 
-void test__std__atanh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::atanh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__div__noreturn() {
+  int x = 1;
+  if (cond) { x=100; div(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__atanh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::atanh(arg1);
+void test__div__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((div(arg1, arg2) > 10) || (div(arg1, arg2) < 100)) {}
 }
 
-void test__std__atanh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::atanh(arg1) > 10) || (std::atanh(arg1) < 100)) {}
+void test__div__leakignore() {
+  char *p = malloc(10); *p=0;
+  div(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__atanh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::atanh(x);
+void test__div__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  div(x, arg2);
 }
 
-void test__atanhf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = atanhf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__div__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  div(arg1, x);
 }
 
-void test__atanhf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    atanhf(arg1);
+void test__std__div__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::div(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atanhf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((atanhf(arg1) > 10) || (atanhf(arg1) < 100)) {}
+void test__std__div__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::div(arg1, arg2) > 10) || (std::div(arg1, arg2) < 100)) {}
 }
 
-void test__atanhf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = atanhf(p);
-    // cppcheck-suppress memleak
+void test__std__div__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::div(x, arg2);
 }
 
-void test__atanhf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = atanhf(x);
+void test__std__div__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::div(arg1, x);
 }
 
-void test__std__atanhf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::atanhf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__imaxdiv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; imaxdiv(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__atanhf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::atanhf(arg1);
+void test__imaxdiv__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((imaxdiv(arg1, arg2) > 10) || (imaxdiv(arg1, arg2) < 100)) {}
 }
 
-void test__std__atanhf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::atanhf(arg1) > 10) || (std::atanhf(arg1) < 100)) {}
+void test__imaxdiv__leakignore() {
+  char *p = malloc(10); *p=0;
+  imaxdiv(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__atanhf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::atanhf(x);
+void test__imaxdiv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  imaxdiv(x, arg2);
 }
 
-void test__atanhl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = atanhl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__imaxdiv__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  imaxdiv(arg1, x);
 }
 
-void test__atanhl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    atanhl(arg1);
+void test__std__imaxdiv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::imaxdiv(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atanhl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((atanhl(arg1) > 10) || (atanhl(arg1) < 100)) {}
+void test__std__imaxdiv__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::imaxdiv(arg1, arg2) > 10) || (std::imaxdiv(arg1, arg2) < 100)) {}
 }
 
-void test__atanhl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = atanhl(p);
-    // cppcheck-suppress memleak
+void test__std__imaxdiv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::imaxdiv(x, arg2);
 }
 
-void test__atanhl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = atanhl(x);
+void test__std__imaxdiv__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::imaxdiv(arg1, x);
 }
 
-void test__std__atanhl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::atanhl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__exit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; exit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__atanhl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::atanhl(arg1);
+void test__exit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  exit(x);
 }
 
-void test__std__atanhl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::atanhl(arg1) > 10) || (std::atanhl(arg1) < 100)) {}
+void test__std__exit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::exit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__atanhl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::atanhl(x);
+void test__std__exit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::exit(x);
 }
 
-void test__catanh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = catanh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__erf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = erf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__catanh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    catanh(arg1);
+void test__erf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  erf(arg1);
 }
 
-void test__catanh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((catanh(arg1) > 10) || (catanh(arg1) < 100)) {}
+void test__erf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((erf(arg1) > 10) || (erf(arg1) < 100)) {}
 }
 
-void test__catanh__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = catanh(p);
-    // cppcheck-suppress memleak
+void test__erf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = erf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__catanh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = catanh(x);
+void test__erf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = erf(x);
 }
 
-void test__catanhf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = catanhf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__erf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::erf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__catanhf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    catanhf(arg1);
+void test__std__erf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::erf(arg1);
 }
 
-void test__catanhf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((catanhf(arg1) > 10) || (catanhf(arg1) < 100)) {}
+void test__std__erf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::erf(arg1) > 10) || (std::erf(arg1) < 100)) {}
 }
 
-void test__catanhf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = catanhf(p);
-    // cppcheck-suppress memleak
+void test__std__erf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::erf(x);
 }
 
-void test__catanhf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = catanhf(x);
+void test__erff__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = erff(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__catanhl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = catanhl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__erff__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  erff(arg1);
 }
 
-void test__catanhl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    catanhl(arg1);
+void test__erff__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((erff(arg1) > 10) || (erff(arg1) < 100)) {}
 }
 
-void test__catanhl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((catanhl(arg1) > 10) || (catanhl(arg1) < 100)) {}
+void test__erff__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = erff(p);
+  // cppcheck-suppress memleak
 }
 
-void test__catanhl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = catanhl(p);
-    // cppcheck-suppress memleak
+void test__erff__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = erff(x);
 }
 
-void test__catanhl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = catanhl(x);
+void test__std__erff__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::erff(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atan2__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = atan2(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__erff__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::erff(arg1);
 }
 
-void test__atan2__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    atan2(arg1, arg2);
+void test__std__erff__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::erff(arg1) > 10) || (std::erff(arg1) < 100)) {}
 }
 
-void test__atan2__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((atan2(arg1, arg2) > 10) || (atan2(arg1, arg2) < 100)) {}
+void test__std__erff__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::erff(x);
 }
 
-void test__atan2__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = atan2(p, arg2);
-    // cppcheck-suppress memleak
+void test__erfl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = erfl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atan2__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = atan2(x, arg2);
+void test__erfl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  erfl(arg1);
 }
 
-void test__atan2__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = atan2(arg1, x);
+void test__erfl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((erfl(arg1) > 10) || (erfl(arg1) < 100)) {}
 }
 
-void test__std__atan2__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::atan2(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__erfl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = erfl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__atan2__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::atan2(arg1, arg2);
+void test__erfl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = erfl(x);
 }
 
-void test__std__atan2__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::atan2(arg1, arg2) > 10) || (std::atan2(arg1, arg2) < 100)) {}
+void test__std__erfl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::erfl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__atan2__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::atan2(x, arg2);
+void test__std__erfl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::erfl(arg1);
 }
 
-void test__std__atan2__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::atan2(arg1, x);
+void test__std__erfl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::erfl(arg1) > 10) || (std::erfl(arg1) < 100)) {}
 }
 
-void test__atan2f__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = atan2f(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__erfl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::erfl(x);
 }
 
-void test__atan2f__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    atan2f(arg1, arg2);
+void test__erfc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = erfc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atan2f__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((atan2f(arg1, arg2) > 10) || (atan2f(arg1, arg2) < 100)) {}
+void test__erfc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  erfc(arg1);
 }
 
-void test__atan2f__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = atan2f(p, arg2);
-    // cppcheck-suppress memleak
+void test__erfc__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((erfc(arg1) > 10) || (erfc(arg1) < 100)) {}
 }
 
-void test__atan2f__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = atan2f(x, arg2);
+void test__erfc__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = erfc(p);
+  // cppcheck-suppress memleak
 }
 
-void test__atan2f__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = atan2f(arg1, x);
+void test__erfc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = erfc(x);
 }
 
-void test__std__atan2f__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::atan2f(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__erfc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::erfc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__atan2f__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::atan2f(arg1, arg2);
+void test__std__erfc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::erfc(arg1);
 }
 
-void test__std__atan2f__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::atan2f(arg1, arg2) > 10) || (std::atan2f(arg1, arg2) < 100)) {}
+void test__std__erfc__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::erfc(arg1) > 10) || (std::erfc(arg1) < 100)) {}
 }
 
-void test__std__atan2f__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::atan2f(x, arg2);
+void test__std__erfc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::erfc(x);
 }
 
-void test__std__atan2f__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::atan2f(arg1, x);
+void test__erfcf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = erfcf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atan2l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = atan2l(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__erfcf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  erfcf(arg1);
 }
 
-void test__atan2l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    atan2l(arg1, arg2);
+void test__erfcf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((erfcf(arg1) > 10) || (erfcf(arg1) < 100)) {}
 }
 
-void test__atan2l__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((atan2l(arg1, arg2) > 10) || (atan2l(arg1, arg2) < 100)) {}
+void test__erfcf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = erfcf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__atan2l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = atan2l(p, arg2);
-    // cppcheck-suppress memleak
+void test__erfcf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = erfcf(x);
 }
 
-void test__atan2l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = atan2l(x, arg2);
+void test__std__erfcf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::erfcf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atan2l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = atan2l(arg1, x);
+void test__std__erfcf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::erfcf(arg1);
 }
 
-void test__std__atan2l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::atan2l(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__erfcf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::erfcf(arg1) > 10) || (std::erfcf(arg1) < 100)) {}
 }
 
-void test__std__atan2l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::atan2l(arg1, arg2);
+void test__std__erfcf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::erfcf(x);
 }
 
-void test__std__atan2l__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::atan2l(arg1, arg2) > 10) || (std::atan2l(arg1, arg2) < 100)) {}
+void test__erfcl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = erfcl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__atan2l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::atan2l(x, arg2);
+void test__erfcl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  erfcl(arg1);
 }
 
-void test__std__atan2l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::atan2l(arg1, x);
+void test__erfcl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((erfcl(arg1) > 10) || (erfcl(arg1) < 100)) {}
 }
 
-void test__atexit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        atexit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__erfcl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = erfcl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__atexit__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((atexit(arg1) > 10) || (atexit(arg1) < 100)) {}
+void test__erfcl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = erfcl(x);
 }
 
-void test__atexit__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    atexit(p);
-    // cppcheck-suppress memleak
+void test__std__erfcl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::erfcl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atexit__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    atexit(NULL);
+void test__std__erfcl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::erfcl(arg1);
 }
 
-void test__std__atexit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::atexit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__erfcl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::erfcl(arg1) > 10) || (std::erfcl(arg1) < 100)) {}
 }
 
-void test__std__atexit__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::atexit(arg1) > 10) || (std::atexit(arg1) < 100)) {}
+void test__std__erfcl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::erfcl(x);
 }
 
-void test__std__atexit__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::atexit(NULL);
+void test__carg__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = carg(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atoi__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = atoi(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__carg__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  carg(arg1);
 }
 
-void test__atoi__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    atoi(arg1);
+void test__carg__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((carg(arg1) > 10) || (carg(arg1) < 100)) {}
 }
 
-void test__atoi__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((atoi(arg1) > 10) || (atoi(arg1) < 100)) {}
+void test__carg__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = carg(p);
+  // cppcheck-suppress memleak
 }
 
-void test__atoi__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = atoi(p);
-    // cppcheck-suppress memleak
+void test__carg__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = carg(x);
 }
 
-void test__atoi__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = atoi(NULL);
+void test__cargf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cargf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atoi__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = atoi(x);
+void test__cargf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cargf(arg1);
 }
 
-void test__std__atoi__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::atoi(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cargf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cargf(arg1) > 10) || (cargf(arg1) < 100)) {}
 }
 
-void test__std__atoi__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::atoi(arg1);
+void test__cargf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cargf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__atoi__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::atoi(arg1) > 10) || (std::atoi(arg1) < 100)) {}
+void test__cargf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cargf(x);
 }
 
-void test__std__atoi__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::atoi(NULL);
+void test__cargl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cargl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__atoi__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::atoi(x);
+void test__cargl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cargl(arg1);
 }
 
-void test__atol__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = atol(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cargl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cargl(arg1) > 10) || (cargl(arg1) < 100)) {}
 }
 
-void test__atol__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    atol(arg1);
+void test__cargl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cargl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__atol__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((atol(arg1) > 10) || (atol(arg1) < 100)) {}
+void test__cargl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cargl(x);
 }
 
-void test__atol__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = atol(p);
-    // cppcheck-suppress memleak
+void test__exp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = exp(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atol__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = atol(NULL);
+void test__exp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  exp(arg1);
 }
 
-void test__atol__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = atol(x);
+void test__exp__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((exp(arg1) > 10) || (exp(arg1) < 100)) {}
 }
 
-void test__std__atol__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::atol(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__exp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = exp(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__atol__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::atol(arg1);
+void test__exp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = exp(x);
 }
 
-void test__std__atol__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::atol(arg1) > 10) || (std::atol(arg1) < 100)) {}
+void test__std__exp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::exp(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__atol__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::atol(NULL);
+void test__std__exp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::exp(arg1);
 }
 
-void test__std__atol__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::atol(x);
+void test__std__exp__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::exp(arg1) > 10) || (std::exp(arg1) < 100)) {}
 }
 
-void test__atoll__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = atoll(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__exp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::exp(x);
 }
 
-void test__atoll__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    atoll(arg1);
+void test__expf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = expf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atoll__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((atoll(arg1) > 10) || (atoll(arg1) < 100)) {}
+void test__expf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  expf(arg1);
 }
 
-void test__atoll__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = atoll(p);
-    // cppcheck-suppress memleak
+void test__expf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((expf(arg1) > 10) || (expf(arg1) < 100)) {}
 }
 
-void test__atoll__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = atoll(NULL);
+void test__expf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = expf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__atoll__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = atoll(x);
+void test__expf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = expf(x);
 }
 
-void test__std__atoll__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::atoll(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__expf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::expf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__atoll__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::atoll(arg1);
+void test__std__expf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::expf(arg1);
 }
 
-void test__std__atoll__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::atoll(arg1) > 10) || (std::atoll(arg1) < 100)) {}
+void test__std__expf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::expf(arg1) > 10) || (std::expf(arg1) < 100)) {}
 }
 
-void test__std__atoll__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::atoll(NULL);
+void test__std__expf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::expf(x);
 }
 
-void test__std__atoll__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::atoll(x);
+void test__expl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = expl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = atof(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__expl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  expl(arg1);
 }
 
-void test__atof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    atof(arg1);
+void test__expl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((expl(arg1) > 10) || (expl(arg1) < 100)) {}
 }
 
-void test__atof__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((atof(arg1) > 10) || (atof(arg1) < 100)) {}
+void test__expl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = expl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__atof__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = atof(p);
-    // cppcheck-suppress memleak
+void test__expl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = expl(x);
 }
 
-void test__atof__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = atof(NULL);
+void test__std__expl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::expl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__atof__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = atof(x);
+void test__std__expl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::expl(arg1);
 }
 
-void test__std__atof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::atof(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__expl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::expl(arg1) > 10) || (std::expl(arg1) < 100)) {}
 }
 
-void test__std__atof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::atof(arg1);
+void test__std__expl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::expl(x);
 }
 
-void test__std__atof__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::atof(arg1) > 10) || (std::atof(arg1) < 100)) {}
+void test__cexp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cexp(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__atof__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::atof(NULL);
+void test__cexp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cexp(arg1);
 }
 
-void test__std__atof__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::atof(x);
+void test__cexp__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cexp(arg1) > 10) || (cexp(arg1) < 100)) {}
 }
 
-void test__calloc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = calloc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cexp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cexp(p);
+  // cppcheck-suppress memleak
 }
 
-void test__calloc__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    calloc(arg1, arg2);
+void test__cexp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cexp(x);
 }
 
-void test__calloc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = calloc(x, arg2);
+void test__cexpf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cexpf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__calloc__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = calloc(arg1, x);
+void test__cexpf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cexpf(arg1);
 }
 
-void test__ceil__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ceil(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cexpf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cexpf(arg1) > 10) || (cexpf(arg1) < 100)) {}
 }
 
-void test__ceil__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ceil(arg1);
+void test__cexpf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cexpf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ceil__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ceil(arg1) > 10) || (ceil(arg1) < 100)) {}
+void test__cexpf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cexpf(x);
 }
 
-void test__ceil__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ceil(p);
-    // cppcheck-suppress memleak
+void test__cexpl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cexpl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ceil__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ceil(x);
+void test__cexpl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cexpl(arg1);
 }
 
-void test__std__ceil__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ceil(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cexpl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cexpl(arg1) > 10) || (cexpl(arg1) < 100)) {}
 }
 
-void test__std__ceil__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ceil(arg1);
+void test__cexpl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cexpl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__ceil__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::ceil(arg1) > 10) || (std::ceil(arg1) < 100)) {}
+void test__cexpl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cexpl(x);
 }
 
-void test__std__ceil__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::ceil(x);
+void test__cimag__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cimag(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ceilf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ceilf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cimag__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cimag(arg1);
 }
 
-void test__ceilf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ceilf(arg1);
+void test__cimag__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cimag(arg1) > 10) || (cimag(arg1) < 100)) {}
 }
 
-void test__ceilf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ceilf(arg1) > 10) || (ceilf(arg1) < 100)) {}
+void test__cimag__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cimag(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ceilf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ceilf(p);
-    // cppcheck-suppress memleak
+void test__cimag__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cimag(x);
 }
 
-void test__ceilf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ceilf(x);
+void test__cimagf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cimagf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ceilf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ceilf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cimagf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cimagf(arg1);
 }
 
-void test__std__ceilf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ceilf(arg1);
+void test__cimagf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cimagf(arg1) > 10) || (cimagf(arg1) < 100)) {}
 }
 
-void test__std__ceilf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::ceilf(arg1) > 10) || (std::ceilf(arg1) < 100)) {}
+void test__cimagf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cimagf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__ceilf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::ceilf(x);
+void test__cimagf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cimagf(x);
 }
 
-void test__ceill__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ceill(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cimagl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cimagl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ceill__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ceill(arg1);
+void test__cimagl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cimagl(arg1);
 }
 
-void test__ceill__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ceill(arg1) > 10) || (ceill(arg1) < 100)) {}
+void test__cimagl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cimagl(arg1) > 10) || (cimagl(arg1) < 100)) {}
 }
 
-void test__ceill__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ceill(p);
-    // cppcheck-suppress memleak
+void test__cimagl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cimagl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ceill__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ceill(x);
+void test__cimagl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cimagl(x);
 }
 
-void test__std__ceill__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ceill(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__exp2__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = exp2(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ceill__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ceill(arg1);
+void test__exp2__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  exp2(arg1);
 }
 
-void test__std__ceill__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::ceill(arg1) > 10) || (std::ceill(arg1) < 100)) {}
+void test__exp2__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((exp2(arg1) > 10) || (exp2(arg1) < 100)) {}
 }
 
-void test__std__ceill__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::ceill(x);
+void test__exp2__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = exp2(p);
+  // cppcheck-suppress memleak
 }
 
-void test__copysign__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = copysign(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__exp2__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = exp2(x);
 }
 
-void test__copysign__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    copysign(arg1, arg2);
+void test__std__exp2__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::exp2(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__copysign__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((copysign(arg1, arg2) > 10) || (copysign(arg1, arg2) < 100)) {}
+void test__std__exp2__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::exp2(arg1);
 }
 
-void test__copysign__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = copysign(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__exp2__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::exp2(arg1) > 10) || (std::exp2(arg1) < 100)) {}
 }
 
-void test__copysign__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = copysign(x, arg2);
+void test__std__exp2__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::exp2(x);
 }
 
-void test__copysign__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = copysign(arg1, x);
+void test__exp2f__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = exp2f(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__copysign__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::copysign(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__exp2f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  exp2f(arg1);
 }
 
-void test__std__copysign__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::copysign(arg1, arg2);
+void test__exp2f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((exp2f(arg1) > 10) || (exp2f(arg1) < 100)) {}
 }
 
-void test__std__copysign__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::copysign(arg1, arg2) > 10) || (std::copysign(arg1, arg2) < 100)) {}
+void test__exp2f__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = exp2f(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__copysign__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::copysign(x, arg2);
+void test__exp2f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = exp2f(x);
 }
 
-void test__std__copysign__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::copysign(arg1, x);
+void test__std__exp2f__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::exp2f(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__copysignf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = copysignf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__exp2f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::exp2f(arg1);
 }
 
-void test__copysignf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    copysignf(arg1, arg2);
+void test__std__exp2f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::exp2f(arg1) > 10) || (std::exp2f(arg1) < 100)) {}
 }
 
-void test__copysignf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((copysignf(arg1, arg2) > 10) || (copysignf(arg1, arg2) < 100)) {}
+void test__std__exp2f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::exp2f(x);
 }
 
-void test__copysignf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = copysignf(p, arg2);
-    // cppcheck-suppress memleak
+void test__exp2l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = exp2l(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__copysignf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = copysignf(x, arg2);
+void test__exp2l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  exp2l(arg1);
 }
 
-void test__copysignf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = copysignf(arg1, x);
+void test__exp2l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((exp2l(arg1) > 10) || (exp2l(arg1) < 100)) {}
 }
 
-void test__std__copysignf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::copysignf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__exp2l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = exp2l(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__copysignf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::copysignf(arg1, arg2);
+void test__exp2l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = exp2l(x);
 }
 
-void test__std__copysignf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::copysignf(arg1, arg2) > 10) || (std::copysignf(arg1, arg2) < 100)) {}
+void test__std__exp2l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::exp2l(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__copysignf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::copysignf(x, arg2);
+void test__std__exp2l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::exp2l(arg1);
 }
 
-void test__std__copysignf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::copysignf(arg1, x);
+void test__std__exp2l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::exp2l(arg1) > 10) || (std::exp2l(arg1) < 100)) {}
 }
 
-void test__copysignl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = copysignl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__exp2l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::exp2l(x);
 }
 
-void test__copysignl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    copysignl(arg1, arg2);
+void test__expm1__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = expm1(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__copysignl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((copysignl(arg1, arg2) > 10) || (copysignl(arg1, arg2) < 100)) {}
+void test__expm1__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  expm1(arg1);
 }
 
-void test__copysignl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = copysignl(p, arg2);
-    // cppcheck-suppress memleak
+void test__expm1__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((expm1(arg1) > 10) || (expm1(arg1) < 100)) {}
 }
 
-void test__copysignl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = copysignl(x, arg2);
+void test__expm1__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = expm1(p);
+  // cppcheck-suppress memleak
 }
 
-void test__copysignl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = copysignl(arg1, x);
+void test__expm1__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = expm1(x);
 }
 
-void test__std__copysignl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::copysignl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__expm1__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::expm1(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__copysignl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::copysignl(arg1, arg2);
+void test__std__expm1__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::expm1(arg1);
 }
 
-void test__std__copysignl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::copysignl(arg1, arg2) > 10) || (std::copysignl(arg1, arg2) < 100)) {}
+void test__std__expm1__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::expm1(arg1) > 10) || (std::expm1(arg1) < 100)) {}
 }
 
-void test__std__copysignl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::copysignl(x, arg2);
+void test__std__expm1__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::expm1(x);
 }
 
-void test__std__copysignl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::copysignl(arg1, x);
+void test__expm1f__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = expm1f(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__clearerr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        clearerr(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__expm1f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  expm1f(arg1);
 }
 
-void test__clearerr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    clearerr(p);
-    // cppcheck-suppress memleak
+void test__expm1f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((expm1f(arg1) > 10) || (expm1f(arg1) < 100)) {}
 }
 
-void test__clearerr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    clearerr(NULL);
+void test__expm1f__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = expm1f(p);
+  // cppcheck-suppress memleak
 }
 
-void test__clearerr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    clearerr(x);
+void test__expm1f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = expm1f(x);
 }
 
-void test__std__clearerr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::clearerr(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__expm1f__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::expm1f(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__clearerr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::clearerr(NULL);
+void test__std__expm1f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::expm1f(arg1);
 }
 
-void test__std__clearerr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::clearerr(x);
+void test__std__expm1f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::expm1f(arg1) > 10) || (std::expm1f(arg1) < 100)) {}
 }
 
-void test__clock__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = clock();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__expm1f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::expm1f(x);
 }
 
-void test__clock__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    clock();
+void test__expm1l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = expm1l(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__clock__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = clock();
-    // cppcheck-suppress memleak
+void test__expm1l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  expm1l(arg1);
 }
 
-void test__cbrt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cbrt(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__expm1l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((expm1l(arg1) > 10) || (expm1l(arg1) < 100)) {}
 }
 
-void test__cbrt__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cbrt(arg1);
+void test__expm1l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = expm1l(p);
+  // cppcheck-suppress memleak
 }
 
-void test__cbrt__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cbrt(arg1) > 10) || (cbrt(arg1) < 100)) {}
+void test__expm1l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = expm1l(x);
 }
 
-void test__cbrt__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cbrt(p);
-    // cppcheck-suppress memleak
+void test__std__expm1l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::expm1l(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cbrt__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cbrt(x);
+void test__std__expm1l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::expm1l(arg1);
 }
 
-void test__std__cbrt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::cbrt(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__expm1l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::expm1l(arg1) > 10) || (std::expm1l(arg1) < 100)) {}
 }
 
-void test__std__cbrt__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::cbrt(arg1);
+void test__std__expm1l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::expm1l(x);
 }
 
-void test__std__cbrt__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::cbrt(arg1) > 10) || (std::cbrt(arg1) < 100)) {}
+void test___Exit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _Exit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__cbrt__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::cbrt(x);
+void test___Exit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _Exit(x);
 }
 
-void test__cbrtf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cbrtf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__quick_exit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; quick_exit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cbrtf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cbrtf(arg1);
+void test__quick_exit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  quick_exit(x);
 }
 
-void test__cbrtf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cbrtf(arg1) > 10) || (cbrtf(arg1) < 100)) {}
+void test__fabs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fabs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cbrtf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cbrtf(p);
-    // cppcheck-suppress memleak
+void test__fabs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fabs(arg1);
 }
 
-void test__cbrtf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cbrtf(x);
+void test__fabs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fabs(arg1) > 10) || (fabs(arg1) < 100)) {}
 }
 
-void test__std__cbrtf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::cbrtf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fabs__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fabs(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__cbrtf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::cbrtf(arg1);
+void test__fabs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fabs(x);
 }
 
-void test__std__cbrtf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::cbrtf(arg1) > 10) || (std::cbrtf(arg1) < 100)) {}
+void test__std__fabs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fabs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__cbrtf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::cbrtf(x);
+void test__std__fabs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fabs(arg1);
 }
 
-void test__cbrtl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cbrtl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fabs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fabs(arg1) > 10) || (std::fabs(arg1) < 100)) {}
 }
 
-void test__cbrtl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cbrtl(arg1);
+void test__std__fabs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fabs(x);
 }
 
-void test__cbrtl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cbrtl(arg1) > 10) || (cbrtl(arg1) < 100)) {}
+void test__fabsf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fabsf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cbrtl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cbrtl(p);
-    // cppcheck-suppress memleak
+void test__fabsf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fabsf(arg1);
 }
 
-void test__cbrtl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cbrtl(x);
+void test__fabsf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fabsf(arg1) > 10) || (fabsf(arg1) < 100)) {}
 }
 
-void test__std__cbrtl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::cbrtl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fabsf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fabsf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__cbrtl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::cbrtl(arg1);
+void test__fabsf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fabsf(x);
 }
 
-void test__std__cbrtl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::cbrtl(arg1) > 10) || (std::cbrtl(arg1) < 100)) {}
+void test__std__fabsf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fabsf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__cbrtl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::cbrtl(x);
+void test__std__fabsf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fabsf(arg1);
 }
 
-void test__cos__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cos(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fabsf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fabsf(arg1) > 10) || (std::fabsf(arg1) < 100)) {}
 }
 
-void test__cos__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cos(arg1);
+void test__std__fabsf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fabsf(x);
 }
 
-void test__cos__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cos(arg1) > 10) || (cos(arg1) < 100)) {}
+void test__fabsl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fabsl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cos__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cos(p);
-    // cppcheck-suppress memleak
+void test__fabsl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fabsl(arg1);
 }
 
-void test__cos__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cos(x);
+void test__fabsl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fabsl(arg1) > 10) || (fabsl(arg1) < 100)) {}
 }
 
-void test__std__cos__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::cos(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fabsl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fabsl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__cos__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::cos(arg1);
+void test__fabsl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fabsl(x);
 }
 
-void test__std__cos__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::cos(arg1) > 10) || (std::cos(arg1) < 100)) {}
+void test__std__fabsl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fabsl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__cos__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::cos(x);
+void test__std__fabsl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fabsl(arg1);
 }
 
-void test__cosf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cosf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fabsl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fabsl(arg1) > 10) || (std::fabsl(arg1) < 100)) {}
 }
 
-void test__cosf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cosf(arg1);
+void test__std__fabsl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fabsl(x);
 }
 
-void test__cosf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cosf(arg1) > 10) || (cosf(arg1) < 100)) {}
+void test__fdim__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fdim(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cosf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cosf(p);
-    // cppcheck-suppress memleak
+void test__fdim__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fdim(arg1, arg2);
 }
 
-void test__cosf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cosf(x);
+void test__fdim__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fdim(arg1, arg2) > 10) || (fdim(arg1, arg2) < 100)) {}
 }
 
-void test__std__cosf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::cosf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fdim__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fdim(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__cosf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::cosf(arg1);
+void test__fdim__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdim(x, arg2);
 }
 
-void test__std__cosf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::cosf(arg1) > 10) || (std::cosf(arg1) < 100)) {}
+void test__fdim__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdim(arg1, x);
 }
 
-void test__std__cosf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::cosf(x);
+void test__std__fdim__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fdim(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cosl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cosl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fdim__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fdim(arg1, arg2);
 }
 
-void test__cosl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cosl(arg1);
+void test__std__fdim__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fdim(arg1, arg2) > 10) || (std::fdim(arg1, arg2) < 100)) {}
 }
 
-void test__cosl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cosl(arg1) > 10) || (cosl(arg1) < 100)) {}
+void test__std__fdim__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fdim(x, arg2);
 }
 
-void test__cosl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cosl(p);
-    // cppcheck-suppress memleak
+void test__std__fdim__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fdim(arg1, x);
 }
 
-void test__cosl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cosl(x);
+void test__fdimf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fdimf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__cosl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::cosl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fdimf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fdimf(arg1, arg2);
 }
 
-void test__std__cosl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::cosl(arg1);
+void test__fdimf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fdimf(arg1, arg2) > 10) || (fdimf(arg1, arg2) < 100)) {}
 }
 
-void test__std__cosl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::cosl(arg1) > 10) || (std::cosl(arg1) < 100)) {}
+void test__fdimf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fdimf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__cosl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::cosl(x);
+void test__fdimf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdimf(x, arg2);
 }
 
-void test__ccos__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ccos(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fdimf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdimf(arg1, x);
 }
 
-void test__ccos__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ccos(arg1);
+void test__std__fdimf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fdimf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ccos__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ccos(arg1) > 10) || (ccos(arg1) < 100)) {}
+void test__std__fdimf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fdimf(arg1, arg2);
 }
 
-void test__ccos__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ccos(p);
-    // cppcheck-suppress memleak
+void test__std__fdimf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fdimf(arg1, arg2) > 10) || (std::fdimf(arg1, arg2) < 100)) {}
 }
 
-void test__ccos__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ccos(x);
+void test__std__fdimf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fdimf(x, arg2);
 }
 
-void test__ccosf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ccosf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fdimf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fdimf(arg1, x);
 }
 
-void test__ccosf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ccosf(arg1);
+void test__fdiml__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fdiml(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ccosf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ccosf(arg1) > 10) || (ccosf(arg1) < 100)) {}
+void test__fdiml__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fdiml(arg1, arg2);
 }
 
-void test__ccosf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ccosf(p);
-    // cppcheck-suppress memleak
+void test__fdiml__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fdiml(arg1, arg2) > 10) || (fdiml(arg1, arg2) < 100)) {}
 }
 
-void test__ccosf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ccosf(x);
+void test__fdiml__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fdiml(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__ccosl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ccosl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fdiml__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdiml(x, arg2);
 }
 
-void test__ccosl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ccosl(arg1);
+void test__fdiml__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdiml(arg1, x);
 }
 
-void test__ccosl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ccosl(arg1) > 10) || (ccosl(arg1) < 100)) {}
+void test__std__fdiml__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fdiml(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ccosl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ccosl(p);
-    // cppcheck-suppress memleak
+void test__std__fdiml__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fdiml(arg1, arg2);
 }
 
-void test__ccosl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ccosl(x);
+void test__std__fdiml__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fdiml(arg1, arg2) > 10) || (std::fdiml(arg1, arg2) < 100)) {}
 }
 
-void test__cosh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cosh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fdiml__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fdiml(x, arg2);
 }
 
-void test__cosh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cosh(arg1);
+void test__std__fdiml__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fdiml(arg1, x);
 }
 
-void test__cosh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cosh(arg1) > 10) || (cosh(arg1) < 100)) {}
+void test__fclose__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fclose(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cosh__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cosh(p);
-    // cppcheck-suppress memleak
+void test__fclose__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fclose(NULL);
 }
 
-void test__cosh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cosh(x);
+void test__fclose__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fclose(x);
 }
 
-void test__std__cosh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::cosh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fclose__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fclose(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__cosh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::cosh(arg1);
+void test__std__fclose__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fclose(NULL);
 }
 
-void test__std__cosh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::cosh(arg1) > 10) || (std::cosh(arg1) < 100)) {}
+void test__std__fclose__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fclose(x);
 }
 
-void test__std__cosh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::cosh(x);
+void test__feof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = feof(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__coshf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = coshf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__feof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  feof(arg1);
 }
 
-void test__coshf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    coshf(arg1);
+void test__feof__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = feof(p);
+  // cppcheck-suppress memleak
 }
 
-void test__coshf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((coshf(arg1) > 10) || (coshf(arg1) < 100)) {}
+void test__feof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = feof(NULL);
 }
 
-void test__coshf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = coshf(p);
-    // cppcheck-suppress memleak
+void test__feof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = feof(x);
 }
 
-void test__coshf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = coshf(x);
+void test__std__feof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::feof(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__coshf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::coshf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__feof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::feof(arg1);
 }
 
-void test__std__coshf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::coshf(arg1);
+void test__std__feof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::feof(NULL);
 }
 
-void test__std__coshf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::coshf(arg1) > 10) || (std::coshf(arg1) < 100)) {}
+void test__std__feof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::feof(x);
 }
 
-void test__std__coshf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::coshf(x);
+void test__ferror__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ferror(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__coshl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = coshl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ferror__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ferror(arg1);
 }
 
-void test__coshl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    coshl(arg1);
+void test__ferror__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ferror(p);
+  // cppcheck-suppress memleak
 }
 
-void test__coshl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((coshl(arg1) > 10) || (coshl(arg1) < 100)) {}
+void test__ferror__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = ferror(NULL);
 }
 
-void test__coshl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = coshl(p);
-    // cppcheck-suppress memleak
+void test__ferror__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = ferror(x);
 }
 
-void test__coshl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = coshl(x);
+void test__std__ferror__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ferror(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__coshl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::coshl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ferror__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ferror(arg1);
 }
 
-void test__std__coshl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::coshl(arg1);
+void test__std__ferror__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::ferror(NULL);
 }
 
-void test__std__coshl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::coshl(arg1) > 10) || (std::coshl(arg1) < 100)) {}
+void test__std__ferror__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::ferror(x);
 }
 
-void test__std__coshl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::coshl(x);
+void test__fflush__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fflush(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ccosh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ccosh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fflush__leakignore() {
+  char *p = malloc(10); *p=0;
+  fflush(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ccosh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ccosh(arg1);
+void test__fflush__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fflush(x);
 }
 
-void test__ccosh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ccosh(arg1) > 10) || (ccosh(arg1) < 100)) {}
+void test__std__fflush__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fflush(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ccosh__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ccosh(p);
-    // cppcheck-suppress memleak
+void test__std__fflush__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fflush(x);
 }
 
-void test__ccosh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ccosh(x);
+void test__fgetc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fgetc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ccoshf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ccoshf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fgetc__leakignore() {
+  char *p = malloc(10); *p=0;
+  fgetc(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ccoshf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ccoshf(arg1);
+void test__fgetc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fgetc(NULL);
 }
 
-void test__ccoshf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ccoshf(arg1) > 10) || (ccoshf(arg1) < 100)) {}
+void test__fgetc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fgetc(x);
 }
 
-void test__ccoshf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ccoshf(p);
-    // cppcheck-suppress memleak
+void test__std__fgetc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fgetc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ccoshf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ccoshf(x);
+void test__std__fgetc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgetc(NULL);
 }
 
-void test__ccoshl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ccoshl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fgetc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fgetc(x);
 }
 
-void test__ccoshl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ccoshl(arg1);
+void test__getc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ccoshl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ccoshl(arg1) > 10) || (ccoshl(arg1) < 100)) {}
+void test__getc__leakignore() {
+  char *p = malloc(10); *p=0;
+  getc(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ccoshl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ccoshl(p);
-    // cppcheck-suppress memleak
+void test__getc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getc(NULL);
 }
 
-void test__ccoshl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ccoshl(x);
+void test__getc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getc(x);
 }
 
-void test__ctime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ctime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__getc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::getc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ctime__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ctime(arg1);
+void test__std__getc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::getc(NULL);
 }
 
-void test__ctime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ctime(p);
-    // cppcheck-suppress memleak
+void test__std__getc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::getc(x);
 }
 
-void test__ctime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = ctime(NULL);
+void test__fgetwc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fgetwc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ctime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = ctime(x);
+void test__fgetwc__leakignore() {
+  char *p = malloc(10); *p=0;
+  fgetwc(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__ctime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ctime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fgetwc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fgetwc(NULL);
 }
 
-void test__std__ctime__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ctime(arg1);
+void test__fgetwc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fgetwc(x);
 }
 
-void test__std__ctime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::ctime(NULL);
+void test__std__fgetwc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fgetwc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ctime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::ctime(x);
+void test__std__fgetwc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgetwc(NULL);
 }
 
-void test__difftime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = difftime(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fgetwc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fgetwc(x);
 }
 
-void test__difftime__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    difftime(arg1, arg2);
+void test__getwc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getwc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__difftime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = difftime(p, arg2);
-    // cppcheck-suppress memleak
+void test__getwc__leakignore() {
+  char *p = malloc(10); *p=0;
+  getwc(p);
+  // cppcheck-suppress memleak
 }
 
-void test__difftime__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = difftime(x, arg2);
+void test__getwc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getwc(NULL);
 }
 
-void test__difftime__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = difftime(arg1, x);
+void test__getwc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getwc(x);
 }
 
-void test__std__difftime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::difftime(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__getwc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::getwc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__difftime__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::difftime(arg1, arg2);
+void test__std__getwc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::getwc(NULL);
 }
 
-void test__std__difftime__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::difftime(x, arg2);
+void test__std__getwc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::getwc(x);
 }
 
-void test__std__difftime__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::difftime(arg1, x);
+void test__fgetpos__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fgetpos(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__div__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        div(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fgetpos__leakignore() {
+  char *p = malloc(10); *p=0;
+  fgetpos(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__div__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((div(arg1, arg2) > 10) || (div(arg1, arg2) < 100)) {}
+void test__fgetpos__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fgetpos(NULL, arg2);
 }
 
-void test__div__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    div(p, arg2);
-    // cppcheck-suppress memleak
+void test__fgetpos__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fgetpos(x, arg2);
 }
 
-void test__div__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    div(x, arg2);
+void test__fgetpos__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fgetpos(arg1, NULL);
 }
 
-void test__div__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    div(arg1, x);
+void test__std__fgetpos__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fgetpos(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__div__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::div(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fgetpos__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgetpos(NULL, arg2);
 }
 
-void test__std__div__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::div(arg1, arg2) > 10) || (std::div(arg1, arg2) < 100)) {}
+void test__std__fgetpos__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fgetpos(x, arg2);
 }
 
-void test__std__div__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::div(x, arg2);
+void test__std__fgetpos__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgetpos(arg1, NULL);
 }
 
-void test__std__div__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::div(arg1, x);
+void test__floor__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = floor(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__imaxdiv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        imaxdiv(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__floor__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  floor(arg1);
 }
 
-void test__imaxdiv__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((imaxdiv(arg1, arg2) > 10) || (imaxdiv(arg1, arg2) < 100)) {}
+void test__floor__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((floor(arg1) > 10) || (floor(arg1) < 100)) {}
 }
 
-void test__imaxdiv__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    imaxdiv(p, arg2);
-    // cppcheck-suppress memleak
+void test__floor__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = floor(p);
+  // cppcheck-suppress memleak
 }
 
-void test__imaxdiv__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    imaxdiv(x, arg2);
+void test__floor__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = floor(x);
 }
 
-void test__imaxdiv__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    imaxdiv(arg1, x);
+void test__std__floor__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::floor(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__imaxdiv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::imaxdiv(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__floor__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::floor(arg1);
 }
 
-void test__std__imaxdiv__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::imaxdiv(arg1, arg2) > 10) || (std::imaxdiv(arg1, arg2) < 100)) {}
+void test__std__floor__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::floor(arg1) > 10) || (std::floor(arg1) < 100)) {}
 }
 
-void test__std__imaxdiv__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::imaxdiv(x, arg2);
+void test__std__floor__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::floor(x);
 }
 
-void test__std__imaxdiv__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::imaxdiv(arg1, x);
+void test__floorf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = floorf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__exit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        exit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__floorf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  floorf(arg1);
 }
 
-void test__exit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    exit(x);
+void test__floorf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((floorf(arg1) > 10) || (floorf(arg1) < 100)) {}
 }
 
-void test__std__exit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::exit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__floorf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = floorf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__exit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::exit(x);
+void test__floorf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = floorf(x);
 }
 
-void test__erf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = erf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__floorf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::floorf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__erf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    erf(arg1);
+void test__std__floorf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::floorf(arg1);
 }
 
-void test__erf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((erf(arg1) > 10) || (erf(arg1) < 100)) {}
+void test__std__floorf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::floorf(arg1) > 10) || (std::floorf(arg1) < 100)) {}
 }
 
-void test__erf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = erf(p);
-    // cppcheck-suppress memleak
+void test__std__floorf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::floorf(x);
 }
 
-void test__erf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = erf(x);
+void test__floorl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = floorl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__erf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::erf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__floorl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  floorl(arg1);
 }
 
-void test__std__erf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::erf(arg1);
+void test__floorl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((floorl(arg1) > 10) || (floorl(arg1) < 100)) {}
 }
 
-void test__std__erf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::erf(arg1) > 10) || (std::erf(arg1) < 100)) {}
+void test__floorl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = floorl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__erf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::erf(x);
+void test__floorl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = floorl(x);
 }
 
-void test__erff__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = erff(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__floorl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::floorl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__erff__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    erff(arg1);
+void test__std__floorl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::floorl(arg1);
 }
 
-void test__erff__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((erff(arg1) > 10) || (erff(arg1) < 100)) {}
+void test__std__floorl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::floorl(arg1) > 10) || (std::floorl(arg1) < 100)) {}
 }
 
-void test__erff__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = erff(p);
-    // cppcheck-suppress memleak
+void test__std__floorl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::floorl(x);
 }
 
-void test__erff__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = erff(x);
+void test__fma__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fma(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__erff__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::erff(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fma__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fma(arg1, arg2, arg3);
 }
 
-void test__std__erff__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::erff(arg1);
+void test__fma__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fma(arg1, arg2, arg3) > 10) || (fma(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__erff__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::erff(arg1) > 10) || (std::erff(arg1) < 100)) {}
+void test__fma__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fma(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__erff__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::erff(x);
+void test__fma__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fma(x, arg2, arg3);
 }
 
-void test__erfl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = erfl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fma__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fma(arg1, x, arg3);
 }
 
-void test__erfl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    erfl(arg1);
+void test__fma__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fma(arg1, arg2, x);
 }
 
-void test__erfl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((erfl(arg1) > 10) || (erfl(arg1) < 100)) {}
+void test__std__fma__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fma(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__erfl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = erfl(p);
-    // cppcheck-suppress memleak
+void test__std__fma__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fma(arg1, arg2, arg3);
 }
 
-void test__erfl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = erfl(x);
+void test__std__fma__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fma(arg1, arg2, arg3) > 10) || (std::fma(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__erfl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::erfl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fma__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fma(x, arg2, arg3);
 }
 
-void test__std__erfl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::erfl(arg1);
+void test__std__fma__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fma(arg1, x, arg3);
 }
 
-void test__std__erfl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::erfl(arg1) > 10) || (std::erfl(arg1) < 100)) {}
+void test__std__fma__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fma(arg1, arg2, x);
 }
 
-void test__std__erfl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::erfl(x);
+void test__fmaf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fmaf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__erfc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = erfc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fmaf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmaf(arg1, arg2, arg3);
 }
 
-void test__erfc__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    erfc(arg1);
+void test__fmaf__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmaf(arg1, arg2, arg3) > 10) || (fmaf(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__erfc__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((erfc(arg1) > 10) || (erfc(arg1) < 100)) {}
+void test__fmaf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fmaf(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__erfc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = erfc(p);
-    // cppcheck-suppress memleak
+void test__fmaf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmaf(x, arg2, arg3);
 }
 
-void test__erfc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = erfc(x);
+void test__fmaf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmaf(arg1, x, arg3);
 }
 
-void test__std__erfc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::erfc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fmaf__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmaf(arg1, arg2, x);
 }
 
-void test__std__erfc__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::erfc(arg1);
+void test__std__fmaf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fmaf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__erfc__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::erfc(arg1) > 10) || (std::erfc(arg1) < 100)) {}
+void test__std__fmaf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmaf(arg1, arg2, arg3);
 }
 
-void test__std__erfc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::erfc(x);
+void test__std__fmaf__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fmaf(arg1, arg2, arg3) > 10) || (std::fmaf(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__erfcf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = erfcf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fmaf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmaf(x, arg2, arg3);
 }
 
-void test__erfcf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    erfcf(arg1);
+void test__std__fmaf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmaf(arg1, x, arg3);
 }
 
-void test__erfcf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((erfcf(arg1) > 10) || (erfcf(arg1) < 100)) {}
+void test__std__fmaf__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmaf(arg1, arg2, x);
 }
 
-void test__erfcf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = erfcf(p);
-    // cppcheck-suppress memleak
+void test__fmal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fmal(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__erfcf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = erfcf(x);
+void test__fmal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmal(arg1, arg2, arg3);
 }
 
-void test__std__erfcf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::erfcf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fmal__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmal(arg1, arg2, arg3) > 10) || (fmal(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__erfcf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::erfcf(arg1);
+void test__fmal__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fmal(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__erfcf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::erfcf(arg1) > 10) || (std::erfcf(arg1) < 100)) {}
+void test__fmal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmal(x, arg2, arg3);
 }
 
-void test__std__erfcf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::erfcf(x);
+void test__fmal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmal(arg1, x, arg3);
 }
 
-void test__erfcl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = erfcl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fmal__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmal(arg1, arg2, x);
 }
 
-void test__erfcl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    erfcl(arg1);
+void test__std__fmal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fmal(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__erfcl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((erfcl(arg1) > 10) || (erfcl(arg1) < 100)) {}
+void test__std__fmal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmal(arg1, arg2, arg3);
 }
 
-void test__erfcl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = erfcl(p);
-    // cppcheck-suppress memleak
+void test__std__fmal__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fmal(arg1, arg2, arg3) > 10) || (std::fmal(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__erfcl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = erfcl(x);
+void test__std__fmal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmal(x, arg2, arg3);
 }
 
-void test__std__erfcl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::erfcl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fmal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmal(arg1, x, arg3);
 }
 
-void test__std__erfcl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::erfcl(arg1);
+void test__std__fmal__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmal(arg1, arg2, x);
 }
 
-void test__std__erfcl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::erfcl(arg1) > 10) || (std::erfcl(arg1) < 100)) {}
+void test__fmax__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fmax(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__erfcl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::erfcl(x);
+void test__fmax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmax(arg1, arg2);
 }
 
-void test__carg__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = carg(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fmax__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmax(arg1, arg2) > 10) || (fmax(arg1, arg2) < 100)) {}
 }
 
-void test__carg__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    carg(arg1);
+void test__fmax__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fmax(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__carg__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((carg(arg1) > 10) || (carg(arg1) < 100)) {}
+void test__fmax__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmax(x, arg2);
 }
 
-void test__carg__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = carg(p);
-    // cppcheck-suppress memleak
+void test__fmax__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmax(arg1, x);
 }
 
-void test__carg__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = carg(x);
+void test__std__fmax__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fmax(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cargf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cargf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fmax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmax(arg1, arg2);
 }
 
-void test__cargf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cargf(arg1);
+void test__std__fmax__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fmax(arg1, arg2) > 10) || (std::fmax(arg1, arg2) < 100)) {}
 }
 
-void test__cargf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cargf(arg1) > 10) || (cargf(arg1) < 100)) {}
+void test__std__fmax__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmax(x, arg2);
 }
 
-void test__cargf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cargf(p);
-    // cppcheck-suppress memleak
+void test__std__fmax__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmax(arg1, x);
 }
 
-void test__cargf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cargf(x);
+void test__fmaxf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fmaxf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cargl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cargl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fmaxf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmaxf(arg1, arg2);
 }
 
-void test__cargl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cargl(arg1);
+void test__fmaxf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmaxf(arg1, arg2) > 10) || (fmaxf(arg1, arg2) < 100)) {}
 }
 
-void test__cargl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cargl(arg1) > 10) || (cargl(arg1) < 100)) {}
+void test__fmaxf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fmaxf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__cargl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cargl(p);
-    // cppcheck-suppress memleak
+void test__fmaxf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmaxf(x, arg2);
 }
 
-void test__cargl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cargl(x);
+void test__fmaxf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmaxf(arg1, x);
 }
 
-void test__exp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = exp(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fmaxf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fmaxf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__exp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    exp(arg1);
+void test__std__fmaxf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmaxf(arg1, arg2);
 }
 
-void test__exp__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((exp(arg1) > 10) || (exp(arg1) < 100)) {}
+void test__std__fmaxf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fmaxf(arg1, arg2) > 10) || (std::fmaxf(arg1, arg2) < 100)) {}
 }
 
-void test__exp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = exp(p);
-    // cppcheck-suppress memleak
+void test__std__fmaxf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmaxf(x, arg2);
 }
 
-void test__exp__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = exp(x);
+void test__std__fmaxf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmaxf(arg1, x);
 }
 
-void test__std__exp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::exp(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fmaxl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fmaxl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__exp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::exp(arg1);
+void test__fmaxl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmaxl(arg1, arg2);
 }
 
-void test__std__exp__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::exp(arg1) > 10) || (std::exp(arg1) < 100)) {}
+void test__fmaxl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmaxl(arg1, arg2) > 10) || (fmaxl(arg1, arg2) < 100)) {}
 }
 
-void test__std__exp__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::exp(x);
+void test__fmaxl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fmaxl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__expf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = expf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fmaxl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmaxl(x, arg2);
 }
 
-void test__expf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    expf(arg1);
+void test__fmaxl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmaxl(arg1, x);
 }
 
-void test__expf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((expf(arg1) > 10) || (expf(arg1) < 100)) {}
+void test__std__fmaxl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fmaxl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__expf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = expf(p);
-    // cppcheck-suppress memleak
+void test__std__fmaxl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmaxl(arg1, arg2);
 }
 
-void test__expf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = expf(x);
+void test__std__fmaxl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fmaxl(arg1, arg2) > 10) || (std::fmaxl(arg1, arg2) < 100)) {}
 }
 
-void test__std__expf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::expf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fmaxl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmaxl(x, arg2);
 }
 
-void test__std__expf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::expf(arg1);
+void test__std__fmaxl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmaxl(arg1, x);
 }
 
-void test__std__expf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::expf(arg1) > 10) || (std::expf(arg1) < 100)) {}
+void test__fmin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fmin(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__expf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::expf(x);
+void test__fmin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmin(arg1, arg2);
 }
 
-void test__expl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = expl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fmin__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmin(arg1, arg2) > 10) || (fmin(arg1, arg2) < 100)) {}
 }
 
-void test__expl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    expl(arg1);
+void test__fmin__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fmin(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__expl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((expl(arg1) > 10) || (expl(arg1) < 100)) {}
+void test__fmin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmin(x, arg2);
 }
 
-void test__expl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = expl(p);
-    // cppcheck-suppress memleak
+void test__fmin__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmin(arg1, x);
 }
 
-void test__expl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = expl(x);
+void test__std__fmin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fmin(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__expl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::expl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fmin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmin(arg1, arg2);
 }
 
-void test__std__expl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::expl(arg1);
+void test__std__fmin__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fmin(arg1, arg2) > 10) || (std::fmin(arg1, arg2) < 100)) {}
 }
 
-void test__std__expl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::expl(arg1) > 10) || (std::expl(arg1) < 100)) {}
+void test__std__fmin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmin(x, arg2);
 }
 
-void test__std__expl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::expl(x);
+void test__std__fmin__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmin(arg1, x);
 }
 
-void test__cexp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cexp(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fminf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fminf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cexp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cexp(arg1);
+void test__fminf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fminf(arg1, arg2);
 }
 
-void test__cexp__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cexp(arg1) > 10) || (cexp(arg1) < 100)) {}
+void test__fminf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fminf(arg1, arg2) > 10) || (fminf(arg1, arg2) < 100)) {}
 }
 
-void test__cexp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cexp(p);
-    // cppcheck-suppress memleak
+void test__fminf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fminf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__cexp__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cexp(x);
+void test__fminf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fminf(x, arg2);
 }
 
-void test__cexpf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cexpf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fminf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fminf(arg1, x);
 }
 
-void test__cexpf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cexpf(arg1);
+void test__std__fminf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fminf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cexpf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cexpf(arg1) > 10) || (cexpf(arg1) < 100)) {}
+void test__std__fminf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fminf(arg1, arg2);
 }
 
-void test__cexpf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cexpf(p);
-    // cppcheck-suppress memleak
+void test__std__fminf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fminf(arg1, arg2) > 10) || (std::fminf(arg1, arg2) < 100)) {}
 }
 
-void test__cexpf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cexpf(x);
+void test__std__fminf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fminf(x, arg2);
 }
 
-void test__cexpl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cexpl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fminf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fminf(arg1, x);
 }
 
-void test__cexpl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cexpl(arg1);
+void test__fminl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fminl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cexpl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cexpl(arg1) > 10) || (cexpl(arg1) < 100)) {}
+void test__fminl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fminl(arg1, arg2);
 }
 
-void test__cexpl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cexpl(p);
-    // cppcheck-suppress memleak
+void test__fminl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fminl(arg1, arg2) > 10) || (fminl(arg1, arg2) < 100)) {}
 }
 
-void test__cexpl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cexpl(x);
+void test__fminl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fminl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__cimag__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cimag(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fminl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fminl(x, arg2);
 }
 
-void test__cimag__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cimag(arg1);
+void test__fminl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fminl(arg1, x);
 }
 
-void test__cimag__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cimag(arg1) > 10) || (cimag(arg1) < 100)) {}
+void test__std__fminl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fminl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cimag__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cimag(p);
-    // cppcheck-suppress memleak
+void test__std__fminl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fminl(arg1, arg2);
 }
 
-void test__cimag__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cimag(x);
+void test__std__fminl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fminl(arg1, arg2) > 10) || (std::fminl(arg1, arg2) < 100)) {}
 }
 
-void test__cimagf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cimagf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fminl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fminl(x, arg2);
 }
 
-void test__cimagf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cimagf(arg1);
+void test__std__fminl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fminl(arg1, x);
 }
 
-void test__cimagf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cimagf(arg1) > 10) || (cimagf(arg1) < 100)) {}
+void test__fmod__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fmod(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cimagf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cimagf(p);
-    // cppcheck-suppress memleak
+void test__fmod__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmod(arg1, arg2);
 }
 
-void test__cimagf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cimagf(x);
+void test__fmod__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmod(arg1, arg2) > 10) || (fmod(arg1, arg2) < 100)) {}
 }
 
-void test__cimagl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cimagl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fmod__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fmod(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__cimagl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cimagl(arg1);
+void test__fmod__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmod(x, arg2);
 }
 
-void test__cimagl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cimagl(arg1) > 10) || (cimagl(arg1) < 100)) {}
+void test__fmod__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmod(arg1, x);
 }
 
-void test__cimagl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cimagl(p);
-    // cppcheck-suppress memleak
+void test__std__fmod__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fmod(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cimagl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cimagl(x);
+void test__std__fmod__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmod(arg1, arg2);
 }
 
-void test__exp2__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = exp2(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fmod__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fmod(arg1, arg2) > 10) || (std::fmod(arg1, arg2) < 100)) {}
 }
 
-void test__exp2__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    exp2(arg1);
+void test__std__fmod__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmod(x, arg2);
 }
 
-void test__exp2__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((exp2(arg1) > 10) || (exp2(arg1) < 100)) {}
+void test__std__fmod__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmod(arg1, x);
 }
 
-void test__exp2__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = exp2(p);
-    // cppcheck-suppress memleak
+void test__fmodf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fmodf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__exp2__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = exp2(x);
+void test__fmodf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmodf(arg1, arg2);
 }
 
-void test__std__exp2__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::exp2(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fmodf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmodf(arg1, arg2) > 10) || (fmodf(arg1, arg2) < 100)) {}
 }
 
-void test__std__exp2__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::exp2(arg1);
+void test__fmodf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fmodf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__exp2__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::exp2(arg1) > 10) || (std::exp2(arg1) < 100)) {}
+void test__fmodf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmodf(x, arg2);
 }
 
-void test__std__exp2__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::exp2(x);
+void test__fmodf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmodf(arg1, x);
 }
 
-void test__exp2f__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = exp2f(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fmodf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fmodf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__exp2f__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    exp2f(arg1);
+void test__std__fmodf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmodf(arg1, arg2);
 }
 
-void test__exp2f__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((exp2f(arg1) > 10) || (exp2f(arg1) < 100)) {}
+void test__std__fmodf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fmodf(arg1, arg2) > 10) || (std::fmodf(arg1, arg2) < 100)) {}
 }
 
-void test__exp2f__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = exp2f(p);
-    // cppcheck-suppress memleak
+void test__std__fmodf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmodf(x, arg2);
 }
 
-void test__exp2f__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = exp2f(x);
+void test__std__fmodf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmodf(arg1, x);
 }
 
-void test__std__exp2f__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::exp2f(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fmodl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fmodl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__exp2f__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::exp2f(arg1);
+void test__fmodl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmodl(arg1, arg2);
 }
 
-void test__std__exp2f__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::exp2f(arg1) > 10) || (std::exp2f(arg1) < 100)) {}
+void test__fmodl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmodl(arg1, arg2) > 10) || (fmodl(arg1, arg2) < 100)) {}
 }
 
-void test__std__exp2f__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::exp2f(x);
+void test__fmodl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fmodl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__exp2l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = exp2l(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fmodl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmodl(x, arg2);
 }
 
-void test__exp2l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    exp2l(arg1);
+void test__fmodl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmodl(arg1, x);
 }
 
-void test__exp2l__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((exp2l(arg1) > 10) || (exp2l(arg1) < 100)) {}
+void test__std__fmodl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fmodl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__exp2l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = exp2l(p);
-    // cppcheck-suppress memleak
+void test__std__fmodl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmodl(arg1, arg2);
 }
 
-void test__exp2l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = exp2l(x);
+void test__std__fmodl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fmodl(arg1, arg2) > 10) || (std::fmodl(arg1, arg2) < 100)) {}
 }
 
-void test__std__exp2l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::exp2l(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fmodl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmodl(x, arg2);
 }
 
-void test__std__exp2l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::exp2l(arg1);
+void test__std__fmodl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmodl(arg1, x);
 }
 
-void test__std__exp2l__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::exp2l(arg1) > 10) || (std::exp2l(arg1) < 100)) {}
+void test__fopen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fopen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__exp2l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::exp2l(x);
+void test__fopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fopen(arg1, arg2);
 }
 
-void test__expm1__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = expm1(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fopen(NULL, arg2);
 }
 
-void test__expm1__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    expm1(arg1);
+void test__fopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fopen(x, arg2);
 }
 
-void test__expm1__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((expm1(arg1) > 10) || (expm1(arg1) < 100)) {}
+void test__fopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fopen(arg1, NULL);
 }
 
-void test__expm1__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = expm1(p);
-    // cppcheck-suppress memleak
+void test__fopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fopen(arg1, x);
 }
 
-void test__expm1__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = expm1(x);
+void test__std__fopen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fopen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__expm1__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::expm1(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fopen(arg1, arg2);
 }
 
-void test__std__expm1__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::expm1(arg1);
+void test__std__fopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::fopen(NULL, arg2);
 }
 
-void test__std__expm1__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::expm1(arg1) > 10) || (std::expm1(arg1) < 100)) {}
+void test__std__fopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::fopen(x, arg2);
 }
 
-void test__std__expm1__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::expm1(x);
+void test__std__fopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::fopen(arg1, NULL);
 }
 
-void test__expm1f__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = expm1f(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::fopen(arg1, x);
 }
 
-void test__expm1f__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    expm1f(arg1);
+void test__fopen_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fopen_s(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__expm1f__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((expm1f(arg1) > 10) || (expm1f(arg1) < 100)) {}
+void test__fopen_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fopen_s(NULL, arg2, arg3);
 }
 
-void test__expm1f__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = expm1f(p);
-    // cppcheck-suppress memleak
+void test__fopen_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fopen_s(arg1, NULL, arg3);
 }
 
-void test__expm1f__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = expm1f(x);
+void test__fopen_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fopen_s(arg1, x, arg3);
 }
 
-void test__std__expm1f__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::expm1f(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fopen_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  fopen_s(arg1, arg2, NULL);
 }
 
-void test__std__expm1f__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::expm1f(arg1);
+void test__fopen_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fopen_s(arg1, arg2, x);
 }
 
-void test__std__expm1f__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::expm1f(arg1) > 10) || (std::expm1f(arg1) < 100)) {}
+void test__fprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fprintf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__expm1f__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::expm1f(x);
+void test__fprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  fprintf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__expm1l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = expm1l(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fprintf(NULL, arg2);
 }
 
-void test__expm1l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    expm1l(arg1);
+void test__fprintf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fprintf(x, arg2);
 }
 
-void test__expm1l__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((expm1l(arg1) > 10) || (expm1l(arg1) < 100)) {}
+void test__fprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fprintf(arg1, x);
 }
 
-void test__expm1l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = expm1l(p);
-    // cppcheck-suppress memleak
+void test__std__fprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fprintf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__expm1l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = expm1l(x);
+void test__std__fprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fprintf(NULL, arg2);
 }
 
-void test__std__expm1l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::expm1l(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fprintf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fprintf(x, arg2);
 }
 
-void test__std__expm1l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::expm1l(arg1);
+void test__std__fprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fprintf(arg1, x);
 }
 
-void test__std__expm1l__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::expm1l(arg1) > 10) || (std::expm1l(arg1) < 100)) {}
+void test__vfprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vfprintf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__expm1l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::expm1l(x);
+void test__vfprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  vfprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___Exit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _Exit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__vfprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vfprintf(NULL, arg2, arg3);
 }
 
-void test___Exit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _Exit(x);
+void test__vfprintf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vfprintf(x, arg2, arg3);
 }
 
-void test__quick_exit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        quick_exit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__vfprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vfprintf(arg1, x, arg3);
 }
 
-void test__quick_exit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    quick_exit(x);
+void test__std__vfprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vfprintf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fabs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fabs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vfprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vfprintf(NULL, arg2, arg3);
 }
 
-void test__fabs__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fabs(arg1);
+void test__std__vfprintf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vfprintf(x, arg2, arg3);
 }
 
-void test__fabs__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fabs(arg1) > 10) || (fabs(arg1) < 100)) {}
+void test__std__vfprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vfprintf(arg1, x, arg3);
 }
 
-void test__fabs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fabs(p);
-    // cppcheck-suppress memleak
+void test__vfwprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vfwprintf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fabs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fabs(x);
+void test__vfwprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  vfwprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fabs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fabs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__vfwprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vfwprintf(NULL, arg2, arg3);
 }
 
-void test__std__fabs__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fabs(arg1);
+void test__vfwprintf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vfwprintf(x, arg2, arg3);
 }
 
-void test__std__fabs__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fabs(arg1) > 10) || (std::fabs(arg1) < 100)) {}
+void test__vfwprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vfwprintf(arg1, x, arg3);
 }
 
-void test__std__fabs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fabs(x);
+void test__std__vfwprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vfwprintf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fabsf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fabsf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vfwprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vfwprintf(NULL, arg2, arg3);
 }
 
-void test__fabsf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fabsf(arg1);
+void test__std__vfwprintf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vfwprintf(x, arg2, arg3);
 }
 
-void test__fabsf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fabsf(arg1) > 10) || (fabsf(arg1) < 100)) {}
+void test__std__vfwprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vfwprintf(arg1, x, arg3);
 }
 
-void test__fabsf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fabsf(p);
-    // cppcheck-suppress memleak
+void test__fputc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fputc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fabsf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fabsf(x);
+void test__fputc__leakignore() {
+  char *p = malloc(10); *p=0;
+  fputc(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fabsf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fabsf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fputc__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  fputc(!x, arg2);
 }
 
-void test__std__fabsf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fabsf(arg1);
+void test__fputc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fputc(x, arg2);
 }
 
-void test__std__fabsf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fabsf(arg1) > 10) || (std::fabsf(arg1) < 100)) {}
+void test__fputc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fputc(arg1, NULL);
 }
 
-void test__std__fabsf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fabsf(x);
+void test__fputc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fputc(arg1, x);
 }
 
-void test__fabsl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fabsl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fputc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fputc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fabsl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fabsl(arg1);
+void test__std__fputc__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::fputc(!x, arg2);
 }
 
-void test__fabsl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fabsl(arg1) > 10) || (fabsl(arg1) < 100)) {}
+void test__std__fputc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fputc(x, arg2);
 }
 
-void test__fabsl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fabsl(p);
-    // cppcheck-suppress memleak
+void test__std__fputc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fputc(arg1, NULL);
 }
 
-void test__fabsl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fabsl(x);
+void test__std__fputc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fputc(arg1, x);
 }
 
-void test__std__fabsl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fabsl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fputwc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fputwc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fabsl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fabsl(arg1);
+void test__fputwc__leakignore() {
+  char *p = malloc(10); *p=0;
+  fputwc(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fabsl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fabsl(arg1) > 10) || (std::fabsl(arg1) < 100)) {}
+void test__fputwc__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  fputwc(!x, arg2);
 }
 
-void test__std__fabsl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fabsl(x);
+void test__fputwc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fputwc(x, arg2);
 }
 
-void test__fdim__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fdim(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fputwc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fputwc(arg1, NULL);
 }
 
-void test__fdim__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fdim(arg1, arg2);
+void test__fputwc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fputwc(arg1, x);
 }
 
-void test__fdim__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fdim(arg1, arg2) > 10) || (fdim(arg1, arg2) < 100)) {}
+void test__std__fputwc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fputwc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fdim__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fdim(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__fputwc__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::fputwc(!x, arg2);
 }
 
-void test__fdim__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fdim(x, arg2);
+void test__std__fputwc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fputwc(x, arg2);
 }
 
-void test__fdim__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fdim(arg1, x);
+void test__std__fputwc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fputwc(arg1, NULL);
 }
 
-void test__std__fdim__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fdim(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fputwc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fputwc(arg1, x);
 }
 
-void test__std__fdim__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fdim(arg1, arg2);
+void test__fputs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fputs(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fdim__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fdim(arg1, arg2) > 10) || (std::fdim(arg1, arg2) < 100)) {}
+void test__fputs__leakignore() {
+  char *p = malloc(10); *p=0;
+  fputs(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fdim__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fdim(x, arg2);
+void test__fputs__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fputs(NULL, arg2);
 }
 
-void test__std__fdim__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fdim(arg1, x);
+void test__fputs__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fputs(x, arg2);
 }
 
-void test__fdimf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fdimf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fputs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fputs(arg1, NULL);
 }
 
-void test__fdimf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fdimf(arg1, arg2);
+void test__fputs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fputs(arg1, x);
 }
 
-void test__fdimf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fdimf(arg1, arg2) > 10) || (fdimf(arg1, arg2) < 100)) {}
+void test__std__fputs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fputs(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fdimf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fdimf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__fputs__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fputs(NULL, arg2);
 }
 
-void test__fdimf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fdimf(x, arg2);
+void test__std__fputs__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fputs(x, arg2);
 }
 
-void test__fdimf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fdimf(arg1, x);
+void test__std__fputs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fputs(arg1, NULL);
 }
 
-void test__std__fdimf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fdimf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fputs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fputs(arg1, x);
 }
 
-void test__std__fdimf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fdimf(arg1, arg2);
+void test__fputws__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fputws(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fdimf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fdimf(arg1, arg2) > 10) || (std::fdimf(arg1, arg2) < 100)) {}
+void test__fputws__leakignore() {
+  char *p = malloc(10); *p=0;
+  fputws(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fdimf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fdimf(x, arg2);
+void test__fputws__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fputws(NULL, arg2);
 }
 
-void test__std__fdimf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fdimf(arg1, x);
+void test__fputws__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fputws(x, arg2);
 }
 
-void test__fdiml__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fdiml(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fputws__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fputws(arg1, NULL);
 }
 
-void test__fdiml__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fdiml(arg1, arg2);
+void test__fputws__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fputws(arg1, x);
 }
 
-void test__fdiml__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fdiml(arg1, arg2) > 10) || (fdiml(arg1, arg2) < 100)) {}
+void test__std__fputws__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fputws(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fdiml__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fdiml(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__fputws__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fputws(NULL, arg2);
 }
 
-void test__fdiml__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fdiml(x, arg2);
+void test__std__fputws__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fputws(x, arg2);
 }
 
-void test__fdiml__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fdiml(arg1, x);
+void test__std__fputws__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fputws(arg1, NULL);
 }
 
-void test__std__fdiml__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fdiml(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fputws__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fputws(arg1, x);
 }
 
-void test__std__fdiml__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fdiml(arg1, arg2);
+void test__fread__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fread(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fdiml__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fdiml(arg1, arg2) > 10) || (std::fdiml(arg1, arg2) < 100)) {}
+void test__fread__leakignore() {
+  char *p = malloc(10); *p=0;
+  fread(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fdiml__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fdiml(x, arg2);
+void test__fread__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fread(NULL, arg2, arg3, arg4);
 }
 
-void test__std__fdiml__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fdiml(arg1, x);
+void test__fread__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fread(arg1, x, arg3, arg4);
 }
 
-void test__fclose__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fclose(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fread__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fread(arg1, arg2, x, arg4);
 }
 
-void test__fclose__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fclose(NULL);
+void test__fread__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  fread(arg1, arg2, arg3, NULL);
 }
 
-void test__fclose__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fclose(x);
+void test__fread__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fread(arg1, arg2, arg3, x);
 }
 
-void test__std__fclose__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fclose(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fread__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fread(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fclose__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fclose(NULL);
+void test__std__fread__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fread(NULL, arg2, arg3, arg4);
 }
 
-void test__std__fclose__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fclose(x);
+void test__std__fread__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fread(arg1, x, arg3, arg4);
 }
 
-void test__feof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = feof(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fread__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fread(arg1, arg2, x, arg4);
 }
 
-void test__feof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    feof(arg1);
+void test__std__fread__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fread(arg1, arg2, arg3, NULL);
 }
 
-void test__feof__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = feof(p);
-    // cppcheck-suppress memleak
+void test__std__fread__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fread(arg1, arg2, arg3, x);
 }
 
-void test__feof__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = feof(NULL);
+void test__free__noreturn() {
+  int x = 1;
+  if (cond) { x=100; free(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__feof__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = feof(x);
+void test__free__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  free(x);
 }
 
-void test__std__feof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::feof(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__free__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::free(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__feof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::feof(arg1);
+void test__std__free__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::free(x);
 }
 
-void test__std__feof__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::feof(NULL);
+void test__freopen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = freopen(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__feof__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::feof(x);
+void test__freopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  freopen(arg1, arg2, arg3);
 }
 
-void test__ferror__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ferror(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__freopen__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = freopen(x, arg2, arg3);
 }
 
-void test__ferror__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ferror(arg1);
+void test__freopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = freopen(arg1, NULL, arg3);
 }
 
-void test__ferror__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ferror(p);
-    // cppcheck-suppress memleak
+void test__freopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = freopen(arg1, x, arg3);
 }
 
-void test__ferror__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = ferror(NULL);
+void test__freopen__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = freopen(arg1, arg2, NULL);
 }
 
-void test__ferror__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = ferror(x);
+void test__freopen__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = freopen(arg1, arg2, x);
 }
 
-void test__std__ferror__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ferror(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__freopen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::freopen(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ferror__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ferror(arg1);
+void test__std__freopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::freopen(arg1, arg2, arg3);
 }
 
-void test__std__ferror__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::ferror(NULL);
+void test__std__freopen__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::freopen(x, arg2, arg3);
 }
 
-void test__std__ferror__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::ferror(x);
+void test__std__freopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::freopen(arg1, NULL, arg3);
 }
 
-void test__fflush__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fflush(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__freopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::freopen(arg1, x, arg3);
 }
 
-void test__fflush__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fflush(p);
-    // cppcheck-suppress memleak
+void test__std__freopen__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::freopen(arg1, arg2, NULL);
 }
 
-void test__fflush__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fflush(x);
+void test__std__freopen__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::freopen(arg1, arg2, x);
 }
 
-void test__std__fflush__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fflush(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__freopen_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = freopen_s(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fflush__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fflush(x);
+void test__freopen_s__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  freopen_s(arg1, arg2, arg3, arg4);
 }
 
-void test__fgetc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fgetc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__freopen_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = freopen_s(x, arg2, arg3, arg4);
 }
 
-void test__fgetc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fgetc(p);
-    // cppcheck-suppress memleak
+void test__freopen_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = freopen_s(arg1, x, arg3, arg4);
 }
-
-void test__fgetc__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fgetc(NULL);
+
+void test__freopen_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = freopen_s(arg1, arg2, NULL, arg4);
 }
 
-void test__fgetc__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fgetc(x);
+void test__freopen_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = freopen_s(arg1, arg2, x, arg4);
 }
 
-void test__std__fgetc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fgetc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__freopen_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  result = freopen_s(arg1, arg2, arg3, NULL);
 }
 
-void test__std__fgetc__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fgetc(NULL);
+void test__freopen_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = freopen_s(arg1, arg2, arg3, x);
 }
-
-void test__std__fgetc__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fgetc(x);
+
+void test__frexp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; frexp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__getc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__frexp__leakignore() {
+  char *p = malloc(10); *p=0;
+  frexp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__getc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getc(p);
-    // cppcheck-suppress memleak
+void test__frexp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  frexp(x, arg2);
 }
-
-void test__getc__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getc(NULL);
+
+void test__frexp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  frexp(arg1, NULL);
 }
 
-void test__getc__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    getc(x);
+void test__std__frexp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::frexp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__getc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::getc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__frexp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::frexp(x, arg2);
 }
 
-void test__std__getc__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::getc(NULL);
+void test__std__frexp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::frexp(arg1, NULL);
 }
 
-void test__std__getc__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::getc(x);
+void test__frexpf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; frexpf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fgetwc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fgetwc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__frexpf__leakignore() {
+  char *p = malloc(10); *p=0;
+  frexpf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__fgetwc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fgetwc(p);
-    // cppcheck-suppress memleak
+void test__frexpf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  frexpf(x, arg2);
 }
 
-void test__fgetwc__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fgetwc(NULL);
+void test__frexpf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  frexpf(arg1, NULL);
 }
 
-void test__fgetwc__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fgetwc(x);
+void test__std__frexpf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::frexpf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fgetwc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fgetwc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__frexpf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::frexpf(x, arg2);
 }
 
-void test__std__fgetwc__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fgetwc(NULL);
+void test__std__frexpf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::frexpf(arg1, NULL);
 }
 
-void test__std__fgetwc__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fgetwc(x);
+void test__frexpl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; frexpl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getwc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getwc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__frexpl__leakignore() {
+  char *p = malloc(10); *p=0;
+  frexpl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__getwc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getwc(p);
-    // cppcheck-suppress memleak
+void test__frexpl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  frexpl(x, arg2);
 }
 
-void test__getwc__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getwc(NULL);
+void test__frexpl__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  frexpl(arg1, NULL);
 }
 
-void test__getwc__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    getwc(x);
+void test__std__frexpl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::frexpl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__getwc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::getwc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__frexpl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::frexpl(x, arg2);
 }
 
-void test__std__getwc__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::getwc(NULL);
+void test__std__frexpl__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::frexpl(arg1, NULL);
 }
 
-void test__std__getwc__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::getwc(x);
+void test__hypot__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = hypot(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fgetpos__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fgetpos(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__hypot__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  hypot(arg1, arg2, arg3);
 }
 
-void test__fgetpos__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fgetpos(p, arg2);
-    // cppcheck-suppress memleak
+void test__hypot__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((hypot(arg1, arg2, arg3) > 10) || (hypot(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__fgetpos__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fgetpos(NULL, arg2);
+void test__hypot__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = hypot(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__fgetpos__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fgetpos(x, arg2);
+void test__hypot__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = hypot(x, arg2, arg3);
 }
 
-void test__fgetpos__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fgetpos(arg1, NULL);
+void test__hypot__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = hypot(arg1, x, arg3);
 }
 
-void test__std__fgetpos__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fgetpos(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__hypot__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = hypot(arg1, arg2, x);
 }
 
-void test__std__fgetpos__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fgetpos(NULL, arg2);
+void test__std__hypot__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::hypot(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fgetpos__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fgetpos(x, arg2);
+void test__std__hypot__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::hypot(arg1, arg2, arg3);
 }
 
-void test__std__fgetpos__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fgetpos(arg1, NULL);
+void test__std__hypot__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::hypot(arg1, arg2, arg3) > 10) || (std::hypot(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__floor__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = floor(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__hypot__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::hypot(x, arg2, arg3);
 }
 
-void test__floor__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    floor(arg1);
+void test__std__hypot__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::hypot(arg1, x, arg3);
 }
 
-void test__floor__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((floor(arg1) > 10) || (floor(arg1) < 100)) {}
+void test__std__hypot__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::hypot(arg1, arg2, x);
 }
 
-void test__floor__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = floor(p);
-    // cppcheck-suppress memleak
+void test__hypotf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = hypotf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__floor__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = floor(x);
+void test__hypotf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  hypotf(arg1, arg2);
 }
 
-void test__std__floor__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::floor(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__hypotf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((hypotf(arg1, arg2) > 10) || (hypotf(arg1, arg2) < 100)) {}
 }
 
-void test__std__floor__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::floor(arg1);
+void test__hypotf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = hypotf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__floor__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::floor(arg1) > 10) || (std::floor(arg1) < 100)) {}
+void test__hypotf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = hypotf(x, arg2);
 }
 
-void test__std__floor__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::floor(x);
+void test__hypotf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = hypotf(arg1, x);
 }
 
-void test__floorf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = floorf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__hypotf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::hypotf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__floorf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    floorf(arg1);
+void test__std__hypotf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::hypotf(arg1, arg2);
 }
 
-void test__floorf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((floorf(arg1) > 10) || (floorf(arg1) < 100)) {}
+void test__std__hypotf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::hypotf(arg1, arg2) > 10) || (std::hypotf(arg1, arg2) < 100)) {}
 }
 
-void test__floorf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = floorf(p);
-    // cppcheck-suppress memleak
+void test__std__hypotf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::hypotf(x, arg2);
 }
 
-void test__floorf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = floorf(x);
+void test__std__hypotf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::hypotf(arg1, x);
 }
 
-void test__std__floorf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::floorf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__hypotl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = hypotl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__floorf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::floorf(arg1);
+void test__hypotl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  hypotl(arg1, arg2);
 }
 
-void test__std__floorf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::floorf(arg1) > 10) || (std::floorf(arg1) < 100)) {}
+void test__hypotl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((hypotl(arg1, arg2) > 10) || (hypotl(arg1, arg2) < 100)) {}
 }
 
-void test__std__floorf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::floorf(x);
+void test__hypotl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = hypotl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__floorl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = floorl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__hypotl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = hypotl(x, arg2);
 }
 
-void test__floorl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    floorl(arg1);
+void test__hypotl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = hypotl(arg1, x);
 }
 
-void test__floorl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((floorl(arg1) > 10) || (floorl(arg1) < 100)) {}
+void test__std__hypotl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::hypotl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__floorl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = floorl(p);
-    // cppcheck-suppress memleak
+void test__std__hypotl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::hypotl(arg1, arg2);
 }
 
-void test__floorl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = floorl(x);
+void test__std__hypotl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::hypotl(arg1, arg2) > 10) || (std::hypotl(arg1, arg2) < 100)) {}
 }
 
-void test__std__floorl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::floorl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__hypotl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::hypotl(x, arg2);
 }
 
-void test__std__floorl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::floorl(arg1);
+void test__std__hypotl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::hypotl(arg1, x);
 }
 
-void test__std__floorl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::floorl(arg1) > 10) || (std::floorl(arg1) < 100)) {}
+void test__fscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fscanf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__floorl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::floorl(x);
+void test__fscanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  fscanf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__fma__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fma(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fscanf(x, arg2);
 }
 
-void test__fma__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fma(arg1, arg2, arg3);
+void test__fscanf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fscanf(arg1, x);
 }
 
-void test__fma__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fma(arg1, arg2, arg3) > 10) || (fma(arg1, arg2, arg3) < 100)) {}
+void test__std__fscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fscanf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fma__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fma(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__fscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fscanf(x, arg2);
 }
 
-void test__fma__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fma(x, arg2, arg3);
+void test__std__fscanf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fscanf(arg1, x);
 }
 
-void test__fma__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fma(arg1, x, arg3);
+void test__vfscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vfscanf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fma__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fma(arg1, arg2, x);
+void test__vfscanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  vfscanf(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fma__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fma(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__vfscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vfscanf(x, arg2, arg3);
 }
 
-void test__std__fma__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fma(arg1, arg2, arg3);
+void test__vfscanf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vfscanf(arg1, x, arg3);
 }
 
-void test__std__fma__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fma(arg1, arg2, arg3) > 10) || (std::fma(arg1, arg2, arg3) < 100)) {}
+void test__std__vfscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vfscanf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fma__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fma(x, arg2, arg3);
+void test__std__vfscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vfscanf(x, arg2, arg3);
 }
 
-void test__std__fma__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fma(arg1, x, arg3);
+void test__std__vfscanf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vfscanf(arg1, x, arg3);
 }
 
-void test__std__fma__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fma(arg1, arg2, x);
+void test__vfwscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vfwscanf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fmaf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fmaf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__vfwscanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  vfwscanf(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__fmaf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fmaf(arg1, arg2, arg3);
+void test__vfwscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vfwscanf(x, arg2, arg3);
 }
 
-void test__fmaf__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fmaf(arg1, arg2, arg3) > 10) || (fmaf(arg1, arg2, arg3) < 100)) {}
+void test__vfwscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  vfwscanf(arg1, NULL, arg3);
 }
 
-void test__fmaf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fmaf(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__vfwscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vfwscanf(arg1, x, arg3);
 }
 
-void test__fmaf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmaf(x, arg2, arg3);
+void test__std__vfwscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vfwscanf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fmaf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmaf(arg1, x, arg3);
+void test__std__vfwscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vfwscanf(x, arg2, arg3);
 }
 
-void test__fmaf__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmaf(arg1, arg2, x);
+void test__std__vfwscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vfwscanf(arg1, NULL, arg3);
 }
 
-void test__std__fmaf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fmaf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vfwscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vfwscanf(arg1, x, arg3);
 }
 
-void test__std__fmaf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fmaf(arg1, arg2, arg3);
+void test__fseek__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fseek(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fmaf__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fmaf(arg1, arg2, arg3) > 10) || (std::fmaf(arg1, arg2, arg3) < 100)) {}
+void test__fseek__leakignore() {
+  char *p = malloc(10); *p=0;
+  fseek(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fmaf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmaf(x, arg2, arg3);
+void test__fseek__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fseek(NULL, arg2, arg3);
 }
 
-void test__std__fmaf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmaf(arg1, x, arg3);
+void test__fseek__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fseek(x, arg2, arg3);
 }
 
-void test__std__fmaf__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmaf(arg1, arg2, x);
+void test__fseek__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fseek(arg1, x, arg3);
 }
 
-void test__fmal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fmal(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fseek__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fseek(arg1, arg2, x);
 }
 
-void test__fmal__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fmal(arg1, arg2, arg3);
+void test__std__fseek__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fseek(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fmal__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fmal(arg1, arg2, arg3) > 10) || (fmal(arg1, arg2, arg3) < 100)) {}
+void test__std__fseek__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fseek(NULL, arg2, arg3);
 }
 
-void test__fmal__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fmal(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__fseek__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fseek(x, arg2, arg3);
 }
 
-void test__fmal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmal(x, arg2, arg3);
+void test__std__fseek__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fseek(arg1, x, arg3);
 }
 
-void test__fmal__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmal(arg1, x, arg3);
+void test__std__fseek__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fseek(arg1, arg2, x);
 }
 
-void test__fmal__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmal(arg1, arg2, x);
+void test__fsetpos__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fsetpos(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fmal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fmal(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fsetpos__leakignore() {
+  char *p = malloc(10); *p=0;
+  fsetpos(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fmal__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fmal(arg1, arg2, arg3);
+void test__fsetpos__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fsetpos(NULL, arg2);
 }
 
-void test__std__fmal__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fmal(arg1, arg2, arg3) > 10) || (std::fmal(arg1, arg2, arg3) < 100)) {}
+void test__fsetpos__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fsetpos(x, arg2);
 }
 
-void test__std__fmal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmal(x, arg2, arg3);
+void test__fsetpos__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fsetpos(arg1, NULL);
 }
 
-void test__std__fmal__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmal(arg1, x, arg3);
+void test__fsetpos__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fsetpos(arg1, x);
 }
 
-void test__std__fmal__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmal(arg1, arg2, x);
+void test__std__fsetpos__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fsetpos(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fmax__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fmax(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fsetpos__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fsetpos(NULL, arg2);
 }
 
-void test__fmax__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fmax(arg1, arg2);
+void test__std__fsetpos__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fsetpos(x, arg2);
 }
 
-void test__fmax__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fmax(arg1, arg2) > 10) || (fmax(arg1, arg2) < 100)) {}
+void test__std__fsetpos__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fsetpos(arg1, NULL);
 }
 
-void test__fmax__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fmax(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__fsetpos__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fsetpos(arg1, x);
 }
 
-void test__fmax__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmax(x, arg2);
+void test__fgets__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fgets(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fmax__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmax(arg1, x);
+void test__fgets__leakignore() {
+  char *p = malloc(10); *p=0;
+  fgets(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fmax__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fmax(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fgets__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fgets(NULL, arg2, arg3);
 }
 
-void test__std__fmax__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fmax(arg1, arg2);
+void test__fgets__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  fgets(arg1, !x, arg3);
 }
 
-void test__std__fmax__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fmax(arg1, arg2) > 10) || (std::fmax(arg1, arg2) < 100)) {}
+void test__fgets__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fgets(arg1, x, arg3);
 }
 
-void test__std__fmax__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmax(x, arg2);
+void test__fgets__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  fgets(arg1, arg2, NULL);
 }
 
-void test__std__fmax__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmax(arg1, x);
+void test__fgets__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fgets(arg1, arg2, x);
 }
 
-void test__fmaxf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fmaxf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fgets__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fgets(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fmaxf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fmaxf(arg1, arg2);
+void test__std__fgets__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgets(NULL, arg2, arg3);
 }
 
-void test__fmaxf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fmaxf(arg1, arg2) > 10) || (fmaxf(arg1, arg2) < 100)) {}
+void test__std__fgets__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::fgets(arg1, !x, arg3);
 }
 
-void test__fmaxf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fmaxf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__fgets__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fgets(arg1, x, arg3);
 }
 
-void test__fmaxf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmaxf(x, arg2);
+void test__std__fgets__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgets(arg1, arg2, NULL);
 }
 
-void test__fmaxf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmaxf(arg1, x);
+void test__std__fgets__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fgets(arg1, arg2, x);
 }
 
-void test__std__fmaxf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fmaxf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fgetws__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fgetws(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fmaxf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fmaxf(arg1, arg2);
+void test__fgetws__leakignore() {
+  char *p = malloc(10); *p=0;
+  fgetws(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fmaxf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fmaxf(arg1, arg2) > 10) || (std::fmaxf(arg1, arg2) < 100)) {}
+void test__fgetws__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fgetws(NULL, arg2, arg3);
 }
 
-void test__std__fmaxf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmaxf(x, arg2);
+void test__fgetws__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  fgetws(arg1, !x, arg3);
 }
 
-void test__std__fmaxf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmaxf(arg1, x);
+void test__fgetws__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fgetws(arg1, x, arg3);
 }
 
-void test__fmaxl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fmaxl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fgetws__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  fgetws(arg1, arg2, NULL);
 }
 
-void test__fmaxl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fmaxl(arg1, arg2);
+void test__fgetws__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fgetws(arg1, arg2, x);
 }
 
-void test__fmaxl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fmaxl(arg1, arg2) > 10) || (fmaxl(arg1, arg2) < 100)) {}
+void test__std__fgetws__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fgetws(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fmaxl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fmaxl(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__fgetws__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgetws(NULL, arg2, arg3);
 }
 
-void test__fmaxl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmaxl(x, arg2);
+void test__std__fgetws__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::fgetws(arg1, !x, arg3);
 }
 
-void test__fmaxl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmaxl(arg1, x);
+void test__std__fgetws__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fgetws(arg1, x, arg3);
 }
 
-void test__std__fmaxl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fmaxl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fgetws__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgetws(arg1, arg2, NULL);
 }
 
-void test__std__fmaxl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fmaxl(arg1, arg2);
+void test__std__fgetws__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fgetws(arg1, arg2, x);
 }
 
-void test__std__fmaxl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fmaxl(arg1, arg2) > 10) || (std::fmaxl(arg1, arg2) < 100)) {}
+void test__ftell__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ftell(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fmaxl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmaxl(x, arg2);
+void test__ftell__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ftell(arg1);
 }
 
-void test__std__fmaxl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmaxl(arg1, x);
+void test__ftell__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ftell(p);
+  // cppcheck-suppress memleak
 }
 
-void test__fmin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fmin(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ftell__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = ftell(NULL);
 }
 
-void test__fmin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fmin(arg1, arg2);
+void test__ftell__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = ftell(x);
 }
 
-void test__fmin__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fmin(arg1, arg2) > 10) || (fmin(arg1, arg2) < 100)) {}
+void test__std__ftell__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ftell(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fmin__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fmin(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__ftell__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ftell(arg1);
 }
 
-void test__fmin__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmin(x, arg2);
+void test__std__ftell__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::ftell(NULL);
 }
 
-void test__fmin__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmin(arg1, x);
+void test__std__ftell__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::ftell(x);
 }
 
-void test__std__fmin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fmin(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fwide__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fwide(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fmin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fmin(arg1, arg2);
+void test__fwide__leakignore() {
+  char *p = malloc(10); *p=0;
+  fwide(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fmin__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fmin(arg1, arg2) > 10) || (std::fmin(arg1, arg2) < 100)) {}
+void test__fwide__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fwide(NULL, arg2);
 }
 
-void test__std__fmin__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmin(x, arg2);
+void test__fwide__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fwide(x, arg2);
 }
 
-void test__std__fmin__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmin(arg1, x);
+void test__fwide__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fwide(arg1, x);
 }
 
-void test__fminf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fminf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fwide__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fwide(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fminf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fminf(arg1, arg2);
+void test__std__fwide__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fwide(NULL, arg2);
 }
 
-void test__fminf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fminf(arg1, arg2) > 10) || (fminf(arg1, arg2) < 100)) {}
+void test__std__fwide__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fwide(x, arg2);
 }
 
-void test__fminf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fminf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__fwide__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fwide(arg1, x);
 }
 
-void test__fminf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fminf(x, arg2);
+void test__fwrite__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fwrite(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fminf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fminf(arg1, x);
+void test__fwrite__leakignore() {
+  char *p = malloc(10); *p=0;
+  fwrite(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fminf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fminf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fwrite__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fwrite(NULL, arg2, arg3, arg4);
 }
 
-void test__std__fminf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fminf(arg1, arg2);
+void test__fwrite__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fwrite(x, arg2, arg3, arg4);
 }
 
-void test__std__fminf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fminf(arg1, arg2) > 10) || (std::fminf(arg1, arg2) < 100)) {}
+void test__fwrite__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fwrite(arg1, x, arg3, arg4);
 }
 
-void test__std__fminf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fminf(x, arg2);
+void test__fwrite__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fwrite(arg1, arg2, x, arg4);
 }
 
-void test__std__fminf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fminf(arg1, x);
+void test__fwrite__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  fwrite(arg1, arg2, arg3, NULL);
 }
 
-void test__fminl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fminl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fwrite__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fwrite(arg1, arg2, arg3, x);
 }
 
-void test__fminl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fminl(arg1, arg2);
+void test__std__fwrite__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fwrite(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fminl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fminl(arg1, arg2) > 10) || (fminl(arg1, arg2) < 100)) {}
+void test__std__fwrite__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fwrite(NULL, arg2, arg3, arg4);
 }
 
-void test__fminl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fminl(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__fwrite__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fwrite(x, arg2, arg3, arg4);
 }
 
-void test__fminl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fminl(x, arg2);
+void test__std__fwrite__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fwrite(arg1, x, arg3, arg4);
 }
 
-void test__fminl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fminl(arg1, x);
+void test__std__fwrite__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fwrite(arg1, arg2, x, arg4);
 }
 
-void test__std__fminl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fminl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fwrite__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fwrite(arg1, arg2, arg3, NULL);
 }
 
-void test__std__fminl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fminl(arg1, arg2);
+void test__std__fwrite__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fwrite(arg1, arg2, arg3, x);
 }
 
-void test__std__fminl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fminl(arg1, arg2) > 10) || (std::fminl(arg1, arg2) < 100)) {}
+void test__mblen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mblen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fminl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fminl(x, arg2);
+void test__mblen__leakignore() {
+  char *p = malloc(10); *p=0;
+  mblen(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fminl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fminl(arg1, x);
+void test__mblen__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mblen(x, arg2);
 }
 
-void test__fmod__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fmod(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mblen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mblen(arg1, x);
 }
 
-void test__fmod__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fmod(arg1, arg2);
+void test__std__mblen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::mblen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fmod__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fmod(arg1, arg2) > 10) || (fmod(arg1, arg2) < 100)) {}
+void test__std__mblen__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mblen(x, arg2);
 }
 
-void test__fmod__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fmod(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__mblen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mblen(arg1, x);
 }
 
-void test__fmod__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmod(x, arg2);
+void test__mbtowc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mbtowc(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fmod__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmod(arg1, x);
+void test__mbtowc__leakignore() {
+  char *p = malloc(10); *p=0;
+  mbtowc(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fmod__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fmod(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mbtowc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbtowc(arg1, x, arg3);
 }
 
-void test__std__fmod__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fmod(arg1, arg2);
+void test__mbtowc__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbtowc(arg1, arg2, x);
 }
 
-void test__std__fmod__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fmod(arg1, arg2) > 10) || (std::fmod(arg1, arg2) < 100)) {}
+void test__std__mbtowc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::mbtowc(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fmod__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmod(x, arg2);
+void test__std__mbtowc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbtowc(arg1, x, arg3);
 }
 
-void test__std__fmod__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmod(arg1, x);
+void test__std__mbtowc__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbtowc(arg1, arg2, x);
 }
 
-void test__fmodf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fmodf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mbrlen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mbrlen(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fmodf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fmodf(arg1, arg2);
+void test__mbrlen__leakignore() {
+  char *p = malloc(10); *p=0;
+  mbrlen(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__fmodf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fmodf(arg1, arg2) > 10) || (fmodf(arg1, arg2) < 100)) {}
+void test__mbrlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mbrlen(NULL, arg2, arg3);
 }
 
-void test__fmodf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fmodf(p, arg2);
-    // cppcheck-suppress memleak
+void test__mbrlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mbrlen(x, arg2, arg3);
 }
 
-void test__fmodf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmodf(x, arg2);
+void test__mbrlen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrlen(arg1, x, arg3);
 }
 
-void test__fmodf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmodf(arg1, x);
+void test__mbrlen__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrlen(arg1, arg2, x);
 }
 
-void test__std__fmodf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fmodf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__mbrlen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::mbrlen(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fmodf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fmodf(arg1, arg2);
+void test__std__mbrlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::mbrlen(NULL, arg2, arg3);
 }
 
-void test__std__fmodf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fmodf(arg1, arg2) > 10) || (std::fmodf(arg1, arg2) < 100)) {}
+void test__std__mbrlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::mbrlen(x, arg2, arg3);
 }
 
-void test__std__fmodf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmodf(x, arg2);
+void test__std__mbrlen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbrlen(arg1, x, arg3);
 }
 
-void test__std__fmodf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmodf(arg1, x);
+void test__std__mbrlen__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbrlen(arg1, arg2, x);
 }
 
-void test__fmodl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fmodl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__btowc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = btowc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fmodl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fmodl(arg1, arg2);
+void test__btowc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  btowc(arg1);
 }
 
-void test__fmodl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fmodl(arg1, arg2) > 10) || (fmodl(arg1, arg2) < 100)) {}
+void test__btowc__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((btowc(arg1) > 10) || (btowc(arg1) < 100)) {}
 }
 
-void test__fmodl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fmodl(p, arg2);
-    // cppcheck-suppress memleak
+void test__btowc__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = btowc(p);
+  // cppcheck-suppress memleak
 }
 
-void test__fmodl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmodl(x, arg2);
+void test__btowc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = btowc(x);
 }
 
-void test__fmodl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fmodl(arg1, x);
+void test__std__btowc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::btowc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fmodl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fmodl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__btowc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::btowc(arg1);
 }
 
-void test__std__fmodl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fmodl(arg1, arg2);
+void test__std__btowc__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::btowc(arg1) > 10) || (std::btowc(arg1) < 100)) {}
 }
 
-void test__std__fmodl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fmodl(arg1, arg2) > 10) || (std::fmodl(arg1, arg2) < 100)) {}
+void test__std__btowc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::btowc(x);
 }
 
-void test__std__fmodl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmodl(x, arg2);
+void test__mbsinit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mbsinit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fmodl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fmodl(arg1, x);
+void test__mbsinit__leakignore() {
+  char *p = malloc(10); *p=0;
+  mbsinit(p);
+  // cppcheck-suppress memleak
 }
 
-void test__fopen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fopen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mbsinit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbsinit(x);
 }
 
-void test__fopen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fopen(arg1, arg2);
+void test__std__mbsinit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::mbsinit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fopen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = fopen(NULL, arg2);
+void test__std__mbsinit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbsinit(x);
 }
 
-void test__fopen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = fopen(x, arg2);
+void test__getwchar__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getwchar(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fopen__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = fopen(arg1, NULL);
+void test__getwchar__leakignore() {
+  char *p = malloc(10); *p=0;
+  getwchar();
+  // cppcheck-suppress memleak
 }
 
-void test__fopen__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = fopen(arg1, x);
+void test__mbstowcs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mbstowcs(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fopen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fopen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mbstowcs__leakignore() {
+  char *p = malloc(10); *p=0;
+  mbstowcs(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fopen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fopen(arg1, arg2);
+void test__mbstowcs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  mbstowcs(arg1, NULL, arg3);
 }
 
-void test__std__fopen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::fopen(NULL, arg2);
+void test__mbstowcs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mbstowcs(arg1, x, arg3);
 }
 
-void test__std__fopen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::fopen(x, arg2);
+void test__mbstowcs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbstowcs(arg1, arg2, x);
 }
 
-void test__std__fopen__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::fopen(arg1, NULL);
+void test__std__mbstowcs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::mbstowcs(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fopen__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::fopen(arg1, x);
+void test__std__mbstowcs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::mbstowcs(arg1, NULL, arg3);
 }
 
-void test__fopen_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fopen_s(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__mbstowcs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::mbstowcs(arg1, x, arg3);
 }
 
-void test__fopen_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fopen_s(NULL, arg2, arg3);
+void test__std__mbstowcs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbstowcs(arg1, arg2, x);
 }
 
-void test__fopen_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fopen_s(arg1, NULL, arg3);
+void test__mbsrtowcs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mbsrtowcs(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fopen_s__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fopen_s(arg1, x, arg3);
+void test__mbsrtowcs__leakignore() {
+  char *p = malloc(10); *p=0;
+  mbsrtowcs(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__fopen_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fopen_s(arg1, arg2, NULL);
+void test__mbsrtowcs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  mbsrtowcs(arg1, NULL, arg3, arg4);
 }
 
-void test__fopen_s__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fopen_s(arg1, arg2, x);
+void test__mbsrtowcs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mbsrtowcs(arg1, x, arg3, arg4);
 }
 
-void test__fprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fprintf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mbsrtowcs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbsrtowcs(arg1, arg2, x, arg4);
 }
 
-void test__fprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fprintf(p, arg2);
-    // cppcheck-suppress memleak
+void test__mbsrtowcs__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  mbsrtowcs(arg1, arg2, arg3, NULL);
 }
 
-void test__fprintf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fprintf(NULL, arg2);
+void test__std__mbsrtowcs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::mbsrtowcs(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fprintf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fprintf(x, arg2);
+void test__std__mbsrtowcs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::mbsrtowcs(arg1, NULL, arg3, arg4);
 }
 
-void test__fprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fprintf(arg1, x);
+void test__std__mbsrtowcs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::mbsrtowcs(arg1, x, arg3, arg4);
 }
 
-void test__std__fprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fprintf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__mbsrtowcs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbsrtowcs(arg1, arg2, x, arg4);
 }
 
-void test__std__fprintf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fprintf(NULL, arg2);
+void test__std__mbsrtowcs__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  std::mbsrtowcs(arg1, arg2, arg3, NULL);
 }
 
-void test__std__fprintf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fprintf(x, arg2);
+void test__wctob__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wctob(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fprintf(arg1, x);
+void test__wctob__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wctob(arg1);
 }
 
-void test__vfprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vfprintf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wctob__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wctob(arg1) > 10) || (wctob(arg1) < 100)) {}
 }
 
-void test__vfprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vfprintf(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__wctob__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wctob(p);
+  // cppcheck-suppress memleak
 }
 
-void test__vfprintf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vfprintf(NULL, arg2, arg3);
+void test__wctob__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wctob(x);
 }
 
-void test__vfprintf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    vfprintf(x, arg2, arg3);
+void test__std__wctob__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wctob(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vfprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    vfprintf(arg1, x, arg3);
+void test__std__wctob__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wctob(arg1);
 }
 
-void test__std__vfprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vfprintf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wctob__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wctob(arg1) > 10) || (std::wctob(arg1) < 100)) {}
 }
 
-void test__std__vfprintf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::vfprintf(NULL, arg2, arg3);
+void test__std__wctob__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wctob(x);
 }
 
-void test__std__vfprintf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::vfprintf(x, arg2, arg3);
+void test__wctomb__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wctomb(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vfprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::vfprintf(arg1, x, arg3);
+void test__wctomb__leakignore() {
+  char *p = malloc(10); *p=0;
+  wctomb(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__vfwprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vfwprintf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wctomb__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wctomb(x, arg2);
 }
 
-void test__vfwprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vfwprintf(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__wctomb__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wctomb(arg1, x);
 }
 
-void test__vfwprintf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vfwprintf(NULL, arg2, arg3);
+void test__std__wctomb__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wctomb(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vfwprintf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    vfwprintf(x, arg2, arg3);
+void test__std__wctomb__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wctomb(x, arg2);
 }
 
-void test__vfwprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    vfwprintf(arg1, x, arg3);
+void test__std__wctomb__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wctomb(arg1, x);
 }
 
-void test__std__vfwprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vfwprintf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcstombs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcstombs(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vfwprintf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::vfwprintf(NULL, arg2, arg3);
+void test__wcstombs__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcstombs(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__vfwprintf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::vfwprintf(x, arg2, arg3);
+void test__wcstombs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstombs(arg1, NULL, arg3);
 }
 
-void test__std__vfwprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::vfwprintf(arg1, x, arg3);
+void test__wcstombs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcstombs(arg1, x, arg3);
 }
 
-void test__fputc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fputc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcstombs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcstombs(arg1, arg2, x);
 }
 
-void test__fputc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fputc(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__wcstombs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wcstombs(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fputc__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    fputc(!x, arg2);
+void test__std__wcstombs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcstombs(arg1, NULL, arg3);
 }
 
-void test__fputc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fputc(x, arg2);
+void test__std__wcstombs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcstombs(arg1, x, arg3);
 }
 
-void test__fputc__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fputc(arg1, NULL);
+void test__std__wcstombs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcstombs(arg1, arg2, x);
 }
 
-void test__fputc__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fputc(arg1, x);
+void test__getchar__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getchar(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fputc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fputc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getchar__leakignore() {
+  char *p = malloc(10); *p=0;
+  getchar();
+  // cppcheck-suppress memleak
 }
 
-void test__std__fputc__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::fputc(!x, arg2);
+void test__ungetc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ungetc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fputc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fputc(x, arg2);
+void test__ungetc__leakignore() {
+  char *p = malloc(10); *p=0;
+  ungetc(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fputc__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fputc(arg1, NULL);
+void test__ungetc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ungetc(x, arg2);
 }
 
-void test__std__fputc__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fputc(arg1, x);
+void test__ungetc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  ungetc(arg1, NULL);
 }
 
-void test__fputwc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fputwc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ungetc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ungetc(arg1, x);
 }
 
-void test__fputwc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fputwc(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__ungetc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::ungetc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fputwc__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    fputwc(!x, arg2);
+void test__std__ungetc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ungetc(x, arg2);
 }
 
-void test__fputwc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fputwc(x, arg2);
+void test__std__ungetc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::ungetc(arg1, NULL);
 }
 
-void test__fputwc__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fputwc(arg1, NULL);
+void test__std__ungetc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::ungetc(arg1, x);
 }
 
-void test__fputwc__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fputwc(arg1, x);
+void test__ungetwc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ungetwc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fputwc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fputwc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ungetwc__leakignore() {
+  char *p = malloc(10); *p=0;
+  ungetwc(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fputwc__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::fputwc(!x, arg2);
+void test__ungetwc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ungetwc(x, arg2);
 }
 
-void test__std__fputwc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fputwc(x, arg2);
+void test__ungetwc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  ungetwc(arg1, NULL);
 }
 
-void test__std__fputwc__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fputwc(arg1, NULL);
+void test__ungetwc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ungetwc(arg1, x);
 }
 
-void test__std__fputwc__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fputwc(arg1, x);
+void test__std__ungetwc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::ungetwc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fputs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fputs(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ungetwc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ungetwc(x, arg2);
 }
 
-void test__fputs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fputs(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__ungetwc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::ungetwc(arg1, NULL);
 }
 
-void test__fputs__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fputs(NULL, arg2);
+void test__std__ungetwc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::ungetwc(arg1, x);
 }
 
-void test__fputs__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fputs(x, arg2);
+void test__getenv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = getenv(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fputs__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fputs(arg1, NULL);
+void test__getenv__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getenv(arg1);
 }
 
-void test__fputs__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fputs(arg1, x);
+void test__getenv__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = getenv(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fputs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fputs(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = getenv(NULL);
 }
 
-void test__std__fputs__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fputs(NULL, arg2);
+void test__getenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = getenv(x);
 }
 
-void test__std__fputs__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fputs(x, arg2);
+void test__std__getenv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::getenv(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fputs__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fputs(arg1, NULL);
+void test__std__getenv__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::getenv(arg1);
 }
 
-void test__std__fputs__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fputs(arg1, x);
+void test__std__getenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::getenv(NULL);
 }
 
-void test__fputws__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fputws(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__getenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::getenv(x);
 }
 
-void test__fputws__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fputws(p, arg2);
-    // cppcheck-suppress memleak
+void test__gets__noreturn() {
+  int x = 1;
+  if (cond) { x=100; gets(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fputws__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fputws(NULL, arg2);
+void test__gets__leakignore() {
+  char *p = malloc(10); *p=0;
+  gets(p);
+  // cppcheck-suppress memleak
 }
 
-void test__fputws__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fputws(x, arg2);
+void test__gets__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  gets(NULL);
 }
 
-void test__fputws__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fputws(arg1, NULL);
+void test__std__gets__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::gets(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fputws__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fputws(arg1, x);
+void test__std__gets__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::gets(NULL);
 }
 
-void test__std__fputws__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fputws(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__gets_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; gets_s(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fputws__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fputws(NULL, arg2);
+void test__gets_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  gets_s(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fputws__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fputws(x, arg2);
+void test__gets_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  gets_s(NULL, arg2);
 }
 
-void test__std__fputws__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fputws(arg1, NULL);
+void test__gets_s__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  gets_s(arg1, !x);
 }
 
-void test__std__fputws__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fputws(arg1, x);
+void test__gets_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  gets_s(arg1, x);
 }
 
-void test__fread__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fread(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__gets_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::gets_s(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fread__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fread(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__std__gets_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::gets_s(NULL, arg2);
 }
 
-void test__fread__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fread(NULL, arg2, arg3, arg4);
+void test__std__gets_s__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::gets_s(arg1, !x);
 }
 
-void test__fread__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fread(arg1, x, arg3, arg4);
+void test__std__gets_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::gets_s(arg1, x);
 }
 
-void test__fread__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fread(arg1, arg2, x, arg4);
+void test__gmtime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = gmtime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fread__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fread(arg1, arg2, arg3, NULL);
+void test__gmtime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  gmtime(arg1);
 }
 
-void test__fread__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fread(arg1, arg2, arg3, x);
+void test__gmtime__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((gmtime(arg1) > 10) || (gmtime(arg1) < 100)) {}
 }
 
-void test__std__fread__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fread(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__gmtime__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = gmtime(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fread__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fread(NULL, arg2, arg3, arg4);
+void test__gmtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = gmtime(NULL);
 }
 
-void test__std__fread__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fread(arg1, x, arg3, arg4);
+void test__gmtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = gmtime(x);
 }
 
-void test__std__fread__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fread(arg1, arg2, x, arg4);
+void test__std__gmtime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::gmtime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fread__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fread(arg1, arg2, arg3, NULL);
+void test__std__gmtime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::gmtime(arg1);
 }
 
-void test__std__fread__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fread(arg1, arg2, arg3, x);
+void test__std__gmtime__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::gmtime(arg1) > 10) || (std::gmtime(arg1) < 100)) {}
 }
 
-void test__free__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        free(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__gmtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::gmtime(NULL);
 }
 
-void test__free__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    free(x);
+void test__std__gmtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::gmtime(x);
 }
 
-void test__std__free__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::free(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isalnum__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isalnum(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__free__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::free(x);
+void test__isalnum__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isalnum(arg1);
 }
 
-void test__freopen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = freopen(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isalnum__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isalnum(arg1) > 10) || (isalnum(arg1) < 100)) {}
 }
 
-void test__freopen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    freopen(arg1, arg2, arg3);
+void test__isalnum__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isalnum(p);
+  // cppcheck-suppress memleak
 }
 
-void test__freopen__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = freopen(x, arg2, arg3);
+void test__isalnum__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isalnum(x);
 }
 
-void test__freopen__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = freopen(arg1, NULL, arg3);
+void test__std__isalnum__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isalnum(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__freopen__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = freopen(arg1, x, arg3);
+void test__std__isalnum__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isalnum(arg1);
 }
 
-void test__freopen__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = freopen(arg1, arg2, NULL);
+void test__std__isalnum__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isalnum(arg1) > 10) || (std::isalnum(arg1) < 100)) {}
 }
 
-void test__freopen__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = freopen(arg1, arg2, x);
+void test__std__isalnum__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isalnum(x);
 }
 
-void test__std__freopen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::freopen(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswalnum__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = iswalnum(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__freopen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::freopen(arg1, arg2, arg3);
+void test__iswalnum__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswalnum(arg1);
 }
 
-void test__std__freopen__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::freopen(x, arg2, arg3);
+void test__iswalnum__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswalnum(arg1) > 10) || (iswalnum(arg1) < 100)) {}
 }
 
-void test__std__freopen__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::freopen(arg1, NULL, arg3);
+void test__iswalnum__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = iswalnum(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__freopen__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::freopen(arg1, x, arg3);
+void test__iswalnum__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswalnum(x);
 }
 
-void test__std__freopen__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::freopen(arg1, arg2, NULL);
+void test__std__iswalnum__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::iswalnum(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__freopen__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::freopen(arg1, arg2, x);
+void test__std__iswalnum__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswalnum(arg1);
 }
 
-void test__freopen_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = freopen_s(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__iswalnum__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswalnum(arg1) > 10) || (std::iswalnum(arg1) < 100)) {}
 }
 
-void test__freopen_s__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    freopen_s(arg1, arg2, arg3, arg4);
+void test__std__iswalnum__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswalnum(x);
 }
 
-void test__freopen_s__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = freopen_s(x, arg2, arg3, arg4);
+void test__isalpha__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isalpha(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__freopen_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = freopen_s(arg1, x, arg3, arg4);
+void test__isalpha__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isalpha(arg1);
 }
 
-void test__freopen_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = freopen_s(arg1, arg2, NULL, arg4);
+void test__isalpha__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isalpha(arg1) > 10) || (isalpha(arg1) < 100)) {}
 }
 
-void test__freopen_s__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = freopen_s(arg1, arg2, x, arg4);
+void test__isalpha__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isalpha(p);
+  // cppcheck-suppress memleak
 }
 
-void test__freopen_s__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = freopen_s(arg1, arg2, arg3, NULL);
+void test__isalpha__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isalpha(x);
 }
 
-void test__freopen_s__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = freopen_s(arg1, arg2, arg3, x);
+void test__std__isalpha__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isalpha(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__frexp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        frexp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__isalpha__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isalpha(arg1);
 }
 
-void test__frexp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    frexp(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__isalpha__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isalpha(arg1) > 10) || (std::isalpha(arg1) < 100)) {}
 }
 
-void test__frexp__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    frexp(x, arg2);
+void test__std__isalpha__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isalpha(x);
 }
 
-void test__frexp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    frexp(arg1, NULL);
+void test__iswalpha__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = iswalpha(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__frexp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::frexp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswalpha__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswalpha(arg1);
 }
 
-void test__std__frexp__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::frexp(x, arg2);
+void test__iswalpha__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswalpha(arg1) > 10) || (iswalpha(arg1) < 100)) {}
 }
 
-void test__std__frexp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::frexp(arg1, NULL);
+void test__iswalpha__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = iswalpha(p);
+  // cppcheck-suppress memleak
 }
 
-void test__frexpf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        frexpf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswalpha__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswalpha(x);
 }
 
-void test__frexpf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    frexpf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__iswalpha__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::iswalpha(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__frexpf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    frexpf(x, arg2);
+void test__std__iswalpha__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswalpha(arg1);
 }
 
-void test__frexpf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    frexpf(arg1, NULL);
+void test__std__iswalpha__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswalpha(arg1) > 10) || (std::iswalpha(arg1) < 100)) {}
 }
 
-void test__std__frexpf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::frexpf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__iswalpha__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswalpha(x);
 }
 
-void test__std__frexpf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::frexpf(x, arg2);
+void test__isblank__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isblank(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__frexpf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::frexpf(arg1, NULL);
+void test__isblank__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isblank(arg1);
 }
 
-void test__frexpl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        frexpl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isblank__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isblank(arg1) > 10) || (isblank(arg1) < 100)) {}
 }
 
-void test__frexpl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    frexpl(p, arg2);
-    // cppcheck-suppress memleak
+void test__isblank__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isblank(p);
+  // cppcheck-suppress memleak
 }
 
-void test__frexpl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    frexpl(x, arg2);
+void test__isblank__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isblank(x);
 }
 
-void test__frexpl__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    frexpl(arg1, NULL);
+void test__std__isblank__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isblank(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__frexpl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::frexpl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__isblank__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isblank(arg1);
 }
 
-void test__std__frexpl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::frexpl(x, arg2);
+void test__std__isblank__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isblank(arg1) > 10) || (std::isblank(arg1) < 100)) {}
 }
 
-void test__std__frexpl__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::frexpl(arg1, NULL);
+void test__std__isblank__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isblank(x);
 }
 
-void test__hypot__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = hypot(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswblank__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = iswblank(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__hypot__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    hypot(arg1, arg2, arg3);
+void test__iswblank__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswblank(arg1);
 }
 
-void test__hypot__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((hypot(arg1, arg2, arg3) > 10) || (hypot(arg1, arg2, arg3) < 100)) {}
+void test__iswblank__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswblank(arg1) > 10) || (iswblank(arg1) < 100)) {}
 }
 
-void test__hypot__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = hypot(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__iswblank__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = iswblank(p);
+  // cppcheck-suppress memleak
 }
 
-void test__hypot__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = hypot(x, arg2, arg3);
+void test__iswblank__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswblank(x);
 }
 
-void test__hypot__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = hypot(arg1, x, arg3);
+void test__std__iswblank__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::iswblank(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__hypot__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = hypot(arg1, arg2, x);
+void test__std__iswblank__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswblank(arg1);
 }
 
-void test__std__hypot__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::hypot(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__iswblank__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswblank(arg1) > 10) || (std::iswblank(arg1) < 100)) {}
 }
 
-void test__std__hypot__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::hypot(arg1, arg2, arg3);
+void test__std__iswblank__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswblank(x);
 }
 
-void test__std__hypot__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::hypot(arg1, arg2, arg3) > 10) || (std::hypot(arg1, arg2, arg3) < 100)) {}
+void test__iscntrl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = iscntrl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__hypot__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::hypot(x, arg2, arg3);
+void test__iscntrl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iscntrl(arg1);
 }
 
-void test__std__hypot__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::hypot(arg1, x, arg3);
+void test__iscntrl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iscntrl(arg1) > 10) || (iscntrl(arg1) < 100)) {}
 }
 
-void test__std__hypot__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::hypot(arg1, arg2, x);
+void test__iscntrl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = iscntrl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__hypotf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = hypotf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iscntrl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iscntrl(x);
 }
 
-void test__hypotf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    hypotf(arg1, arg2);
+void test__std__iscntrl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::iscntrl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__hypotf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((hypotf(arg1, arg2) > 10) || (hypotf(arg1, arg2) < 100)) {}
+void test__std__iscntrl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iscntrl(arg1);
 }
 
-void test__hypotf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = hypotf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__iscntrl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iscntrl(arg1) > 10) || (std::iscntrl(arg1) < 100)) {}
 }
 
-void test__hypotf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = hypotf(x, arg2);
+void test__std__iscntrl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iscntrl(x);
 }
 
-void test__hypotf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = hypotf(arg1, x);
+void test__iswcntrl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = iswcntrl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__hypotf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::hypotf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswcntrl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswcntrl(arg1);
 }
 
-void test__std__hypotf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::hypotf(arg1, arg2);
+void test__iswcntrl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswcntrl(arg1) > 10) || (iswcntrl(arg1) < 100)) {}
 }
 
-void test__std__hypotf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::hypotf(arg1, arg2) > 10) || (std::hypotf(arg1, arg2) < 100)) {}
+void test__iswcntrl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = iswcntrl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__hypotf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::hypotf(x, arg2);
+void test__iswcntrl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswcntrl(x);
 }
 
-void test__std__hypotf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::hypotf(arg1, x);
+void test__std__iswcntrl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::iswcntrl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__hypotl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = hypotl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__iswcntrl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswcntrl(arg1);
 }
 
-void test__hypotl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    hypotl(arg1, arg2);
+void test__std__iswcntrl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswcntrl(arg1) > 10) || (std::iswcntrl(arg1) < 100)) {}
 }
 
-void test__hypotl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((hypotl(arg1, arg2) > 10) || (hypotl(arg1, arg2) < 100)) {}
+void test__std__iswcntrl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswcntrl(x);
 }
 
-void test__hypotl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = hypotl(p, arg2);
-    // cppcheck-suppress memleak
+void test__iswctype__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = iswctype(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__hypotl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = hypotl(x, arg2);
+void test__iswctype__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswctype(arg1, arg2);
 }
 
-void test__hypotl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = hypotl(arg1, x);
+void test__iswctype__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswctype(arg1, arg2) > 10) || (iswctype(arg1, arg2) < 100)) {}
 }
 
-void test__std__hypotl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::hypotl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswctype__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = iswctype(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__hypotl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::hypotl(arg1, arg2);
+void test__iswctype__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswctype(x, arg2);
 }
 
-void test__std__hypotl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::hypotl(arg1, arg2) > 10) || (std::hypotl(arg1, arg2) < 100)) {}
+void test__iswctype__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswctype(arg1, x);
 }
 
-void test__std__hypotl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::hypotl(x, arg2);
+void test__std__iswctype__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::iswctype(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__hypotl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::hypotl(arg1, x);
+void test__std__iswctype__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswctype(arg1, arg2);
 }
 
-void test__fscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fscanf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__iswctype__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswctype(arg1, arg2) > 10) || (std::iswctype(arg1, arg2) < 100)) {}
 }
 
-void test__fscanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fscanf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__iswctype__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswctype(x, arg2);
 }
 
-void test__fscanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fscanf(x, arg2);
+void test__std__iswctype__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswctype(arg1, x);
 }
 
-void test__fscanf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fscanf(arg1, x);
+void test__isdigit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isdigit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fscanf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isdigit(arg1);
 }
 
-void test__std__fscanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fscanf(x, arg2);
+void test__isdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isdigit(arg1) > 10) || (isdigit(arg1) < 100)) {}
 }
 
-void test__std__fscanf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fscanf(arg1, x);
+void test__isdigit__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isdigit(p);
+  // cppcheck-suppress memleak
 }
 
-void test__vfscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vfscanf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isdigit(x);
 }
 
-void test__vfscanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vfscanf(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__isdigit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isdigit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vfscanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    vfscanf(x, arg2, arg3);
+void test__std__isdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isdigit(arg1);
 }
 
-void test__vfscanf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    vfscanf(arg1, x, arg3);
+void test__std__isdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isdigit(arg1) > 10) || (std::isdigit(arg1) < 100)) {}
 }
 
-void test__std__vfscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vfscanf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vfscanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::vfscanf(x, arg2, arg3);
+void test__std__isdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isdigit(x);
 }
 
-void test__std__vfscanf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::vfscanf(arg1, x, arg3);
+void test__iswdigit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = iswdigit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vfwscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vfwscanf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswdigit(arg1);
 }
 
-void test__vfwscanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vfwscanf(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__iswdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswdigit(arg1) > 10) || (iswdigit(arg1) < 100)) {}
 }
 
-void test__vfwscanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    vfwscanf(x, arg2, arg3);
+void test__iswdigit__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = iswdigit(p);
+  // cppcheck-suppress memleak
 }
 
-void test__vfwscanf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vfwscanf(arg1, NULL, arg3);
+void test__iswdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswdigit(x);
 }
 
-void test__vfwscanf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    vfwscanf(arg1, x, arg3);
+void test__std__iswdigit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::iswdigit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vfwscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vfwscanf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__iswdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswdigit(arg1);
 }
 
-void test__std__vfwscanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::vfwscanf(x, arg2, arg3);
+void test__std__iswdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswdigit(arg1) > 10) || (std::iswdigit(arg1) < 100)) {}
 }
 
-void test__std__vfwscanf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::vfwscanf(arg1, NULL, arg3);
+void test__std__iswdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswdigit(x);
 }
 
-void test__std__vfwscanf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::vfwscanf(arg1, x, arg3);
+void test__isgraph__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isgraph(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fseek__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fseek(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isgraph__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isgraph(arg1);
 }
 
-void test__fseek__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fseek(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__isgraph__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isgraph(arg1) > 10) || (isgraph(arg1) < 100)) {}
 }
 
-void test__fseek__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fseek(NULL, arg2, arg3);
+void test__isgraph__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isgraph(p);
+  // cppcheck-suppress memleak
 }
 
-void test__fseek__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fseek(x, arg2, arg3);
+void test__isgraph__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isgraph(x);
 }
 
-void test__fseek__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fseek(arg1, x, arg3);
+void test__std__isgraph__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isgraph(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fseek__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fseek(arg1, arg2, x);
+void test__std__isgraph__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isgraph(arg1);
 }
 
-void test__std__fseek__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fseek(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__isgraph__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isgraph(arg1) > 10) || (std::isgraph(arg1) < 100)) {}
 }
 
-void test__std__fseek__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fseek(NULL, arg2, arg3);
+void test__std__isgraph__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isgraph(x);
 }
 
-void test__std__fseek__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fseek(x, arg2, arg3);
+void test__iswgraph__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = iswgraph(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fseek__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fseek(arg1, x, arg3);
+void test__iswgraph__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswgraph(arg1);
 }
 
-void test__std__fseek__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fseek(arg1, arg2, x);
+void test__iswgraph__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswgraph(arg1) > 10) || (iswgraph(arg1) < 100)) {}
 }
 
-void test__fsetpos__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fsetpos(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswgraph__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = iswgraph(p);
+  // cppcheck-suppress memleak
 }
 
-void test__fsetpos__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fsetpos(p, arg2);
-    // cppcheck-suppress memleak
+void test__iswgraph__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswgraph(x);
 }
 
-void test__fsetpos__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fsetpos(NULL, arg2);
+void test__std__iswgraph__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::iswgraph(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fsetpos__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fsetpos(x, arg2);
+void test__std__iswgraph__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswgraph(arg1);
 }
 
-void test__fsetpos__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fsetpos(arg1, NULL);
+void test__std__iswgraph__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswgraph(arg1) > 10) || (std::iswgraph(arg1) < 100)) {}
 }
 
-void test__fsetpos__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fsetpos(arg1, x);
+void test__std__iswgraph__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswgraph(x);
 }
 
-void test__std__fsetpos__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fsetpos(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__islower__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = islower(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fsetpos__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fsetpos(NULL, arg2);
+void test__islower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  islower(arg1);
 }
 
-void test__std__fsetpos__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fsetpos(x, arg2);
+void test__islower__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((islower(arg1) > 10) || (islower(arg1) < 100)) {}
 }
 
-void test__std__fsetpos__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fsetpos(arg1, NULL);
+void test__islower__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = islower(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fsetpos__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fsetpos(arg1, x);
+void test__islower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = islower(x);
 }
 
-void test__fgets__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fgets(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__islower__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::islower(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fgets__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fgets(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__islower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::islower(arg1);
 }
 
-void test__fgets__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fgets(NULL, arg2, arg3);
+void test__std__islower__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::islower(arg1) > 10) || (std::islower(arg1) < 100)) {}
 }
 
-void test__fgets__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    fgets(arg1, !x, arg3);
+void test__std__islower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::islower(x);
 }
 
-void test__fgets__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fgets(arg1, x, arg3);
+void test__iswlower__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = iswlower(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fgets__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fgets(arg1, arg2, NULL);
+void test__iswlower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswlower(arg1);
 }
 
-void test__fgets__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fgets(arg1, arg2, x);
+void test__iswlower__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswlower(arg1) > 10) || (iswlower(arg1) < 100)) {}
 }
 
-void test__std__fgets__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fgets(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswlower__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = iswlower(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fgets__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fgets(NULL, arg2, arg3);
+void test__iswlower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswlower(x);
 }
 
-void test__std__fgets__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::fgets(arg1, !x, arg3);
+void test__std__iswlower__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::iswlower(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fgets__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fgets(arg1, x, arg3);
+void test__std__iswlower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswlower(arg1);
 }
 
-void test__std__fgets__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fgets(arg1, arg2, NULL);
+void test__std__iswlower__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswlower(arg1) > 10) || (std::iswlower(arg1) < 100)) {}
 }
 
-void test__std__fgets__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fgets(arg1, arg2, x);
+void test__std__iswlower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswlower(x);
 }
 
-void test__fgetws__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fgetws(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isprint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isprint(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fgetws__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fgetws(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__isprint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isprint(arg1);
 }
 
-void test__fgetws__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fgetws(NULL, arg2, arg3);
+void test__isprint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isprint(arg1) > 10) || (isprint(arg1) < 100)) {}
 }
 
-void test__fgetws__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    fgetws(arg1, !x, arg3);
+void test__isprint__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isprint(p);
+  // cppcheck-suppress memleak
 }
 
-void test__fgetws__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fgetws(arg1, x, arg3);
+void test__isprint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isprint(x);
 }
 
-void test__fgetws__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fgetws(arg1, arg2, NULL);
+void test__std__isprint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isprint(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fgetws__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fgetws(arg1, arg2, x);
+void test__std__isprint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isprint(arg1);
 }
 
-void test__std__fgetws__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fgetws(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__isprint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isprint(arg1) > 10) || (std::isprint(arg1) < 100)) {}
 }
 
-void test__std__fgetws__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fgetws(NULL, arg2, arg3);
+void test__std__isprint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isprint(x);
 }
 
-void test__std__fgetws__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::fgetws(arg1, !x, arg3);
+void test__iswprint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = iswprint(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fgetws__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fgetws(arg1, x, arg3);
+void test__iswprint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswprint(arg1);
 }
 
-void test__std__fgetws__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fgetws(arg1, arg2, NULL);
+void test__iswprint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswprint(arg1) > 10) || (iswprint(arg1) < 100)) {}
 }
 
-void test__std__fgetws__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fgetws(arg1, arg2, x);
+void test__iswprint__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = iswprint(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ftell__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ftell(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswprint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswprint(x);
 }
 
-void test__ftell__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ftell(arg1);
+void test__std__iswprint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::iswprint(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ftell__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ftell(p);
-    // cppcheck-suppress memleak
+void test__std__iswprint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswprint(arg1);
 }
 
-void test__ftell__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = ftell(NULL);
+void test__std__iswprint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswprint(arg1) > 10) || (std::iswprint(arg1) < 100)) {}
 }
 
-void test__ftell__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = ftell(x);
+void test__std__iswprint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswprint(x);
 }
 
-void test__std__ftell__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ftell(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ispunct__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ispunct(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ftell__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ftell(arg1);
+void test__ispunct__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ispunct(arg1);
 }
 
-void test__std__ftell__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::ftell(NULL);
+void test__ispunct__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ispunct(arg1) > 10) || (ispunct(arg1) < 100)) {}
 }
 
-void test__std__ftell__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::ftell(x);
+void test__ispunct__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ispunct(p);
+  // cppcheck-suppress memleak
 }
 
-void test__fwide__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fwide(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ispunct__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ispunct(x);
 }
 
-void test__fwide__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fwide(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__ispunct__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ispunct(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fwide__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fwide(NULL, arg2);
+void test__std__ispunct__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ispunct(arg1);
 }
 
-void test__fwide__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fwide(x, arg2);
+void test__std__ispunct__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::ispunct(arg1) > 10) || (std::ispunct(arg1) < 100)) {}
 }
 
-void test__fwide__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fwide(arg1, x);
+void test__std__ispunct__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ispunct(x);
 }
 
-void test__std__fwide__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fwide(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswpunct__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = iswpunct(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fwide__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fwide(NULL, arg2);
+void test__iswpunct__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswpunct(arg1);
 }
 
-void test__std__fwide__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fwide(x, arg2);
+void test__iswpunct__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswpunct(arg1) > 10) || (iswpunct(arg1) < 100)) {}
 }
 
-void test__std__fwide__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fwide(arg1, x);
+void test__iswpunct__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = iswpunct(p);
+  // cppcheck-suppress memleak
 }
 
-void test__fwrite__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fwrite(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswpunct__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswpunct(x);
 }
 
-void test__fwrite__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fwrite(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__std__iswpunct__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::iswpunct(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fwrite__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fwrite(NULL, arg2, arg3, arg4);
+void test__std__iswpunct__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswpunct(arg1);
 }
 
-void test__fwrite__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fwrite(x, arg2, arg3, arg4);
+void test__std__iswpunct__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswpunct(arg1) > 10) || (std::iswpunct(arg1) < 100)) {}
 }
 
-void test__fwrite__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fwrite(arg1, x, arg3, arg4);
+void test__std__iswpunct__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswpunct(x);
 }
 
-void test__fwrite__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fwrite(arg1, arg2, x, arg4);
+void test__isspace__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isspace(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fwrite__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fwrite(arg1, arg2, arg3, NULL);
+void test__isspace__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isspace(arg1);
 }
 
-void test__fwrite__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fwrite(arg1, arg2, arg3, x);
+void test__isspace__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isspace(arg1) > 10) || (isspace(arg1) < 100)) {}
 }
 
-void test__std__fwrite__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fwrite(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isspace__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isspace(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__fwrite__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fwrite(NULL, arg2, arg3, arg4);
+void test__isspace__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isspace(x);
 }
 
-void test__std__fwrite__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fwrite(x, arg2, arg3, arg4);
+void test__std__isspace__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isspace(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fwrite__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fwrite(arg1, x, arg3, arg4);
+void test__std__isspace__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isspace(arg1);
 }
 
-void test__std__fwrite__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fwrite(arg1, arg2, x, arg4);
+void test__std__isspace__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isspace(arg1) > 10) || (std::isspace(arg1) < 100)) {}
 }
 
-void test__std__fwrite__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fwrite(arg1, arg2, arg3, NULL);
+void test__std__isspace__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isspace(x);
 }
 
-void test__std__fwrite__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fwrite(arg1, arg2, arg3, x);
+void test__iswspace__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = iswspace(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mblen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mblen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswspace__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswspace(arg1);
 }
 
-void test__mblen__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mblen(p, arg2);
-    // cppcheck-suppress memleak
+void test__iswspace__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswspace(arg1) > 10) || (iswspace(arg1) < 100)) {}
 }
 
-void test__mblen__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mblen(x, arg2);
+void test__iswspace__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = iswspace(p);
+  // cppcheck-suppress memleak
 }
 
-void test__mblen__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mblen(arg1, x);
+void test__iswspace__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswspace(x);
 }
 
-void test__std__mblen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::mblen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__iswspace__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::iswspace(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__mblen__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::mblen(x, arg2);
+void test__std__iswspace__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswspace(arg1);
 }
 
-void test__std__mblen__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::mblen(arg1, x);
+void test__std__iswspace__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswspace(arg1) > 10) || (std::iswspace(arg1) < 100)) {}
 }
 
-void test__mbtowc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mbtowc(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__iswspace__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswspace(x);
 }
 
-void test__mbtowc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mbtowc(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__isupper__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isupper(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbtowc__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mbtowc(arg1, x, arg3);
+void test__isupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isupper(arg1);
 }
 
-void test__mbtowc__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mbtowc(arg1, arg2, x);
+void test__isupper__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isupper(arg1) > 10) || (isupper(arg1) < 100)) {}
 }
 
-void test__std__mbtowc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::mbtowc(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isupper__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isupper(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__mbtowc__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::mbtowc(arg1, x, arg3);
+void test__isupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isupper(x);
 }
 
-void test__std__mbtowc__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::mbtowc(arg1, arg2, x);
+void test__std__isupper__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isupper(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbrlen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mbrlen(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__isupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isupper(arg1);
 }
 
-void test__mbrlen__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mbrlen(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__isupper__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isupper(arg1) > 10) || (std::isupper(arg1) < 100)) {}
 }
 
-void test__mbrlen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mbrlen(NULL, arg2, arg3);
+void test__std__isupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isupper(x);
 }
 
-void test__mbrlen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    mbrlen(x, arg2, arg3);
+void test__iswupper__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = iswupper(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbrlen__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mbrlen(arg1, x, arg3);
+void test__iswupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswupper(arg1);
 }
 
-void test__mbrlen__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mbrlen(arg1, arg2, x);
+void test__iswupper__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswupper(arg1) > 10) || (iswupper(arg1) < 100)) {}
 }
 
-void test__std__mbrlen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::mbrlen(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswupper__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = iswupper(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__mbrlen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::mbrlen(NULL, arg2, arg3);
+void test__iswupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswupper(x);
 }
 
-void test__std__mbrlen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::mbrlen(x, arg2, arg3);
+void test__std__iswupper__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::iswupper(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__mbrlen__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::mbrlen(arg1, x, arg3);
+void test__std__iswupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswupper(arg1);
 }
 
-void test__std__mbrlen__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::mbrlen(arg1, arg2, x);
+void test__std__iswupper__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswupper(arg1) > 10) || (std::iswupper(arg1) < 100)) {}
 }
 
-void test__btowc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = btowc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__iswupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswupper(x);
 }
 
-void test__btowc__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    btowc(arg1);
+void test__isxdigit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isxdigit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__btowc__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((btowc(arg1) > 10) || (btowc(arg1) < 100)) {}
+void test__isxdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isxdigit(arg1);
 }
 
-void test__btowc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = btowc(p);
-    // cppcheck-suppress memleak
+void test__isxdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isxdigit(arg1) > 10) || (isxdigit(arg1) < 100)) {}
 }
 
-void test__btowc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = btowc(x);
+void test__isxdigit__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isxdigit(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__btowc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::btowc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__btowc__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::btowc(arg1);
+void test__isxdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isxdigit(x);
 }
 
-void test__std__btowc__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::btowc(arg1) > 10) || (std::btowc(arg1) < 100)) {}
+void test__std__isxdigit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isxdigit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__btowc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::btowc(x);
+void test__std__isxdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isxdigit(arg1);
 }
 
-void test__mbsinit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mbsinit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__isxdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isxdigit(arg1) > 10) || (std::isxdigit(arg1) < 100)) {}
 }
-
-void test__mbsinit__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mbsinit(p);
-    // cppcheck-suppress memleak
+
+void test__std__isxdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isxdigit(x);
 }
 
-void test__mbsinit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mbsinit(x);
+void test__iswxdigit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = iswxdigit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__mbsinit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::mbsinit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswxdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswxdigit(arg1);
 }
 
-void test__std__mbsinit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::mbsinit(x);
+void test__iswxdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswxdigit(arg1) > 10) || (iswxdigit(arg1) < 100)) {}
 }
 
-void test__getwchar__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getwchar();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswxdigit__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = iswxdigit(p);
+  // cppcheck-suppress memleak
 }
-
-void test__getwchar__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getwchar();
-    // cppcheck-suppress memleak
+
+void test__iswxdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswxdigit(x);
 }
-
-void test__mbstowcs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mbstowcs(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__std__iswxdigit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::iswxdigit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbstowcs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mbstowcs(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__iswxdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswxdigit(arg1);
 }
 
-void test__mbstowcs__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mbstowcs(arg1, NULL, arg3);
-}
-
-void test__mbstowcs__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    mbstowcs(arg1, x, arg3);
-}
+void test__std__iswxdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswxdigit(arg1) > 10) || (std::iswxdigit(arg1) < 100)) {}
+}
 
-void test__mbstowcs__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mbstowcs(arg1, arg2, x);
-}
+void test__std__iswxdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswxdigit(x);
+}
 
-void test__std__mbstowcs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::mbstowcs(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__towctrans__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = towctrans(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__mbstowcs__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::mbstowcs(arg1, NULL, arg3);
+void test__towctrans__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  towctrans(arg1, arg2);
 }
 
-void test__std__mbstowcs__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::mbstowcs(arg1, x, arg3);
+void test__towctrans__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((towctrans(arg1, arg2) > 10) || (towctrans(arg1, arg2) < 100)) {}
 }
 
-void test__std__mbstowcs__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::mbstowcs(arg1, arg2, x);
+void test__towctrans__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = towctrans(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__mbsrtowcs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mbsrtowcs(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__towctrans__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = towctrans(x, arg2);
 }
 
-void test__mbsrtowcs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mbsrtowcs(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__towctrans__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = towctrans(arg1, x);
 }
 
-void test__mbsrtowcs__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mbsrtowcs(arg1, NULL, arg3, arg4);
+void test__std__towctrans__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::towctrans(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbsrtowcs__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    mbsrtowcs(arg1, x, arg3, arg4);
+void test__std__towctrans__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::towctrans(arg1, arg2);
 }
 
-void test__mbsrtowcs__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mbsrtowcs(arg1, arg2, x, arg4);
+void test__std__towctrans__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::towctrans(arg1, arg2) > 10) || (std::towctrans(arg1, arg2) < 100)) {}
 }
 
-void test__mbsrtowcs__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mbsrtowcs(arg1, arg2, arg3, NULL);
+void test__std__towctrans__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::towctrans(x, arg2);
 }
 
-void test__std__mbsrtowcs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::mbsrtowcs(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__towctrans__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::towctrans(arg1, x);
 }
 
-void test__std__mbsrtowcs__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::mbsrtowcs(arg1, NULL, arg3, arg4);
+void test__towlower__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = towlower(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__mbsrtowcs__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::mbsrtowcs(arg1, x, arg3, arg4);
+void test__towlower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  towlower(arg1);
 }
 
-void test__std__mbsrtowcs__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::mbsrtowcs(arg1, arg2, x, arg4);
+void test__towlower__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((towlower(arg1) > 10) || (towlower(arg1) < 100)) {}
 }
 
-void test__std__mbsrtowcs__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::mbsrtowcs(arg1, arg2, arg3, NULL);
+void test__towlower__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = towlower(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wctob__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wctob(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__towlower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = towlower(x);
 }
 
-void test__wctob__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wctob(arg1);
+void test__std__towlower__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::towlower(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wctob__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((wctob(arg1) > 10) || (wctob(arg1) < 100)) {}
+void test__std__towlower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::towlower(arg1);
 }
 
-void test__wctob__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wctob(p);
-    // cppcheck-suppress memleak
+void test__std__towlower__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::towlower(arg1) > 10) || (std::towlower(arg1) < 100)) {}
 }
 
-void test__wctob__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wctob(x);
+void test__std__towlower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::towlower(x);
 }
 
-void test__std__wctob__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wctob(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__towupper__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = towupper(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wctob__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wctob(arg1);
+void test__towupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  towupper(arg1);
 }
 
-void test__std__wctob__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::wctob(arg1) > 10) || (std::wctob(arg1) < 100)) {}
+void test__towupper__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((towupper(arg1) > 10) || (towupper(arg1) < 100)) {}
 }
 
-void test__std__wctob__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wctob(x);
+void test__towupper__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = towupper(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wctomb__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wctomb(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__towupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = towupper(x);
 }
 
-void test__wctomb__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wctomb(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__towupper__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::towupper(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wctomb__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wctomb(x, arg2);
+void test__std__towupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::towupper(arg1);
 }
 
-void test__wctomb__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wctomb(arg1, x);
+void test__std__towupper__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::towupper(arg1) > 10) || (std::towupper(arg1) < 100)) {}
 }
 
-void test__std__wctomb__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wctomb(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__towupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::towupper(x);
 }
 
-void test__std__wctomb__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wctomb(x, arg2);
+void test__wctrans__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wctrans(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wctomb__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wctomb(arg1, x);
-}
+void test__wctrans__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wctrans(arg1);
+}
 
-void test__wcstombs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcstombs(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wctrans__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wctrans(arg1) > 10) || (wctrans(arg1) < 100)) {}
 }
 
-void test__wcstombs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcstombs(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__wctrans__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wctrans(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wcstombs__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcstombs(arg1, NULL, arg3);
+void test__wctrans__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wctrans(NULL);
 }
 
-void test__wcstombs__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcstombs(arg1, x, arg3);
+void test__wctrans__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wctrans(x);
 }
 
-void test__wcstombs__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wcstombs(arg1, arg2, x);
-}
+void test__std__wctrans__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wctrans(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__std__wcstombs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wcstombs(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wctrans__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wctrans(arg1);
 }
 
-void test__std__wcstombs__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcstombs(arg1, NULL, arg3);
+void test__std__wctrans__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wctrans(arg1) > 10) || (std::wctrans(arg1) < 100)) {}
 }
 
-void test__std__wcstombs__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wcstombs(arg1, x, arg3);
+void test__std__wctrans__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wctrans(NULL);
 }
 
-void test__std__wcstombs__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wcstombs(arg1, arg2, x);
-}
+void test__std__wctrans__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wctrans(x);
+}
 
-void test__getchar__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getchar();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wctype__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wctype(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getchar__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getchar();
-    // cppcheck-suppress memleak
+void test__wctype__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wctype(arg1);
 }
 
-void test__ungetc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ungetc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wctype__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wctype(arg1) > 10) || (wctype(arg1) < 100)) {}
 }
 
-void test__ungetc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ungetc(p, arg2);
-    // cppcheck-suppress memleak
+void test__wctype__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wctype(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ungetc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ungetc(x, arg2);
+void test__wctype__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wctype(NULL);
 }
 
-void test__ungetc__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ungetc(arg1, NULL);
+void test__wctype__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wctype(x);
 }
 
-void test__ungetc__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    ungetc(arg1, x);
+void test__std__wctype__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wctype(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ungetc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::ungetc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wctype__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wctype(arg1);
 }
 
-void test__std__ungetc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::ungetc(x, arg2);
+void test__std__wctype__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wctype(arg1) > 10) || (std::wctype(arg1) < 100)) {}
 }
 
-void test__std__ungetc__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::ungetc(arg1, NULL);
+void test__std__wctype__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wctype(NULL);
 }
 
-void test__std__ungetc__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::ungetc(arg1, x);
+void test__std__wctype__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wctype(x);
 }
 
-void test__ungetwc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ungetwc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cabs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cabs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ungetwc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ungetwc(p, arg2);
-    // cppcheck-suppress memleak
+void test__cabs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cabs(arg1);
 }
 
-void test__ungetwc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ungetwc(x, arg2);
+void test__cabs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cabs(arg1) > 10) || (cabs(arg1) < 100)) {}
 }
 
-void test__ungetwc__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ungetwc(arg1, NULL);
+void test__cabs__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cabs(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ungetwc__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    ungetwc(arg1, x);
+void test__cabs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cabs(x);
 }
 
-void test__std__ungetwc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::ungetwc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cabsf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cabsf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ungetwc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::ungetwc(x, arg2);
+void test__cabsf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cabsf(arg1);
 }
 
-void test__std__ungetwc__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::ungetwc(arg1, NULL);
+void test__cabsf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cabsf(arg1) > 10) || (cabsf(arg1) < 100)) {}
 }
 
-void test__std__ungetwc__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::ungetwc(arg1, x);
+void test__cabsf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cabsf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__getenv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = getenv(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cabsf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cabsf(x);
 }
 
-void test__getenv__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    getenv(arg1);
+void test__cabsl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cabsl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getenv__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = getenv(p);
-    // cppcheck-suppress memleak
+void test__cabsl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cabsl(arg1);
 }
 
-void test__getenv__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = getenv(NULL);
+void test__cabsl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cabsl(arg1) > 10) || (cabsl(arg1) < 100)) {}
 }
 
-void test__getenv__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = getenv(x);
+void test__cabsl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cabsl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__getenv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::getenv(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cabsl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cabsl(x);
 }
 
-void test__std__getenv__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::getenv(arg1);
+void test__cacos__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cacos(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__getenv__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::getenv(NULL);
+void test__cacos__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cacos(arg1);
 }
 
-void test__std__getenv__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::getenv(x);
+void test__cacos__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cacos(arg1) > 10) || (cacos(arg1) < 100)) {}
 }
 
-void test__gets__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        gets(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cacos__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cacos(p);
+  // cppcheck-suppress memleak
 }
 
-void test__gets__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    gets(p);
-    // cppcheck-suppress memleak
+void test__cacos__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cacos(x);
 }
 
-void test__gets__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    gets(NULL);
+void test__cacosf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cacosf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__gets__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::gets(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cacosf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cacosf(arg1);
 }
 
-void test__std__gets__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::gets(NULL);
+void test__cacosf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cacosf(arg1) > 10) || (cacosf(arg1) < 100)) {}
 }
 
-void test__gets_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        gets_s(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cacosf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cacosf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__gets_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    gets_s(p, arg2);
-    // cppcheck-suppress memleak
+void test__cacosf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cacosf(x);
 }
 
-void test__gets_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    gets_s(NULL, arg2);
+void test__cacosl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cacosl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__gets_s__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    gets_s(arg1, !x);
+void test__cacosl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cacosl(arg1);
 }
 
-void test__gets_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    gets_s(arg1, x);
+void test__cacosl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cacosl(arg1) > 10) || (cacosl(arg1) < 100)) {}
 }
 
-void test__std__gets_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::gets_s(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cacosl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cacosl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__gets_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::gets_s(NULL, arg2);
+void test__cacosl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cacosl(x);
 }
 
-void test__std__gets_s__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::gets_s(arg1, !x);
+void test__cacosh__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cacosh(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__gets_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::gets_s(arg1, x);
+void test__cacosh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cacosh(arg1);
 }
 
-void test__gmtime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = gmtime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cacosh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cacosh(arg1) > 10) || (cacosh(arg1) < 100)) {}
 }
 
-void test__gmtime__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    gmtime(arg1);
+void test__cacosh__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cacosh(p);
+  // cppcheck-suppress memleak
 }
 
-void test__gmtime__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((gmtime(arg1) > 10) || (gmtime(arg1) < 100)) {}
+void test__cacosh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cacosh(x);
 }
 
-void test__gmtime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = gmtime(p);
-    // cppcheck-suppress memleak
+void test__cacoshf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cacoshf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__gmtime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = gmtime(NULL);
+void test__cacoshf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cacoshf(arg1);
 }
 
-void test__gmtime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = gmtime(x);
+void test__cacoshf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cacoshf(arg1) > 10) || (cacoshf(arg1) < 100)) {}
 }
 
-void test__std__gmtime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::gmtime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cacoshf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cacoshf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__gmtime__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::gmtime(arg1);
+void test__cacoshf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cacoshf(x);
 }
 
-void test__std__gmtime__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::gmtime(arg1) > 10) || (std::gmtime(arg1) < 100)) {}
+void test__cacoshl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cacoshl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__gmtime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::gmtime(NULL);
+void test__cacoshl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cacoshl(arg1);
 }
 
-void test__std__gmtime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::gmtime(x);
+void test__cacoshl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cacoshl(arg1) > 10) || (cacoshl(arg1) < 100)) {}
 }
 
-void test__isalnum__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isalnum(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cacoshl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cacoshl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__isalnum__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isalnum(arg1);
+void test__cacoshl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cacoshl(x);
 }
 
-void test__isalnum__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isalnum(arg1) > 10) || (isalnum(arg1) < 100)) {}
+void test__labs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = labs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isalnum__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isalnum(p);
-    // cppcheck-suppress memleak
+void test__labs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  labs(arg1);
 }
 
-void test__isalnum__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isalnum(x);
+void test__labs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((labs(arg1) > 10) || (labs(arg1) < 100)) {}
 }
 
-void test__std__isalnum__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isalnum(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__labs__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = labs(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__isalnum__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isalnum(arg1);
+void test__labs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = labs(x);
 }
 
-void test__std__isalnum__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isalnum(arg1) > 10) || (std::isalnum(arg1) < 100)) {}
+void test__std__labs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::labs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__isalnum__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isalnum(x);
+void test__std__labs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::labs(arg1);
 }
 
-void test__iswalnum__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = iswalnum(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__labs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::labs(arg1) > 10) || (std::labs(arg1) < 100)) {}
 }
 
-void test__iswalnum__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    iswalnum(arg1);
+void test__std__labs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::labs(x);
 }
 
-void test__iswalnum__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((iswalnum(arg1) > 10) || (iswalnum(arg1) < 100)) {}
+void test__llabs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = llabs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iswalnum__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = iswalnum(p);
-    // cppcheck-suppress memleak
+void test__llabs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  llabs(arg1);
 }
 
-void test__iswalnum__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = iswalnum(x);
+void test__llabs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((llabs(arg1) > 10) || (llabs(arg1) < 100)) {}
 }
 
-void test__std__iswalnum__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::iswalnum(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__llabs__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = llabs(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__iswalnum__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::iswalnum(arg1);
+void test__llabs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = llabs(x);
 }
 
-void test__std__iswalnum__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::iswalnum(arg1) > 10) || (std::iswalnum(arg1) < 100)) {}
+void test__std__llabs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::llabs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__iswalnum__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::iswalnum(x);
+void test__std__llabs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::llabs(arg1);
 }
 
-void test__isalpha__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isalpha(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__llabs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::llabs(arg1) > 10) || (std::llabs(arg1) < 100)) {}
 }
 
-void test__isalpha__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isalpha(arg1);
+void test__std__llabs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::llabs(x);
 }
 
-void test__isalpha__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isalpha(arg1) > 10) || (isalpha(arg1) < 100)) {}
+void test__ldexp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ldexp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isalpha__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isalpha(p);
-    // cppcheck-suppress memleak
+void test__ldexp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ldexp(arg1, arg2);
 }
 
-void test__isalpha__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isalpha(x);
+void test__ldexp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ldexp(arg1, arg2) > 10) || (ldexp(arg1, arg2) < 100)) {}
 }
 
-void test__std__isalpha__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isalpha(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ldexp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ldexp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__isalpha__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isalpha(arg1);
+void test__ldexp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ldexp(x, arg2);
 }
 
-void test__std__isalpha__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isalpha(arg1) > 10) || (std::isalpha(arg1) < 100)) {}
+void test__ldexp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ldexp(arg1, x);
 }
 
-void test__std__isalpha__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isalpha(x);
+void test__std__ldexp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ldexp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iswalpha__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = iswalpha(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ldexp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ldexp(arg1, arg2);
 }
 
-void test__iswalpha__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    iswalpha(arg1);
+void test__std__ldexp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::ldexp(arg1, arg2) > 10) || (std::ldexp(arg1, arg2) < 100)) {}
 }
 
-void test__iswalpha__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((iswalpha(arg1) > 10) || (iswalpha(arg1) < 100)) {}
+void test__std__ldexp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ldexp(x, arg2);
 }
 
-void test__iswalpha__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = iswalpha(p);
-    // cppcheck-suppress memleak
+void test__std__ldexp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ldexp(arg1, x);
 }
 
-void test__iswalpha__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = iswalpha(x);
+void test__ldexpf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ldexpf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__iswalpha__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::iswalpha(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ldexpf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ldexpf(arg1, arg2);
 }
 
-void test__std__iswalpha__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::iswalpha(arg1);
+void test__ldexpf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ldexpf(arg1, arg2) > 10) || (ldexpf(arg1, arg2) < 100)) {}
 }
 
-void test__std__iswalpha__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::iswalpha(arg1) > 10) || (std::iswalpha(arg1) < 100)) {}
+void test__ldexpf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ldexpf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__iswalpha__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::iswalpha(x);
+void test__ldexpf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ldexpf(x, arg2);
 }
 
-void test__isblank__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isblank(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ldexpf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ldexpf(arg1, x);
 }
 
-void test__isblank__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isblank(arg1);
+void test__std__ldexpf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ldexpf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isblank__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isblank(arg1) > 10) || (isblank(arg1) < 100)) {}
+void test__std__ldexpf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ldexpf(arg1, arg2);
 }
 
-void test__isblank__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isblank(p);
-    // cppcheck-suppress memleak
+void test__std__ldexpf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::ldexpf(arg1, arg2) > 10) || (std::ldexpf(arg1, arg2) < 100)) {}
 }
 
-void test__isblank__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isblank(x);
+void test__std__ldexpf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ldexpf(x, arg2);
 }
 
-void test__std__isblank__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isblank(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ldexpf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ldexpf(arg1, x);
 }
 
-void test__std__isblank__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isblank(arg1);
+void test__ldexpl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ldexpl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__isblank__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isblank(arg1) > 10) || (std::isblank(arg1) < 100)) {}
+void test__ldexpl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ldexpl(arg1, arg2);
 }
 
-void test__std__isblank__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isblank(x);
+void test__ldexpl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ldexpl(arg1, arg2) > 10) || (ldexpl(arg1, arg2) < 100)) {}
 }
 
-void test__iswblank__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = iswblank(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ldexpl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ldexpl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__iswblank__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    iswblank(arg1);
+void test__ldexpl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ldexpl(x, arg2);
 }
 
-void test__iswblank__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((iswblank(arg1) > 10) || (iswblank(arg1) < 100)) {}
+void test__ldexpl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ldexpl(arg1, x);
 }
 
-void test__iswblank__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = iswblank(p);
-    // cppcheck-suppress memleak
+void test__std__ldexpl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ldexpl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iswblank__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = iswblank(x);
+void test__std__ldexpl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ldexpl(arg1, arg2);
 }
 
-void test__std__iswblank__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::iswblank(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ldexpl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::ldexpl(arg1, arg2) > 10) || (std::ldexpl(arg1, arg2) < 100)) {}
 }
 
-void test__std__iswblank__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::iswblank(arg1);
+void test__std__ldexpl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ldexpl(x, arg2);
 }
 
-void test__std__iswblank__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::iswblank(arg1) > 10) || (std::iswblank(arg1) < 100)) {}
+void test__std__ldexpl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ldexpl(arg1, x);
 }
 
-void test__std__iswblank__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::iswblank(x);
+void test__lgamma__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = lgamma(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iscntrl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = iscntrl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__lgamma__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lgamma(arg1);
 }
 
-void test__iscntrl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    iscntrl(arg1);
+void test__lgamma__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lgamma(arg1) > 10) || (lgamma(arg1) < 100)) {}
 }
 
-void test__iscntrl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((iscntrl(arg1) > 10) || (iscntrl(arg1) < 100)) {}
+void test__lgamma__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = lgamma(p);
+  // cppcheck-suppress memleak
 }
 
-void test__iscntrl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = iscntrl(p);
-    // cppcheck-suppress memleak
+void test__lgamma__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lgamma(x);
 }
 
-void test__iscntrl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = iscntrl(x);
+void test__std__lgamma__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::lgamma(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__iscntrl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::iscntrl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__lgamma__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lgamma(arg1);
 }
 
-void test__std__iscntrl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::iscntrl(arg1);
+void test__std__lgamma__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lgamma(arg1) > 10) || (std::lgamma(arg1) < 100)) {}
 }
 
-void test__std__iscntrl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::iscntrl(arg1) > 10) || (std::iscntrl(arg1) < 100)) {}
+void test__std__lgamma__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lgamma(x);
 }
 
-void test__std__iscntrl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::iscntrl(x);
+void test__lgammaf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = lgammaf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iswcntrl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = iswcntrl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__lgammaf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lgammaf(arg1);
 }
 
-void test__iswcntrl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    iswcntrl(arg1);
+void test__lgammaf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lgammaf(arg1) > 10) || (lgammaf(arg1) < 100)) {}
 }
 
-void test__iswcntrl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((iswcntrl(arg1) > 10) || (iswcntrl(arg1) < 100)) {}
+void test__lgammaf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = lgammaf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__iswcntrl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = iswcntrl(p);
-    // cppcheck-suppress memleak
+void test__lgammaf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lgammaf(x);
 }
 
-void test__iswcntrl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = iswcntrl(x);
+void test__std__lgammaf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::lgammaf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__iswcntrl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::iswcntrl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__lgammaf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lgammaf(arg1);
 }
 
-void test__std__iswcntrl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::iswcntrl(arg1);
+void test__std__lgammaf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lgammaf(arg1) > 10) || (std::lgammaf(arg1) < 100)) {}
 }
 
-void test__std__iswcntrl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::iswcntrl(arg1) > 10) || (std::iswcntrl(arg1) < 100)) {}
+void test__std__lgammaf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lgammaf(x);
 }
 
-void test__std__iswcntrl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::iswcntrl(x);
+void test__lgammal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = lgammal(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iswctype__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = iswctype(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__lgammal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lgammal(arg1);
 }
 
-void test__iswctype__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    iswctype(arg1, arg2);
+void test__lgammal__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lgammal(arg1) > 10) || (lgammal(arg1) < 100)) {}
 }
 
-void test__iswctype__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((iswctype(arg1, arg2) > 10) || (iswctype(arg1, arg2) < 100)) {}
+void test__lgammal__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = lgammal(p);
+  // cppcheck-suppress memleak
 }
 
-void test__iswctype__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = iswctype(p, arg2);
-    // cppcheck-suppress memleak
+void test__lgammal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lgammal(x);
 }
 
-void test__iswctype__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = iswctype(x, arg2);
+void test__std__lgammal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::lgammal(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iswctype__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = iswctype(arg1, x);
+void test__std__lgammal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lgammal(arg1);
 }
 
-void test__std__iswctype__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::iswctype(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__lgammal__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lgammal(arg1) > 10) || (std::lgammal(arg1) < 100)) {}
 }
 
-void test__std__iswctype__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::iswctype(arg1, arg2);
+void test__std__lgammal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lgammal(x);
 }
 
-void test__std__iswctype__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::iswctype(arg1, arg2) > 10) || (std::iswctype(arg1, arg2) < 100)) {}
+void test__rint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = rint(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__iswctype__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::iswctype(x, arg2);
+void test__rint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  rint(arg1);
 }
 
-void test__std__iswctype__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::iswctype(arg1, x);
+void test__rint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((rint(arg1) > 10) || (rint(arg1) < 100)) {}
 }
 
-void test__isdigit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isdigit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__rint__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = rint(p);
+  // cppcheck-suppress memleak
 }
 
-void test__isdigit__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isdigit(arg1);
+void test__rint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = rint(x);
 }
 
-void test__isdigit__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isdigit(arg1) > 10) || (isdigit(arg1) < 100)) {}
+void test__std__rint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::rint(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isdigit__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isdigit(p);
-    // cppcheck-suppress memleak
+void test__std__rint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::rint(arg1);
 }
 
-void test__isdigit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isdigit(x);
+void test__std__rint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::rint(arg1) > 10) || (std::rint(arg1) < 100)) {}
 }
 
-void test__std__isdigit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isdigit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__rint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::rint(x);
 }
 
-void test__std__isdigit__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isdigit(arg1);
+void test__rintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = rintf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__isdigit__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isdigit(arg1) > 10) || (std::isdigit(arg1) < 100)) {}
+void test__rintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  rintf(arg1);
 }
 
-void test__std__isdigit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isdigit(x);
+void test__rintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((rintf(arg1) > 10) || (rintf(arg1) < 100)) {}
 }
 
-void test__iswdigit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = iswdigit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__rintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = rintf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__iswdigit__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    iswdigit(arg1);
+void test__rintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = rintf(x);
 }
 
-void test__iswdigit__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((iswdigit(arg1) > 10) || (iswdigit(arg1) < 100)) {}
+void test__std__rintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::rintf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iswdigit__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = iswdigit(p);
-    // cppcheck-suppress memleak
+void test__std__rintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::rintf(arg1);
 }
 
-void test__iswdigit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = iswdigit(x);
+void test__std__rintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::rintf(arg1) > 10) || (std::rintf(arg1) < 100)) {}
 }
 
-void test__std__iswdigit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::iswdigit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__rintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::rintf(x);
 }
 
-void test__std__iswdigit__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::iswdigit(arg1);
+void test__rintl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = rintl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__iswdigit__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::iswdigit(arg1) > 10) || (std::iswdigit(arg1) < 100)) {}
+void test__rintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  rintl(arg1);
 }
 
-void test__std__iswdigit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::iswdigit(x);
+void test__rintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((rintl(arg1) > 10) || (rintl(arg1) < 100)) {}
 }
 
-void test__isgraph__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isgraph(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__rintl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = rintl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__isgraph__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isgraph(arg1);
+void test__rintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = rintl(x);
 }
 
-void test__isgraph__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isgraph(arg1) > 10) || (isgraph(arg1) < 100)) {}
+void test__std__rintl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::rintl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isgraph__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isgraph(p);
-    // cppcheck-suppress memleak
+void test__std__rintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::rintl(arg1);
 }
 
-void test__isgraph__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isgraph(x);
+void test__std__rintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::rintl(arg1) > 10) || (std::rintl(arg1) < 100)) {}
 }
 
-void test__std__isgraph__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isgraph(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__rintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::rintl(x);
 }
 
-void test__std__isgraph__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isgraph(arg1);
+void test__lrint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = lrint(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__isgraph__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isgraph(arg1) > 10) || (std::isgraph(arg1) < 100)) {}
+void test__lrint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lrint(arg1);
 }
 
-void test__std__isgraph__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isgraph(x);
+void test__lrint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lrint(arg1) > 10) || (lrint(arg1) < 100)) {}
 }
 
-void test__iswgraph__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = iswgraph(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__lrint__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = lrint(p);
+  // cppcheck-suppress memleak
 }
 
-void test__iswgraph__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    iswgraph(arg1);
+void test__lrint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lrint(x);
 }
 
-void test__iswgraph__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((iswgraph(arg1) > 10) || (iswgraph(arg1) < 100)) {}
+void test__std__lrint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::lrint(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iswgraph__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = iswgraph(p);
-    // cppcheck-suppress memleak
+void test__std__lrint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lrint(arg1);
 }
 
-void test__iswgraph__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = iswgraph(x);
+void test__std__lrint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lrint(arg1) > 10) || (std::lrint(arg1) < 100)) {}
 }
 
-void test__std__iswgraph__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::iswgraph(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__lrint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lrint(x);
 }
 
-void test__std__iswgraph__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::iswgraph(arg1);
+void test__lrintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = lrintf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__iswgraph__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::iswgraph(arg1) > 10) || (std::iswgraph(arg1) < 100)) {}
+void test__lrintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lrintf(arg1);
 }
 
-void test__std__iswgraph__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::iswgraph(x);
+void test__lrintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lrintf(arg1) > 10) || (lrintf(arg1) < 100)) {}
 }
 
-void test__islower__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = islower(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__lrintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = lrintf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__islower__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    islower(arg1);
+void test__lrintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lrintf(x);
 }
 
-void test__islower__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((islower(arg1) > 10) || (islower(arg1) < 100)) {}
+void test__std__lrintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::lrintf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__islower__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = islower(p);
-    // cppcheck-suppress memleak
+void test__std__lrintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lrintf(arg1);
 }
 
-void test__islower__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = islower(x);
+void test__std__lrintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lrintf(arg1) > 10) || (std::lrintf(arg1) < 100)) {}
 }
 
-void test__std__islower__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::islower(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__lrintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lrintf(x);
 }
 
-void test__std__islower__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::islower(arg1);
+void test__lrintl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = lrintl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__islower__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::islower(arg1) > 10) || (std::islower(arg1) < 100)) {}
+void test__lrintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lrintl(arg1);
 }
 
-void test__std__islower__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::islower(x);
+void test__lrintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lrintl(arg1) > 10) || (lrintl(arg1) < 100)) {}
 }
 
-void test__iswlower__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = iswlower(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__lrintl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = lrintl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__iswlower__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    iswlower(arg1);
+void test__lrintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lrintl(x);
 }
 
-void test__iswlower__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((iswlower(arg1) > 10) || (iswlower(arg1) < 100)) {}
+void test__std__lrintl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::lrintl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iswlower__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = iswlower(p);
-    // cppcheck-suppress memleak
+void test__std__lrintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lrintl(arg1);
 }
 
-void test__iswlower__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = iswlower(x);
+void test__std__lrintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lrintl(arg1) > 10) || (std::lrintl(arg1) < 100)) {}
 }
 
-void test__std__iswlower__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::iswlower(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__lrintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lrintl(x);
 }
 
-void test__std__iswlower__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::iswlower(arg1);
+void test__llrint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = llrint(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__iswlower__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::iswlower(arg1) > 10) || (std::iswlower(arg1) < 100)) {}
+void test__llrint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  llrint(arg1);
 }
 
-void test__std__iswlower__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::iswlower(x);
+void test__llrint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((llrint(arg1) > 10) || (llrint(arg1) < 100)) {}
 }
 
-void test__isprint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isprint(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__llrint__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = llrint(p);
+  // cppcheck-suppress memleak
 }
 
-void test__isprint__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isprint(arg1);
+void test__llrint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = llrint(x);
 }
 
-void test__isprint__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isprint(arg1) > 10) || (isprint(arg1) < 100)) {}
+void test__std__llrint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::llrint(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isprint__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isprint(p);
-    // cppcheck-suppress memleak
+void test__std__llrint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::llrint(arg1);
 }
 
-void test__isprint__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isprint(x);
+void test__std__llrint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::llrint(arg1) > 10) || (std::llrint(arg1) < 100)) {}
 }
 
-void test__std__isprint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isprint(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__llrint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::llrint(x);
 }
 
-void test__std__isprint__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isprint(arg1);
+void test__llrintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = llrintf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__isprint__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isprint(arg1) > 10) || (std::isprint(arg1) < 100)) {}
+void test__llrintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  llrintf(arg1);
 }
 
-void test__std__isprint__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isprint(x);
+void test__llrintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((llrintf(arg1) > 10) || (llrintf(arg1) < 100)) {}
 }
 
-void test__iswprint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = iswprint(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__llrintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = llrintf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__iswprint__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    iswprint(arg1);
+void test__llrintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = llrintf(x);
 }
 
-void test__iswprint__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((iswprint(arg1) > 10) || (iswprint(arg1) < 100)) {}
+void test__std__llrintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::llrintf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iswprint__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = iswprint(p);
-    // cppcheck-suppress memleak
+void test__std__llrintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::llrintf(arg1);
 }
 
-void test__iswprint__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = iswprint(x);
+void test__std__llrintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::llrintf(arg1) > 10) || (std::llrintf(arg1) < 100)) {}
 }
 
-void test__std__iswprint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::iswprint(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__llrintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::llrintf(x);
 }
 
-void test__std__iswprint__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::iswprint(arg1);
+void test__llrintl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = llrintl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__iswprint__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::iswprint(arg1) > 10) || (std::iswprint(arg1) < 100)) {}
+void test__llrintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  llrintl(arg1);
 }
 
-void test__std__iswprint__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::iswprint(x);
+void test__llrintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((llrintl(arg1) > 10) || (llrintl(arg1) < 100)) {}
 }
 
-void test__ispunct__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ispunct(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__llrintl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = llrintl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ispunct__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ispunct(arg1);
+void test__llrintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = llrintl(x);
 }
 
-void test__ispunct__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ispunct(arg1) > 10) || (ispunct(arg1) < 100)) {}
+void test__std__llrintl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::llrintl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ispunct__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ispunct(p);
-    // cppcheck-suppress memleak
+void test__std__llrintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::llrintl(arg1);
 }
 
-void test__ispunct__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ispunct(x);
+void test__std__llrintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::llrintl(arg1) > 10) || (std::llrintl(arg1) < 100)) {}
 }
 
-void test__std__ispunct__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ispunct(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__llrintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::llrintl(x);
 }
 
-void test__std__ispunct__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ispunct(arg1);
+void test__llround__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = llround(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ispunct__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::ispunct(arg1) > 10) || (std::ispunct(arg1) < 100)) {}
+void test__llround__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  llround(arg1);
 }
 
-void test__std__ispunct__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::ispunct(x);
+void test__llround__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((llround(arg1) > 10) || (llround(arg1) < 100)) {}
 }
 
-void test__iswpunct__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = iswpunct(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__llround__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = llround(p);
+  // cppcheck-suppress memleak
 }
 
-void test__iswpunct__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    iswpunct(arg1);
+void test__llround__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = llround(x);
 }
 
-void test__iswpunct__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((iswpunct(arg1) > 10) || (iswpunct(arg1) < 100)) {}
+void test__std__llround__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::llround(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iswpunct__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = iswpunct(p);
-    // cppcheck-suppress memleak
+void test__std__llround__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::llround(arg1);
 }
 
-void test__iswpunct__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = iswpunct(x);
+void test__std__llround__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::llround(arg1) > 10) || (std::llround(arg1) < 100)) {}
 }
 
-void test__std__iswpunct__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::iswpunct(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__llround__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::llround(x);
 }
 
-void test__std__iswpunct__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::iswpunct(arg1);
+void test__llroundf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = llroundf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__iswpunct__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::iswpunct(arg1) > 10) || (std::iswpunct(arg1) < 100)) {}
+void test__llroundf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  llroundf(arg1);
 }
 
-void test__std__iswpunct__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::iswpunct(x);
+void test__llroundf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((llroundf(arg1) > 10) || (llroundf(arg1) < 100)) {}
 }
 
-void test__isspace__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isspace(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__llroundf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = llroundf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__isspace__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isspace(arg1);
+void test__llroundf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = llroundf(x);
 }
 
-void test__isspace__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isspace(arg1) > 10) || (isspace(arg1) < 100)) {}
+void test__std__llroundf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::llroundf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isspace__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isspace(p);
-    // cppcheck-suppress memleak
+void test__std__llroundf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::llroundf(arg1);
 }
 
-void test__isspace__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isspace(x);
+void test__std__llroundf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::llroundf(arg1) > 10) || (std::llroundf(arg1) < 100)) {}
 }
 
-void test__std__isspace__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isspace(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__llroundf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::llroundf(x);
 }
 
-void test__std__isspace__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isspace(arg1);
+void test__llroundl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = llroundl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__isspace__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isspace(arg1) > 10) || (std::isspace(arg1) < 100)) {}
+void test__llroundl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  llroundl(arg1);
 }
 
-void test__std__isspace__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isspace(x);
+void test__llroundl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((llroundl(arg1) > 10) || (llroundl(arg1) < 100)) {}
 }
 
-void test__iswspace__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = iswspace(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__llroundl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = llroundl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__iswspace__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    iswspace(arg1);
+void test__llroundl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = llroundl(x);
 }
 
-void test__iswspace__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((iswspace(arg1) > 10) || (iswspace(arg1) < 100)) {}
+void test__std__llroundl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::llroundl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iswspace__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = iswspace(p);
-    // cppcheck-suppress memleak
+void test__std__llroundl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::llroundl(arg1);
 }
 
-void test__iswspace__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = iswspace(x);
+void test__std__llroundl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::llroundl(arg1) > 10) || (std::llroundl(arg1) < 100)) {}
 }
 
-void test__std__iswspace__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::iswspace(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__llroundl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::llroundl(x);
 }
 
-void test__std__iswspace__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::iswspace(arg1);
+void test__lround__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = lround(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__iswspace__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::iswspace(arg1) > 10) || (std::iswspace(arg1) < 100)) {}
+void test__lround__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lround(arg1);
 }
 
-void test__std__iswspace__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::iswspace(x);
+void test__lround__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lround(arg1) > 10) || (lround(arg1) < 100)) {}
 }
 
-void test__isupper__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isupper(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__lround__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = lround(p);
+  // cppcheck-suppress memleak
 }
 
-void test__isupper__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isupper(arg1);
+void test__lround__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lround(x);
 }
 
-void test__isupper__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isupper(arg1) > 10) || (isupper(arg1) < 100)) {}
+void test__std__lround__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::lround(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isupper__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isupper(p);
-    // cppcheck-suppress memleak
+void test__std__lround__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lround(arg1);
 }
 
-void test__isupper__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isupper(x);
+void test__std__lround__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lround(arg1) > 10) || (std::lround(arg1) < 100)) {}
 }
 
-void test__std__isupper__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isupper(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__lround__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lround(x);
 }
 
-void test__std__isupper__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isupper(arg1);
+void test__lroundf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = lroundf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__isupper__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isupper(arg1) > 10) || (std::isupper(arg1) < 100)) {}
+void test__lroundf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lroundf(arg1);
 }
 
-void test__std__isupper__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isupper(x);
+void test__lroundf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lroundf(arg1) > 10) || (lroundf(arg1) < 100)) {}
 }
 
-void test__iswupper__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = iswupper(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__lroundf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = lroundf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__iswupper__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    iswupper(arg1);
+void test__lroundf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lroundf(x);
 }
 
-void test__iswupper__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((iswupper(arg1) > 10) || (iswupper(arg1) < 100)) {}
+void test__std__lroundf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::lroundf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iswupper__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = iswupper(p);
-    // cppcheck-suppress memleak
+void test__std__lroundf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lroundf(arg1);
 }
 
-void test__iswupper__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = iswupper(x);
+void test__std__lroundf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lroundf(arg1) > 10) || (std::lroundf(arg1) < 100)) {}
 }
 
-void test__std__iswupper__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::iswupper(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__lroundf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lroundf(x);
 }
 
-void test__std__iswupper__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::iswupper(arg1);
+void test__lroundl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = lroundl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__iswupper__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::iswupper(arg1) > 10) || (std::iswupper(arg1) < 100)) {}
+void test__lroundl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lroundl(arg1);
 }
 
-void test__std__iswupper__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::iswupper(x);
+void test__lroundl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lroundl(arg1) > 10) || (lroundl(arg1) < 100)) {}
 }
 
-void test__isxdigit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isxdigit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__lroundl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = lroundl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__isxdigit__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isxdigit(arg1);
+void test__lroundl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lroundl(x);
 }
 
-void test__isxdigit__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isxdigit(arg1) > 10) || (isxdigit(arg1) < 100)) {}
+void test__std__lroundl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::lroundl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isxdigit__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isxdigit(p);
-    // cppcheck-suppress memleak
+void test__std__lroundl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lroundl(arg1);
 }
 
-void test__isxdigit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isxdigit(x);
+void test__std__lroundl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lroundl(arg1) > 10) || (std::lroundl(arg1) < 100)) {}
 }
 
-void test__std__isxdigit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isxdigit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__lroundl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lroundl(x);
 }
 
-void test__std__isxdigit__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isxdigit(arg1);
+void test__rand__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = rand(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__isxdigit__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isxdigit(arg1) > 10) || (std::isxdigit(arg1) < 100)) {}
+void test__rand__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  rand();
 }
 
-void test__std__isxdigit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isxdigit(x);
+void test__rand__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = rand();
+  // cppcheck-suppress memleak
 }
 
-void test__iswxdigit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = iswxdigit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__srand__noreturn() {
+  int x = 1;
+  if (cond) { x=100; srand(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iswxdigit__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    iswxdigit(arg1);
+void test__srand__leakignore() {
+  char *p = malloc(10); *p=0;
+  srand(p);
+  // cppcheck-suppress memleak
 }
 
-void test__iswxdigit__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((iswxdigit(arg1) > 10) || (iswxdigit(arg1) < 100)) {}
+void test__srand__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  srand(x);
 }
 
-void test__iswxdigit__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = iswxdigit(p);
-    // cppcheck-suppress memleak
+void test__std__srand__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::srand(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__iswxdigit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = iswxdigit(x);
+void test__std__srand__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::srand(x);
 }
 
-void test__std__iswxdigit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::iswxdigit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ldiv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ldiv(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__iswxdigit__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::iswxdigit(arg1);
+void test__ldiv__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ldiv(arg1, arg2) > 10) || (ldiv(arg1, arg2) < 100)) {}
 }
 
-void test__std__iswxdigit__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::iswxdigit(arg1) > 10) || (std::iswxdigit(arg1) < 100)) {}
+void test__ldiv__leakignore() {
+  char *p = malloc(10); *p=0;
+  ldiv(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__iswxdigit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::iswxdigit(x);
+void test__ldiv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ldiv(x, arg2);
 }
 
-void test__towctrans__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = towctrans(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ldiv__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ldiv(arg1, x);
 }
 
-void test__towctrans__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    towctrans(arg1, arg2);
+void test__std__ldiv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::ldiv(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__towctrans__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((towctrans(arg1, arg2) > 10) || (towctrans(arg1, arg2) < 100)) {}
+void test__std__ldiv__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::ldiv(arg1, arg2) > 10) || (std::ldiv(arg1, arg2) < 100)) {}
 }
 
-void test__towctrans__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = towctrans(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__ldiv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ldiv(x, arg2);
 }
 
-void test__towctrans__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = towctrans(x, arg2);
+void test__std__ldiv__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ldiv(arg1, x);
 }
 
-void test__towctrans__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = towctrans(arg1, x);
+void test__lldiv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; lldiv(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__towctrans__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::towctrans(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__lldiv__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lldiv(arg1, arg2) > 10) || (lldiv(arg1, arg2) < 100)) {}
 }
 
-void test__std__towctrans__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::towctrans(arg1, arg2);
+void test__lldiv__leakignore() {
+  char *p = malloc(10); *p=0;
+  lldiv(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__towctrans__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::towctrans(arg1, arg2) > 10) || (std::towctrans(arg1, arg2) < 100)) {}
+void test__lldiv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  lldiv(x, arg2);
 }
 
-void test__std__towctrans__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::towctrans(x, arg2);
+void test__lldiv__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  lldiv(arg1, x);
 }
 
-void test__std__towctrans__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::towctrans(arg1, x);
+void test__std__lldiv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::lldiv(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__towlower__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = towlower(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__lldiv__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lldiv(arg1, arg2) > 10) || (std::lldiv(arg1, arg2) < 100)) {}
 }
 
-void test__towlower__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    towlower(arg1);
+void test__std__lldiv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::lldiv(x, arg2);
 }
 
-void test__towlower__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((towlower(arg1) > 10) || (towlower(arg1) < 100)) {}
+void test__std__lldiv__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::lldiv(arg1, x);
 }
 
-void test__towlower__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = towlower(p);
-    // cppcheck-suppress memleak
+void test__localtime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; localtime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__towlower__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = towlower(x);
+void test__localtime__leakignore() {
+  char *p = malloc(10); *p=0;
+  localtime(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__towlower__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::towlower(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__localtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  localtime(NULL);
 }
 
-void test__std__towlower__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::towlower(arg1);
+void test__localtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  localtime(x);
 }
 
-void test__std__towlower__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::towlower(arg1) > 10) || (std::towlower(arg1) < 100)) {}
+void test__std__localtime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::localtime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__towlower__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::towlower(x);
+void test__std__localtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::localtime(NULL);
 }
 
-void test__towupper__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = towupper(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__localtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::localtime(x);
 }
 
-void test__towupper__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    towupper(arg1);
+void test__localtime_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; localtime_s(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__towupper__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((towupper(arg1) > 10) || (towupper(arg1) < 100)) {}
+void test__localtime_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  localtime_s(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__towupper__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = towupper(p);
-    // cppcheck-suppress memleak
+void test__localtime_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  localtime_s(NULL, arg2);
 }
 
-void test__towupper__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = towupper(x);
+void test__localtime_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  localtime_s(arg1, NULL);
 }
 
-void test__std__towupper__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::towupper(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__localtime_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::localtime_s(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__towupper__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::towupper(arg1);
+void test__std__localtime_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::localtime_s(NULL, arg2);
 }
 
-void test__std__towupper__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::towupper(arg1) > 10) || (std::towupper(arg1) < 100)) {}
+void test__std__localtime_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::localtime_s(arg1, NULL);
 }
 
-void test__std__towupper__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::towupper(x);
+void test__log__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = log(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wctrans__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wctrans(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__log__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log(arg1);
 }
 
-void test__wctrans__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wctrans(arg1);
+void test__log__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = log(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wctrans__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((wctrans(arg1) > 10) || (wctrans(arg1) < 100)) {}
+void test__log__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log(x);
 }
 
-void test__wctrans__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wctrans(p);
-    // cppcheck-suppress memleak
+void test__std__log__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::log(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wctrans__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wctrans(NULL);
+void test__std__log__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log(arg1);
 }
 
-void test__wctrans__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wctrans(x);
+void test__std__log__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log(x);
 }
 
-void test__std__wctrans__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wctrans(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__logf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = logf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wctrans__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wctrans(arg1);
+void test__logf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  logf(arg1);
 }
 
-void test__std__wctrans__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::wctrans(arg1) > 10) || (std::wctrans(arg1) < 100)) {}
+void test__logf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = logf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wctrans__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wctrans(NULL);
+void test__logf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = logf(x);
 }
 
-void test__std__wctrans__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wctrans(x);
+void test__std__logf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::logf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wctype__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wctype(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__logf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::logf(arg1);
 }
 
-void test__wctype__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wctype(arg1);
+void test__std__logf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::logf(x);
 }
 
-void test__wctype__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((wctype(arg1) > 10) || (wctype(arg1) < 100)) {}
+void test__logl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = logl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wctype__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wctype(p);
-    // cppcheck-suppress memleak
+void test__logl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  logl(arg1);
 }
 
-void test__wctype__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wctype(NULL);
+void test__logl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = logl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wctype__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wctype(x);
+void test__logl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = logl(x);
 }
 
-void test__std__wctype__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wctype(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__logl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::logl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wctype__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wctype(arg1);
+void test__std__logl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::logl(arg1);
 }
 
-void test__std__wctype__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::wctype(arg1) > 10) || (std::wctype(arg1) < 100)) {}
+void test__std__logl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::logl(x);
 }
 
-void test__std__wctype__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wctype(NULL);
+void test__clog__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = clog(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wctype__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wctype(x);
+void test__clog__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  clog(arg1);
 }
 
-void test__cabs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cabs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__clog__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = clog(p);
+  // cppcheck-suppress memleak
 }
 
-void test__cabs__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cabs(arg1);
+void test__clog__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = clog(x);
 }
 
-void test__cabs__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cabs(arg1) > 10) || (cabs(arg1) < 100)) {}
+void test__clogf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = clogf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cabs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cabs(p);
-    // cppcheck-suppress memleak
+void test__clogf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  clogf(arg1);
 }
 
-void test__cabs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cabs(x);
+void test__clogf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = clogf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__cabsf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cabsf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__clogf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = clogf(x);
 }
 
-void test__cabsf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cabsf(arg1);
+void test__clogl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = clogl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cabsf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cabsf(arg1) > 10) || (cabsf(arg1) < 100)) {}
+void test__clogl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  clogl(arg1);
 }
 
-void test__cabsf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cabsf(p);
-    // cppcheck-suppress memleak
+void test__clogl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = clogl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__cabsf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cabsf(x);
+void test__clogl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = clogl(x);
 }
 
-void test__cabsl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cabsl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__conj__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = conj(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cabsl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cabsl(arg1);
+void test__conj__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  conj(arg1);
 }
 
-void test__cabsl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cabsl(arg1) > 10) || (cabsl(arg1) < 100)) {}
+void test__conj__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = conj(p);
+  // cppcheck-suppress memleak
 }
 
-void test__cabsl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cabsl(p);
-    // cppcheck-suppress memleak
+void test__conj__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = conj(x);
 }
 
-void test__cabsl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cabsl(x);
+void test__conjf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = conjf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cacos__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cacos(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__conjf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  conjf(arg1);
 }
 
-void test__cacos__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cacos(arg1);
+void test__conjf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = conjf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__cacos__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cacos(arg1) > 10) || (cacos(arg1) < 100)) {}
+void test__conjf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = conjf(x);
 }
 
-void test__cacos__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cacos(p);
-    // cppcheck-suppress memleak
+void test__conjl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = conjl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cacos__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cacos(x);
+void test__conjl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  conjl(arg1);
 }
 
-void test__cacosf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cacosf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__conjl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = conjl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__cacosf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cacosf(arg1);
+void test__conjl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = conjl(x);
 }
 
-void test__cacosf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cacosf(arg1) > 10) || (cacosf(arg1) < 100)) {}
+void test__fpclassify__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = fpclassify(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cacosf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cacosf(p);
-    // cppcheck-suppress memleak
+void test__fpclassify__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fpclassify(arg1);
 }
 
-void test__cacosf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cacosf(x);
+void test__fpclassify__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fpclassify(arg1) > 10) || (fpclassify(arg1) < 100)) {}
 }
 
-void test__cacosl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cacosl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fpclassify__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = fpclassify(p);
+  // cppcheck-suppress memleak
 }
 
-void test__cacosl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cacosl(arg1);
+void test__fpclassify__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fpclassify(x);
 }
 
-void test__cacosl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cacosl(arg1) > 10) || (cacosl(arg1) < 100)) {}
+void test__std__fpclassify__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::fpclassify(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cacosl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cacosl(p);
-    // cppcheck-suppress memleak
+void test__std__fpclassify__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fpclassify(arg1);
 }
 
-void test__cacosl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cacosl(x);
+void test__std__fpclassify__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fpclassify(arg1) > 10) || (std::fpclassify(arg1) < 100)) {}
 }
 
-void test__cacosh__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cacosh(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fpclassify__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fpclassify(x);
 }
 
-void test__cacosh__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cacosh(arg1);
+void test__isfinite__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isfinite(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cacosh__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cacosh(arg1) > 10) || (cacosh(arg1) < 100)) {}
+void test__isfinite__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isfinite(arg1);
 }
 
-void test__cacosh__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cacosh(p);
-    // cppcheck-suppress memleak
+void test__isfinite__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isfinite(arg1) > 10) || (isfinite(arg1) < 100)) {}
 }
 
-void test__cacosh__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cacosh(x);
+void test__isfinite__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isfinite(p);
+  // cppcheck-suppress memleak
 }
 
-void test__cacoshf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cacoshf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isfinite__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isfinite(x);
 }
 
-void test__cacoshf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cacoshf(arg1);
+void test__std__isfinite__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isfinite(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cacoshf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cacoshf(arg1) > 10) || (cacoshf(arg1) < 100)) {}
+void test__std__isfinite__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isfinite(arg1);
 }
 
-void test__cacoshf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cacoshf(p);
-    // cppcheck-suppress memleak
+void test__std__isfinite__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isfinite(arg1) > 10) || (std::isfinite(arg1) < 100)) {}
 }
 
-void test__cacoshf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cacoshf(x);
+void test__std__isfinite__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isfinite(x);
 }
 
-void test__cacoshl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cacoshl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isgreater__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isgreater(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cacoshl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cacoshl(arg1);
+void test__isgreater__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isgreater(arg1, arg2);
 }
 
-void test__cacoshl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cacoshl(arg1) > 10) || (cacoshl(arg1) < 100)) {}
+void test__isgreater__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isgreater(arg1, arg2) > 10) || (isgreater(arg1, arg2) < 100)) {}
 }
 
-void test__cacoshl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cacoshl(p);
-    // cppcheck-suppress memleak
+void test__isgreater__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isgreater(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__cacoshl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cacoshl(x);
+void test__isgreater__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isgreater(x, arg2);
 }
 
-void test__labs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = labs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isgreater__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isgreater(arg1, x);
 }
 
-void test__labs__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    labs(arg1);
+void test__std__isgreater__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isgreater(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__labs__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((labs(arg1) > 10) || (labs(arg1) < 100)) {}
+void test__std__isgreater__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isgreater(arg1, arg2);
 }
 
-void test__labs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = labs(p);
-    // cppcheck-suppress memleak
+void test__std__isgreater__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isgreater(arg1, arg2) > 10) || (std::isgreater(arg1, arg2) < 100)) {}
 }
 
-void test__labs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = labs(x);
+void test__std__isgreater__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isgreater(x, arg2);
 }
 
-void test__std__labs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::labs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__isgreater__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isgreater(arg1, x);
 }
 
-void test__std__labs__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::labs(arg1);
+void test__isgreaterequal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isgreaterequal(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__labs__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::labs(arg1) > 10) || (std::labs(arg1) < 100)) {}
+void test__isgreaterequal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isgreaterequal(arg1, arg2);
 }
 
-void test__std__labs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::labs(x);
+void test__isgreaterequal__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isgreaterequal(arg1, arg2) > 10) || (isgreaterequal(arg1, arg2) < 100)) {}
 }
 
-void test__llabs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = llabs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isgreaterequal__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isgreaterequal(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__llabs__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    llabs(arg1);
+void test__isgreaterequal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isgreaterequal(x, arg2);
 }
 
-void test__llabs__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((llabs(arg1) > 10) || (llabs(arg1) < 100)) {}
+void test__isgreaterequal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isgreaterequal(arg1, x);
 }
 
-void test__llabs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = llabs(p);
-    // cppcheck-suppress memleak
+void test__std__isgreaterequal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isgreaterequal(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__llabs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = llabs(x);
+void test__std__isgreaterequal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isgreaterequal(arg1, arg2);
 }
 
-void test__std__llabs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::llabs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__isgreaterequal__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isgreaterequal(arg1, arg2) > 10) || (std::isgreaterequal(arg1, arg2) < 100)) {}
 }
 
-void test__std__llabs__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::llabs(arg1);
+void test__std__isgreaterequal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isgreaterequal(x, arg2);
 }
 
-void test__std__llabs__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::llabs(arg1) > 10) || (std::llabs(arg1) < 100)) {}
+void test__std__isgreaterequal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isgreaterequal(arg1, x);
 }
 
-void test__std__llabs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::llabs(x);
+void test__isinf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isinf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ldexp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ldexp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isinf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isinf(arg1);
 }
 
-void test__ldexp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ldexp(arg1, arg2);
+void test__isinf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isinf(arg1) > 10) || (isinf(arg1) < 100)) {}
 }
 
-void test__ldexp__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ldexp(arg1, arg2) > 10) || (ldexp(arg1, arg2) < 100)) {}
+void test__isinf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isinf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ldexp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ldexp(p, arg2);
-    // cppcheck-suppress memleak
+void test__isinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isinf(x);
 }
 
-void test__ldexp__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ldexp(x, arg2);
+void test__std__isinf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isinf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ldexp__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ldexp(arg1, x);
+void test__std__isinf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isinf(arg1);
 }
 
-void test__std__ldexp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ldexp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__isinf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isinf(arg1) > 10) || (std::isinf(arg1) < 100)) {}
 }
 
-void test__std__ldexp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ldexp(arg1, arg2);
+void test__std__isinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isinf(x);
 }
 
-void test__std__ldexp__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::ldexp(arg1, arg2) > 10) || (std::ldexp(arg1, arg2) < 100)) {}
+void test__logb__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = logb(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ldexp__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::ldexp(x, arg2);
+void test__logb__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  logb(arg1);
 }
 
-void test__std__ldexp__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::ldexp(arg1, x);
+void test__logb__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((logb(arg1) > 10) || (logb(arg1) < 100)) {}
 }
 
-void test__ldexpf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ldexpf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__logb__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = logb(p);
+  // cppcheck-suppress memleak
 }
 
-void test__ldexpf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ldexpf(arg1, arg2);
+void test__logb__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = logb(x);
 }
 
-void test__ldexpf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ldexpf(arg1, arg2) > 10) || (ldexpf(arg1, arg2) < 100)) {}
+void test__std__logb__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::logb(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ldexpf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ldexpf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__logb__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::logb(arg1);
 }
 
-void test__ldexpf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ldexpf(x, arg2);
+void test__std__logb__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::logb(arg1) > 10) || (std::logb(arg1) < 100)) {}
 }
 
-void test__ldexpf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ldexpf(arg1, x);
+void test__std__logb__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::logb(x);
 }
 
-void test__std__ldexpf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ldexpf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__logbf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = logbf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ldexpf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ldexpf(arg1, arg2);
+void test__logbf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  logbf(arg1);
 }
 
-void test__std__ldexpf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::ldexpf(arg1, arg2) > 10) || (std::ldexpf(arg1, arg2) < 100)) {}
+void test__logbf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((logbf(arg1) > 10) || (logbf(arg1) < 100)) {}
 }
 
-void test__std__ldexpf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::ldexpf(x, arg2);
+void test__logbf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = logbf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__ldexpf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::ldexpf(arg1, x);
+void test__logbf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = logbf(x);
 }
 
-void test__ldexpl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ldexpl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__logbf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::logbf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ldexpl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ldexpl(arg1, arg2);
+void test__std__logbf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::logbf(arg1);
 }
 
-void test__ldexpl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ldexpl(arg1, arg2) > 10) || (ldexpl(arg1, arg2) < 100)) {}
+void test__std__logbf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::logbf(arg1) > 10) || (std::logbf(arg1) < 100)) {}
 }
 
-void test__ldexpl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ldexpl(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__logbf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::logbf(x);
 }
 
-void test__ldexpl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ldexpl(x, arg2);
+void test__logbl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = logbl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ldexpl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ldexpl(arg1, x);
+void test__logbl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  logbl(arg1);
 }
 
-void test__std__ldexpl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ldexpl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__logbl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((logbl(arg1) > 10) || (logbl(arg1) < 100)) {}
 }
 
-void test__std__ldexpl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ldexpl(arg1, arg2);
+void test__logbl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = logbl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__ldexpl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::ldexpl(arg1, arg2) > 10) || (std::ldexpl(arg1, arg2) < 100)) {}
+void test__logbl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = logbl(x);
 }
 
-void test__std__ldexpl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::ldexpl(x, arg2);
+void test__std__logbl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::logbl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ldexpl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::ldexpl(arg1, x);
+void test__std__logbl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::logbl(arg1);
 }
 
-void test__lgamma__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = lgamma(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__logbl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::logbl(arg1) > 10) || (std::logbl(arg1) < 100)) {}
 }
 
-void test__lgamma__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    lgamma(arg1);
+void test__std__logbl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::logbl(x);
 }
 
-void test__lgamma__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((lgamma(arg1) > 10) || (lgamma(arg1) < 100)) {}
+void test__isless__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isless(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__lgamma__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = lgamma(p);
-    // cppcheck-suppress memleak
+void test__isless__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isless(arg1, arg2);
 }
 
-void test__lgamma__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = lgamma(x);
+void test__isless__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isless(arg1, arg2) > 10) || (isless(arg1, arg2) < 100)) {}
 }
 
-void test__std__lgamma__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::lgamma(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isless__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isless(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__lgamma__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::lgamma(arg1);
+void test__isless__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isless(x, arg2);
 }
 
-void test__std__lgamma__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::lgamma(arg1) > 10) || (std::lgamma(arg1) < 100)) {}
+void test__isless__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isless(arg1, x);
 }
 
-void test__std__lgamma__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::lgamma(x);
+void test__std__isless__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isless(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__lgammaf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = lgammaf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__isless__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isless(arg1, arg2);
 }
 
-void test__lgammaf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    lgammaf(arg1);
+void test__std__isless__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isless(arg1, arg2) > 10) || (std::isless(arg1, arg2) < 100)) {}
 }
 
-void test__lgammaf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((lgammaf(arg1) > 10) || (lgammaf(arg1) < 100)) {}
+void test__std__isless__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isless(x, arg2);
 }
 
-void test__lgammaf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = lgammaf(p);
-    // cppcheck-suppress memleak
+void test__std__isless__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isless(arg1, x);
 }
 
-void test__lgammaf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = lgammaf(x);
+void test__islessequal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = islessequal(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__lgammaf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::lgammaf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__islessequal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  islessequal(arg1, arg2);
 }
 
-void test__std__lgammaf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::lgammaf(arg1);
+void test__islessequal__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((islessequal(arg1, arg2) > 10) || (islessequal(arg1, arg2) < 100)) {}
 }
 
-void test__std__lgammaf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::lgammaf(arg1) > 10) || (std::lgammaf(arg1) < 100)) {}
+void test__islessequal__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = islessequal(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__lgammaf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::lgammaf(x);
+void test__islessequal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = islessequal(x, arg2);
 }
 
-void test__lgammal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = lgammal(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__islessequal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = islessequal(arg1, x);
 }
 
-void test__lgammal__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    lgammal(arg1);
+void test__std__islessequal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::islessequal(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__lgammal__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((lgammal(arg1) > 10) || (lgammal(arg1) < 100)) {}
+void test__std__islessequal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::islessequal(arg1, arg2);
 }
 
-void test__lgammal__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = lgammal(p);
-    // cppcheck-suppress memleak
+void test__std__islessequal__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::islessequal(arg1, arg2) > 10) || (std::islessequal(arg1, arg2) < 100)) {}
 }
 
-void test__lgammal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = lgammal(x);
+void test__std__islessequal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::islessequal(x, arg2);
 }
 
-void test__std__lgammal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::lgammal(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__islessequal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::islessequal(arg1, x);
 }
 
-void test__std__lgammal__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::lgammal(arg1);
+void test__islessgreater__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = islessgreater(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__lgammal__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::lgammal(arg1) > 10) || (std::lgammal(arg1) < 100)) {}
+void test__islessgreater__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  islessgreater(arg1, arg2);
 }
 
-void test__std__lgammal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::lgammal(x);
+void test__islessgreater__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((islessgreater(arg1, arg2) > 10) || (islessgreater(arg1, arg2) < 100)) {}
 }
 
-void test__rint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = rint(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__islessgreater__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = islessgreater(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__rint__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    rint(arg1);
+void test__islessgreater__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = islessgreater(x, arg2);
 }
 
-void test__rint__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((rint(arg1) > 10) || (rint(arg1) < 100)) {}
+void test__islessgreater__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = islessgreater(arg1, x);
 }
 
-void test__rint__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = rint(p);
-    // cppcheck-suppress memleak
+void test__std__islessgreater__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::islessgreater(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__rint__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = rint(x);
+void test__std__islessgreater__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::islessgreater(arg1, arg2);
 }
 
-void test__std__rint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::rint(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__islessgreater__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::islessgreater(arg1, arg2) > 10) || (std::islessgreater(arg1, arg2) < 100)) {}
 }
 
-void test__std__rint__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::rint(arg1);
+void test__std__islessgreater__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::islessgreater(x, arg2);
 }
 
-void test__std__rint__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::rint(arg1) > 10) || (std::rint(arg1) < 100)) {}
+void test__std__islessgreater__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::islessgreater(arg1, x);
 }
 
-void test__std__rint__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::rint(x);
+void test__nan__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = nan(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__rintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = rintf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__nan__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nan(arg1);
 }
 
-void test__rintf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    rintf(arg1);
+void test__nan__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nan(arg1) > 10) || (nan(arg1) < 100)) {}
 }
 
-void test__rintf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((rintf(arg1) > 10) || (rintf(arg1) < 100)) {}
+void test__nan__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = nan(p);
+  // cppcheck-suppress memleak
 }
 
-void test__rintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = rintf(p);
-    // cppcheck-suppress memleak
+void test__nan__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = nan(NULL);
 }
 
-void test__rintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = rintf(x);
+void test__nan__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = nan(x);
 }
 
-void test__std__rintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::rintf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__nan__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::nan(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__rintf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::rintf(arg1);
+void test__std__nan__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nan(arg1);
 }
 
-void test__std__rintf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::rintf(arg1) > 10) || (std::rintf(arg1) < 100)) {}
+void test__std__nan__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nan(arg1) > 10) || (std::nan(arg1) < 100)) {}
 }
 
-void test__std__rintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::rintf(x);
+void test__std__nan__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::nan(NULL);
 }
 
-void test__rintl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = rintl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__nan__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::nan(x);
 }
 
-void test__rintl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    rintl(arg1);
+void test__nanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = nanf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__rintl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((rintl(arg1) > 10) || (rintl(arg1) < 100)) {}
+void test__nanf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nanf(arg1);
 }
 
-void test__rintl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = rintl(p);
-    // cppcheck-suppress memleak
+void test__nanf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nanf(arg1) > 10) || (nanf(arg1) < 100)) {}
 }
 
-void test__rintl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = rintl(x);
+void test__nanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = nanf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__rintl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::rintl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__nanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = nanf(NULL);
 }
 
-void test__std__rintl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::rintl(arg1);
+void test__nanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = nanf(x);
 }
 
-void test__std__rintl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::rintl(arg1) > 10) || (std::rintl(arg1) < 100)) {}
+void test__std__nanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::nanf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__rintl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::rintl(x);
+void test__std__nanf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nanf(arg1);
 }
 
-void test__lrint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = lrint(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__nanf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nanf(arg1) > 10) || (std::nanf(arg1) < 100)) {}
 }
 
-void test__lrint__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    lrint(arg1);
+void test__std__nanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::nanf(NULL);
 }
 
-void test__lrint__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((lrint(arg1) > 10) || (lrint(arg1) < 100)) {}
+void test__std__nanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::nanf(x);
 }
 
-void test__lrint__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = lrint(p);
-    // cppcheck-suppress memleak
+void test__nanl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = nanl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__lrint__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = lrint(x);
+void test__nanl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nanl(arg1);
 }
 
-void test__std__lrint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::lrint(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__nanl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nanl(arg1) > 10) || (nanl(arg1) < 100)) {}
 }
 
-void test__std__lrint__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::lrint(arg1);
+void test__nanl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = nanl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__lrint__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::lrint(arg1) > 10) || (std::lrint(arg1) < 100)) {}
+void test__nanl__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = nanl(NULL);
 }
 
-void test__std__lrint__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::lrint(x);
+void test__nanl__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = nanl(x);
 }
 
-void test__lrintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = lrintf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__nanl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::nanl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__lrintf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    lrintf(arg1);
+void test__std__nanl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nanl(arg1);
 }
 
-void test__lrintf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((lrintf(arg1) > 10) || (lrintf(arg1) < 100)) {}
+void test__std__nanl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nanl(arg1) > 10) || (std::nanl(arg1) < 100)) {}
 }
 
-void test__lrintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = lrintf(p);
-    // cppcheck-suppress memleak
+void test__std__nanl__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::nanl(NULL);
 }
 
-void test__lrintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = lrintf(x);
+void test__std__nanl__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::nanl(x);
 }
 
-void test__std__lrintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::lrintf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isnan__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isnan(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__lrintf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::lrintf(arg1);
+void test__isnan__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isnan(arg1);
 }
 
-void test__std__lrintf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::lrintf(arg1) > 10) || (std::lrintf(arg1) < 100)) {}
+void test__isnan__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isnan(arg1) > 10) || (isnan(arg1) < 100)) {}
 }
 
-void test__std__lrintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::lrintf(x);
+void test__isnan__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isnan(p);
+  // cppcheck-suppress memleak
 }
 
-void test__lrintl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = lrintl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isnan__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isnan(x);
 }
 
-void test__lrintl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    lrintl(arg1);
+void test__std__isnan__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isnan(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__lrintl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((lrintl(arg1) > 10) || (lrintl(arg1) < 100)) {}
+void test__std__isnan__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isnan(arg1);
 }
 
-void test__lrintl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = lrintl(p);
-    // cppcheck-suppress memleak
+void test__std__isnan__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isnan(arg1) > 10) || (std::isnan(arg1) < 100)) {}
 }
 
-void test__lrintl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = lrintl(x);
+void test__std__isnan__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isnan(x);
 }
 
-void test__std__lrintl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::lrintl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isnormal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isnormal(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__lrintl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::lrintl(arg1);
+void test__isnormal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isnormal(arg1);
 }
 
-void test__std__lrintl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::lrintl(arg1) > 10) || (std::lrintl(arg1) < 100)) {}
+void test__isnormal__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isnormal(arg1) > 10) || (isnormal(arg1) < 100)) {}
 }
 
-void test__std__lrintl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::lrintl(x);
+void test__isnormal__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isnormal(p);
+  // cppcheck-suppress memleak
 }
 
-void test__llrint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = llrint(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isnormal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isnormal(x);
 }
 
-void test__llrint__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    llrint(arg1);
+void test__std__isnormal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isnormal(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__llrint__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((llrint(arg1) > 10) || (llrint(arg1) < 100)) {}
+void test__std__isnormal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isnormal(arg1);
 }
 
-void test__llrint__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = llrint(p);
-    // cppcheck-suppress memleak
+void test__std__isnormal__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isnormal(arg1) > 10) || (std::isnormal(arg1) < 100)) {}
 }
 
-void test__llrint__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = llrint(x);
+void test__std__isnormal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isnormal(x);
 }
 
-void test__std__llrint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::llrint(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isunordered__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = isunordered(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__llrint__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::llrint(arg1);
+void test__isunordered__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isunordered(arg1, arg2);
 }
 
-void test__std__llrint__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::llrint(arg1) > 10) || (std::llrint(arg1) < 100)) {}
+void test__isunordered__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isunordered(arg1, arg2) > 10) || (isunordered(arg1, arg2) < 100)) {}
 }
 
-void test__std__llrint__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::llrint(x);
+void test__isunordered__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = isunordered(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__llrintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = llrintf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__isunordered__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isunordered(x, arg2);
 }
 
-void test__llrintf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    llrintf(arg1);
+void test__isunordered__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isunordered(arg1, x);
 }
 
-void test__llrintf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((llrintf(arg1) > 10) || (llrintf(arg1) < 100)) {}
+void test__std__isunordered__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::isunordered(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__llrintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = llrintf(p);
-    // cppcheck-suppress memleak
+void test__std__isunordered__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isunordered(arg1, arg2);
 }
 
-void test__llrintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = llrintf(x);
+void test__std__isunordered__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isunordered(arg1, arg2) > 10) || (std::isunordered(arg1, arg2) < 100)) {}
 }
 
-void test__std__llrintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::llrintf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__isunordered__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isunordered(x, arg2);
 }
 
-void test__std__llrintf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::llrintf(arg1);
+void test__std__isunordered__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isunordered(arg1, x);
 }
 
-void test__std__llrintf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::llrintf(arg1) > 10) || (std::llrintf(arg1) < 100)) {}
+void test__ilogb__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ilogb(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__llrintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::llrintf(x);
+void test__ilogb__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ilogb(arg1);
 }
 
-void test__llrintl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = llrintl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ilogb__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ilogb(arg1) > 10) || (ilogb(arg1) < 100)) {}
 }
 
-void test__llrintl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    llrintl(arg1);
+void test__ilogb__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ilogb(p);
+  // cppcheck-suppress memleak
 }
 
-void test__llrintl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((llrintl(arg1) > 10) || (llrintl(arg1) < 100)) {}
+void test__ilogb__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ilogb(x);
 }
 
-void test__llrintl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = llrintl(p);
-    // cppcheck-suppress memleak
+void test__std__ilogb__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ilogb(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__llrintl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = llrintl(x);
+void test__std__ilogb__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ilogb(arg1);
 }
 
-void test__std__llrintl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::llrintl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ilogb__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::ilogb(arg1) > 10) || (std::ilogb(arg1) < 100)) {}
 }
 
-void test__std__llrintl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::llrintl(arg1);
+void test__std__ilogb__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ilogb(x);
 }
 
-void test__std__llrintl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::llrintl(arg1) > 10) || (std::llrintl(arg1) < 100)) {}
+void test__ilogbf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ilogbf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__llrintl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::llrintl(x);
+void test__ilogbf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ilogbf(arg1);
 }
 
-void test__llround__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = llround(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ilogbf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ilogbf(arg1) > 10) || (ilogbf(arg1) < 100)) {}
 }
 
-void test__llround__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    llround(arg1);
+void test__ilogbf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ilogbf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__llround__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((llround(arg1) > 10) || (llround(arg1) < 100)) {}
+void test__ilogbf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ilogbf(x);
 }
 
-void test__llround__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = llround(p);
-    // cppcheck-suppress memleak
+void test__std__ilogbf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ilogbf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__llround__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = llround(x);
+void test__std__ilogbf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ilogbf(arg1);
 }
 
-void test__std__llround__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::llround(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ilogbf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::ilogbf(arg1) > 10) || (std::ilogbf(arg1) < 100)) {}
 }
 
-void test__std__llround__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::llround(arg1);
+void test__std__ilogbf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ilogbf(x);
 }
 
-void test__std__llround__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::llround(arg1) > 10) || (std::llround(arg1) < 100)) {}
+void test__ilogbl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ilogbl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__llround__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::llround(x);
+void test__ilogbl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ilogbl(arg1);
 }
 
-void test__llroundf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = llroundf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ilogbl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ilogbl(arg1) > 10) || (ilogbl(arg1) < 100)) {}
 }
 
-void test__llroundf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    llroundf(arg1);
+void test__ilogbl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ilogbl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__llroundf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((llroundf(arg1) > 10) || (llroundf(arg1) < 100)) {}
+void test__ilogbl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ilogbl(x);
 }
 
-void test__llroundf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = llroundf(p);
-    // cppcheck-suppress memleak
+void test__std__ilogbl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ilogbl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__llroundf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = llroundf(x);
+void test__std__ilogbl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ilogbl(arg1);
 }
 
-void test__std__llroundf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::llroundf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ilogbl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::ilogbl(arg1) > 10) || (std::ilogbl(arg1) < 100)) {}
 }
 
-void test__std__llroundf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::llroundf(arg1);
+void test__std__ilogbl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ilogbl(x);
 }
 
-void test__std__llroundf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::llroundf(arg1) > 10) || (std::llroundf(arg1) < 100)) {}
+void test__log10__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = log10(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__llroundf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::llroundf(x);
+void test__log10__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log10(arg1);
 }
 
-void test__llroundl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = llroundl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__log10__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log10(arg1) > 10) || (log10(arg1) < 100)) {}
 }
 
-void test__llroundl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    llroundl(arg1);
+void test__log10__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = log10(p);
+  // cppcheck-suppress memleak
 }
 
-void test__llroundl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((llroundl(arg1) > 10) || (llroundl(arg1) < 100)) {}
+void test__log10__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log10(x);
 }
 
-void test__llroundl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = llroundl(p);
-    // cppcheck-suppress memleak
+void test__std__log10__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::log10(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__llroundl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = llroundl(x);
+void test__std__log10__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log10(arg1);
 }
 
-void test__std__llroundl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::llroundl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__log10__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log10(arg1) > 10) || (std::log10(arg1) < 100)) {}
 }
 
-void test__std__llroundl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::llroundl(arg1);
+void test__std__log10__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log10(x);
 }
 
-void test__std__llroundl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::llroundl(arg1) > 10) || (std::llroundl(arg1) < 100)) {}
+void test__log10f__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = log10f(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__llroundl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::llroundl(x);
+void test__log10f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log10f(arg1);
 }
 
-void test__lround__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = lround(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__log10f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log10f(arg1) > 10) || (log10f(arg1) < 100)) {}
 }
 
-void test__lround__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    lround(arg1);
+void test__log10f__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = log10f(p);
+  // cppcheck-suppress memleak
 }
 
-void test__lround__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((lround(arg1) > 10) || (lround(arg1) < 100)) {}
+void test__log10f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log10f(x);
 }
 
-void test__lround__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = lround(p);
-    // cppcheck-suppress memleak
+void test__std__log10f__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::log10f(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__lround__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = lround(x);
+void test__std__log10f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log10f(arg1);
 }
 
-void test__std__lround__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::lround(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__log10f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log10f(arg1) > 10) || (std::log10f(arg1) < 100)) {}
 }
 
-void test__std__lround__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::lround(arg1);
+void test__std__log10f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log10f(x);
 }
 
-void test__std__lround__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::lround(arg1) > 10) || (std::lround(arg1) < 100)) {}
+void test__log10l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = log10l(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__lround__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::lround(x);
+void test__log10l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log10l(arg1);
 }
 
-void test__lroundf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = lroundf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__log10l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log10l(arg1) > 10) || (log10l(arg1) < 100)) {}
 }
 
-void test__lroundf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    lroundf(arg1);
+void test__log10l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = log10l(p);
+  // cppcheck-suppress memleak
 }
 
-void test__lroundf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((lroundf(arg1) > 10) || (lroundf(arg1) < 100)) {}
+void test__log10l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log10l(x);
 }
 
-void test__lroundf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = lroundf(p);
-    // cppcheck-suppress memleak
+void test__std__log10l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::log10l(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__lroundf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = lroundf(x);
+void test__std__log10l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log10l(arg1);
 }
 
-void test__std__lroundf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::lroundf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__log10l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log10l(arg1) > 10) || (std::log10l(arg1) < 100)) {}
 }
 
-void test__std__lroundf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::lroundf(arg1);
+void test__std__log10l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log10l(x);
 }
 
-void test__std__lroundf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::lroundf(arg1) > 10) || (std::lroundf(arg1) < 100)) {}
+void test__log1p__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = log1p(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__lroundf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::lroundf(x);
+void test__log1p__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log1p(arg1);
 }
 
-void test__lroundl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = lroundl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__log1p__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log1p(arg1) > 10) || (log1p(arg1) < 100)) {}
 }
 
-void test__lroundl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    lroundl(arg1);
+void test__log1p__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = log1p(p);
+  // cppcheck-suppress memleak
 }
 
-void test__lroundl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((lroundl(arg1) > 10) || (lroundl(arg1) < 100)) {}
+void test__log1p__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log1p(x);
 }
 
-void test__lroundl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = lroundl(p);
-    // cppcheck-suppress memleak
+void test__std__log1p__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::log1p(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__lroundl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = lroundl(x);
+void test__std__log1p__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log1p(arg1);
 }
 
-void test__std__lroundl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::lroundl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__log1p__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log1p(arg1) > 10) || (std::log1p(arg1) < 100)) {}
 }
 
-void test__std__lroundl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::lroundl(arg1);
+void test__std__log1p__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log1p(x);
 }
 
-void test__std__lroundl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::lroundl(arg1) > 10) || (std::lroundl(arg1) < 100)) {}
+void test__log1pf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = log1pf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__lroundl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::lroundl(x);
+void test__log1pf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log1pf(arg1);
 }
 
-void test__rand__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = rand();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__log1pf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log1pf(arg1) > 10) || (log1pf(arg1) < 100)) {}
 }
 
-void test__rand__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    rand();
+void test__log1pf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = log1pf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__rand__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = rand();
-    // cppcheck-suppress memleak
+void test__log1pf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log1pf(x);
 }
 
-void test__srand__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        srand(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__log1pf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::log1pf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__srand__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    srand(p);
-    // cppcheck-suppress memleak
+void test__std__log1pf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log1pf(arg1);
 }
 
-void test__srand__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    srand(x);
+void test__std__log1pf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log1pf(arg1) > 10) || (std::log1pf(arg1) < 100)) {}
 }
 
-void test__std__srand__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::srand(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__log1pf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log1pf(x);
 }
 
-void test__std__srand__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::srand(x);
+void test__log1pl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = log1pl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ldiv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ldiv(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__log1pl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log1pl(arg1);
 }
 
-void test__ldiv__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ldiv(arg1, arg2) > 10) || (ldiv(arg1, arg2) < 100)) {}
+void test__log1pl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log1pl(arg1) > 10) || (log1pl(arg1) < 100)) {}
 }
 
-void test__ldiv__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ldiv(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__ldiv__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ldiv(x, arg2);
-}
-
-void test__ldiv__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ldiv(arg1, x);
+void test__log1pl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = log1pl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__ldiv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::ldiv(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ldiv__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::ldiv(arg1, arg2) > 10) || (std::ldiv(arg1, arg2) < 100)) {}
+void test__log1pl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log1pl(x);
 }
-
-void test__std__ldiv__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::ldiv(x, arg2);
+
+void test__std__log1pl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::log1pl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ldiv__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::ldiv(arg1, x);
+void test__std__log1pl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log1pl(arg1);
 }
 
-void test__lldiv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        lldiv(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__log1pl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log1pl(arg1) > 10) || (std::log1pl(arg1) < 100)) {}
 }
 
-void test__lldiv__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((lldiv(arg1, arg2) > 10) || (lldiv(arg1, arg2) < 100)) {}
+void test__std__log1pl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log1pl(x);
 }
 
-void test__lldiv__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    lldiv(p, arg2);
-    // cppcheck-suppress memleak
+void test__log2__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = log2(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__lldiv__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    lldiv(x, arg2);
+void test__log2__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log2(arg1);
 }
 
-void test__lldiv__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    lldiv(arg1, x);
+void test__log2__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log2(arg1) > 10) || (log2(arg1) < 100)) {}
 }
 
-void test__std__lldiv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::lldiv(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__log2__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = log2(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__lldiv__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::lldiv(arg1, arg2) > 10) || (std::lldiv(arg1, arg2) < 100)) {}
+void test__log2__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log2(x);
 }
 
-void test__std__lldiv__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::lldiv(x, arg2);
+void test__std__log2__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::log2(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__lldiv__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::lldiv(arg1, x);
+void test__std__log2__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log2(arg1);
 }
 
-void test__localtime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        localtime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__log2__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log2(arg1) > 10) || (std::log2(arg1) < 100)) {}
 }
 
-void test__localtime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    localtime(p);
-    // cppcheck-suppress memleak
+void test__std__log2__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log2(x);
 }
 
-void test__localtime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    localtime(NULL);
+void test__log2f__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = log2f(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__localtime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    localtime(x);
+void test__log2f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log2f(arg1);
 }
 
-void test__std__localtime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::localtime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__log2f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log2f(arg1) > 10) || (log2f(arg1) < 100)) {}
 }
 
-void test__std__localtime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::localtime(NULL);
+void test__log2f__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = log2f(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__localtime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::localtime(x);
+void test__log2f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log2f(x);
 }
 
-void test__localtime_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        localtime_s(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__log2f__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::log2f(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__localtime_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    localtime_s(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__log2f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log2f(arg1);
 }
 
-void test__localtime_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    localtime_s(NULL, arg2);
+void test__std__log2f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log2f(arg1) > 10) || (std::log2f(arg1) < 100)) {}
 }
 
-void test__localtime_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    localtime_s(arg1, NULL);
+void test__std__log2f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log2f(x);
 }
 
-void test__std__localtime_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::localtime_s(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__log2l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = log2l(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__localtime_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::localtime_s(NULL, arg2);
+void test__log2l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log2l(arg1);
 }
 
-void test__std__localtime_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::localtime_s(arg1, NULL);
+void test__log2l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log2l(arg1) > 10) || (log2l(arg1) < 100)) {}
 }
 
-void test__log__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = log(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__log2l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = log2l(p);
+  // cppcheck-suppress memleak
 }
 
-void test__log__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    log(arg1);
+void test__log2l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log2l(x);
 }
 
-void test__log__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = log(p);
-    // cppcheck-suppress memleak
+void test__std__log2l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::log2l(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__log__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = log(x);
+void test__std__log2l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log2l(arg1);
 }
 
-void test__std__log__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::log(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__log2l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log2l(arg1) > 10) || (std::log2l(arg1) < 100)) {}
 }
 
-void test__std__log__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::log(arg1);
+void test__std__log2l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log2l(x);
 }
 
-void test__std__log__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::log(x);
+void test__nearbyint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = nearbyint(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__logf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = logf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__nearbyint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nearbyint(arg1);
 }
 
-void test__logf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    logf(arg1);
+void test__nearbyint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nearbyint(arg1) > 10) || (nearbyint(arg1) < 100)) {}
 }
 
-void test__logf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = logf(p);
-    // cppcheck-suppress memleak
+void test__nearbyint__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = nearbyint(p);
+  // cppcheck-suppress memleak
 }
 
-void test__logf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = logf(x);
+void test__nearbyint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nearbyint(x);
 }
 
-void test__std__logf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::logf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__nearbyint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::nearbyint(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__logf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::logf(arg1);
+void test__std__nearbyint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nearbyint(arg1);
 }
 
-void test__std__logf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::logf(x);
+void test__std__nearbyint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nearbyint(arg1) > 10) || (std::nearbyint(arg1) < 100)) {}
 }
 
-void test__logl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = logl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__nearbyint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nearbyint(x);
 }
 
-void test__logl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    logl(arg1);
+void test__nearbyintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = nearbyintf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__logl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = logl(p);
-    // cppcheck-suppress memleak
+void test__nearbyintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nearbyintf(arg1);
 }
 
-void test__logl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = logl(x);
+void test__nearbyintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nearbyintf(arg1) > 10) || (nearbyintf(arg1) < 100)) {}
 }
 
-void test__std__logl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::logl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__nearbyintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = nearbyintf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__logl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::logl(arg1);
+void test__nearbyintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nearbyintf(x);
 }
 
-void test__std__logl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::logl(x);
+void test__std__nearbyintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::nearbyintf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__clog__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = clog(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__nearbyintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nearbyintf(arg1);
 }
 
-void test__clog__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    clog(arg1);
+void test__std__nearbyintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nearbyintf(arg1) > 10) || (std::nearbyintf(arg1) < 100)) {}
 }
 
-void test__clog__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = clog(p);
-    // cppcheck-suppress memleak
+void test__std__nearbyintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nearbyintf(x);
 }
 
-void test__clog__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = clog(x);
+void test__nearbyintl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = nearbyintl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__clogf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = clogf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__nearbyintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nearbyintl(arg1);
 }
 
-void test__clogf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    clogf(arg1);
+void test__nearbyintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nearbyintl(arg1) > 10) || (nearbyintl(arg1) < 100)) {}
 }
 
-void test__clogf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = clogf(p);
-    // cppcheck-suppress memleak
+void test__nearbyintl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = nearbyintl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__clogf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = clogf(x);
+void test__nearbyintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nearbyintl(x);
 }
 
-void test__clogl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = clogl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__nearbyintl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::nearbyintl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__clogl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    clogl(arg1);
+void test__std__nearbyintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nearbyintl(arg1);
 }
 
-void test__clogl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = clogl(p);
-    // cppcheck-suppress memleak
+void test__std__nearbyintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nearbyintl(arg1) > 10) || (std::nearbyintl(arg1) < 100)) {}
 }
 
-void test__clogl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = clogl(x);
+void test__std__nearbyintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nearbyintl(x);
 }
 
-void test__conj__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = conj(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__nextafter__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = nextafter(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__conj__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    conj(arg1);
+void test__nextafter__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nextafter(arg1, arg2);
 }
 
-void test__conj__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = conj(p);
-    // cppcheck-suppress memleak
+void test__nextafter__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nextafter(arg1, arg2) > 10) || (nextafter(arg1, arg2) < 100)) {}
 }
 
-void test__conj__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = conj(x);
+void test__nextafter__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = nextafter(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__conjf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = conjf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__nextafter__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nextafter(x, arg2);
 }
 
-void test__conjf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    conjf(arg1);
+void test__nextafter__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nextafter(arg1, x);
 }
 
-void test__conjf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = conjf(p);
-    // cppcheck-suppress memleak
+void test__std__nextafter__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::nextafter(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__conjf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = conjf(x);
+void test__std__nextafter__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nextafter(arg1, arg2);
 }
 
-void test__conjl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = conjl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__nextafter__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nextafter(arg1, arg2) > 10) || (std::nextafter(arg1, arg2) < 100)) {}
 }
 
-void test__conjl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    conjl(arg1);
+void test__std__nextafter__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nextafter(x, arg2);
 }
 
-void test__conjl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = conjl(p);
-    // cppcheck-suppress memleak
+void test__std__nextafter__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nextafter(arg1, x);
 }
 
-void test__conjl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = conjl(x);
+void test__nextafterf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = nextafterf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fpclassify__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = fpclassify(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__nextafterf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nextafterf(arg1, arg2);
 }
 
-void test__fpclassify__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    fpclassify(arg1);
+void test__nextafterf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nextafterf(arg1, arg2) > 10) || (nextafterf(arg1, arg2) < 100)) {}
 }
 
-void test__fpclassify__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((fpclassify(arg1) > 10) || (fpclassify(arg1) < 100)) {}
+void test__nextafterf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = nextafterf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__fpclassify__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = fpclassify(p);
-    // cppcheck-suppress memleak
+void test__nextafterf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nextafterf(x, arg2);
 }
 
-void test__fpclassify__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = fpclassify(x);
+void test__nextafterf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nextafterf(arg1, x);
 }
 
-void test__std__fpclassify__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::fpclassify(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__nextafterf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::nextafterf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fpclassify__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::fpclassify(arg1);
+void test__std__nextafterf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nextafterf(arg1, arg2);
 }
 
-void test__std__fpclassify__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::fpclassify(arg1) > 10) || (std::fpclassify(arg1) < 100)) {}
+void test__std__nextafterf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nextafterf(arg1, arg2) > 10) || (std::nextafterf(arg1, arg2) < 100)) {}
 }
 
-void test__std__fpclassify__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::fpclassify(x);
+void test__std__nextafterf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nextafterf(x, arg2);
 }
 
-void test__isfinite__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isfinite(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__nextafterf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nextafterf(arg1, x);
 }
 
-void test__isfinite__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isfinite(arg1);
+void test__nextafterl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = nextafterl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isfinite__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isfinite(arg1) > 10) || (isfinite(arg1) < 100)) {}
+void test__nextafterl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nextafterl(arg1, arg2);
 }
 
-void test__isfinite__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isfinite(p);
-    // cppcheck-suppress memleak
+void test__nextafterl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nextafterl(arg1, arg2) > 10) || (nextafterl(arg1, arg2) < 100)) {}
 }
 
-void test__isfinite__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isfinite(x);
+void test__nextafterl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = nextafterl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__isfinite__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isfinite(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__nextafterl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nextafterl(x, arg2);
 }
 
-void test__std__isfinite__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isfinite(arg1);
+void test__nextafterl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nextafterl(arg1, x);
 }
 
-void test__std__isfinite__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isfinite(arg1) > 10) || (std::isfinite(arg1) < 100)) {}
+void test__std__nextafterl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::nextafterl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__isfinite__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isfinite(x);
+void test__std__nextafterl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nextafterl(arg1, arg2);
 }
 
-void test__isgreater__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isgreater(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__nextafterl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nextafterl(arg1, arg2) > 10) || (std::nextafterl(arg1, arg2) < 100)) {}
 }
 
-void test__isgreater__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isgreater(arg1, arg2);
+void test__std__nextafterl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nextafterl(x, arg2);
 }
 
-void test__isgreater__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isgreater(arg1, arg2) > 10) || (isgreater(arg1, arg2) < 100)) {}
+void test__std__nextafterl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nextafterl(arg1, x);
 }
 
-void test__isgreater__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isgreater(p, arg2);
-    // cppcheck-suppress memleak
+void test__nexttoward__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = nexttoward(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isgreater__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isgreater(x, arg2);
+void test__nexttoward__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nexttoward(arg1, arg2);
 }
 
-void test__isgreater__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isgreater(arg1, x);
+void test__nexttoward__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nexttoward(arg1, arg2) > 10) || (nexttoward(arg1, arg2) < 100)) {}
 }
 
-void test__std__isgreater__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isgreater(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__nexttoward__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = nexttoward(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__isgreater__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isgreater(arg1, arg2);
+void test__nexttoward__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nexttoward(x, arg2);
 }
 
-void test__std__isgreater__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isgreater(arg1, arg2) > 10) || (std::isgreater(arg1, arg2) < 100)) {}
+void test__nexttoward__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nexttoward(arg1, x);
 }
 
-void test__std__isgreater__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isgreater(x, arg2);
+void test__std__nexttoward__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::nexttoward(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__isgreater__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isgreater(arg1, x);
+void test__std__nexttoward__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nexttoward(arg1, arg2);
 }
 
-void test__isgreaterequal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isgreaterequal(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__nexttoward__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nexttoward(arg1, arg2) > 10) || (std::nexttoward(arg1, arg2) < 100)) {}
 }
 
-void test__isgreaterequal__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isgreaterequal(arg1, arg2);
+void test__std__nexttoward__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nexttoward(x, arg2);
 }
 
-void test__isgreaterequal__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isgreaterequal(arg1, arg2) > 10) || (isgreaterequal(arg1, arg2) < 100)) {}
+void test__std__nexttoward__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nexttoward(arg1, x);
 }
 
-void test__isgreaterequal__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isgreaterequal(p, arg2);
-    // cppcheck-suppress memleak
+void test__nexttowardf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = nexttowardf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isgreaterequal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isgreaterequal(x, arg2);
+void test__nexttowardf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nexttowardf(arg1, arg2);
 }
 
-void test__isgreaterequal__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isgreaterequal(arg1, x);
+void test__nexttowardf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nexttowardf(arg1, arg2) > 10) || (nexttowardf(arg1, arg2) < 100)) {}
 }
 
-void test__std__isgreaterequal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isgreaterequal(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__nexttowardf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = nexttowardf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__isgreaterequal__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isgreaterequal(arg1, arg2);
+void test__nexttowardf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nexttowardf(x, arg2);
 }
 
-void test__std__isgreaterequal__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isgreaterequal(arg1, arg2) > 10) || (std::isgreaterequal(arg1, arg2) < 100)) {}
+void test__nexttowardf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nexttowardf(arg1, x);
 }
 
-void test__std__isgreaterequal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isgreaterequal(x, arg2);
+void test__std__nexttowardf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::nexttowardf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__isgreaterequal__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isgreaterequal(arg1, x);
+void test__std__nexttowardf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nexttowardf(arg1, arg2);
 }
 
-void test__isinf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isinf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__nexttowardf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nexttowardf(arg1, arg2) > 10) || (std::nexttowardf(arg1, arg2) < 100)) {}
 }
 
-void test__isinf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isinf(arg1);
+void test__std__nexttowardf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nexttowardf(x, arg2);
 }
 
-void test__isinf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isinf(arg1) > 10) || (isinf(arg1) < 100)) {}
+void test__std__nexttowardf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nexttowardf(arg1, x);
 }
 
-void test__isinf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isinf(p);
-    // cppcheck-suppress memleak
+void test__nexttowardl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = nexttowardl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isinf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isinf(x);
+void test__nexttowardl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nexttowardl(arg1, arg2);
 }
 
-void test__std__isinf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isinf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__nexttowardl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nexttowardl(arg1, arg2) > 10) || (nexttowardl(arg1, arg2) < 100)) {}
 }
 
-void test__std__isinf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isinf(arg1);
+void test__nexttowardl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = nexttowardl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__isinf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isinf(arg1) > 10) || (std::isinf(arg1) < 100)) {}
+void test__nexttowardl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nexttowardl(x, arg2);
 }
 
-void test__std__isinf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isinf(x);
+void test__nexttowardl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nexttowardl(arg1, x);
 }
 
-void test__logb__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = logb(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__nexttowardl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::nexttowardl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__logb__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    logb(arg1);
+void test__std__nexttowardl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nexttowardl(arg1, arg2);
 }
 
-void test__logb__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((logb(arg1) > 10) || (logb(arg1) < 100)) {}
+void test__std__nexttowardl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nexttowardl(arg1, arg2) > 10) || (std::nexttowardl(arg1, arg2) < 100)) {}
 }
 
-void test__logb__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = logb(p);
-    // cppcheck-suppress memleak
+void test__std__nexttowardl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nexttowardl(x, arg2);
 }
 
-void test__logb__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = logb(x);
+void test__std__nexttowardl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nexttowardl(arg1, x);
 }
 
-void test__std__logb__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::logb(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__longjmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; longjmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__logb__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::logb(arg1);
+void test__longjmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  longjmp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__logb__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::logb(arg1) > 10) || (std::logb(arg1) < 100)) {}
+void test__longjmp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  longjmp(x, arg2);
 }
 
-void test__std__logb__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::logb(x);
+void test__longjmp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  longjmp(arg1, x);
 }
 
-void test__logbf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = logbf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__longjmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::longjmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__logbf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    logbf(arg1);
+void test__std__longjmp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::longjmp(x, arg2);
 }
 
-void test__logbf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((logbf(arg1) > 10) || (logbf(arg1) < 100)) {}
+void test__std__longjmp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::longjmp(arg1, x);
 }
 
-void test__logbf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = logbf(p);
-    // cppcheck-suppress memleak
+void test__malloc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = malloc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__logbf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = logbf(x);
+void test__malloc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  malloc(arg1);
 }
 
-void test__std__logbf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::logbf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__malloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = malloc(x);
 }
 
-void test__std__logbf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::logbf(arg1);
+void test__std__malloc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::malloc(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__logbf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::logbf(arg1) > 10) || (std::logbf(arg1) < 100)) {}
+void test__std__malloc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::malloc(arg1);
 }
 
-void test__std__logbf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::logbf(x);
+void test__std__malloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::malloc(x);
 }
 
-void test__logbl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = logbl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__alloca__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = alloca(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__logbl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    logbl(arg1);
+void test__alloca__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  alloca(arg1);
 }
 
-void test__logbl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((logbl(arg1) > 10) || (logbl(arg1) < 100)) {}
+void test__alloca__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = alloca(x);
 }
 
-void test__logbl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = logbl(p);
-    // cppcheck-suppress memleak
+void test__memchr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = memchr(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__logbl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = logbl(x);
+void test__memchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  memchr(arg1, arg2, arg3);
 }
 
-void test__std__logbl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::logbl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__memchr__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((memchr(arg1, arg2, arg3) > 10) || (memchr(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__logbl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::logbl(arg1);
+void test__memchr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = memchr(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__logbl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::logbl(arg1) > 10) || (std::logbl(arg1) < 100)) {}
+void test__memchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = memchr(NULL, arg2, arg3);
 }
 
-void test__std__logbl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::logbl(x);
+void test__memchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = memchr(x, arg2, arg3);
 }
 
-void test__isless__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isless(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__memchr__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = memchr(arg1, !x, arg3);
 }
 
-void test__isless__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isless(arg1, arg2);
+void test__memchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = memchr(arg1, x, arg3);
 }
 
-void test__isless__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isless(arg1, arg2) > 10) || (isless(arg1, arg2) < 100)) {}
+void test__memchr__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = memchr(arg1, arg2, !x);
 }
 
-void test__isless__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isless(p, arg2);
-    // cppcheck-suppress memleak
+void test__memchr__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = memchr(arg1, arg2, x);
 }
 
-void test__isless__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isless(x, arg2);
+void test__std__memchr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::memchr(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isless__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isless(arg1, x);
+void test__std__memchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::memchr(arg1, arg2, arg3);
 }
 
-void test__std__isless__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isless(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__memchr__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::memchr(arg1, arg2, arg3) > 10) || (std::memchr(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__isless__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isless(arg1, arg2);
+void test__std__memchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::memchr(NULL, arg2, arg3);
 }
 
-void test__std__isless__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isless(arg1, arg2) > 10) || (std::isless(arg1, arg2) < 100)) {}
+void test__std__memchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::memchr(x, arg2, arg3);
 }
 
-void test__std__isless__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isless(x, arg2);
+void test__std__memchr__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::memchr(arg1, !x, arg3);
 }
 
-void test__std__isless__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isless(arg1, x);
+void test__std__memchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::memchr(arg1, x, arg3);
 }
 
-void test__islessequal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = islessequal(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__memchr__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::memchr(arg1, arg2, !x);
 }
 
-void test__islessequal__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    islessequal(arg1, arg2);
+void test__std__memchr__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::memchr(arg1, arg2, x);
 }
 
-void test__islessequal__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((islessequal(arg1, arg2) > 10) || (islessequal(arg1, arg2) < 100)) {}
+void test__wmemchr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wmemchr(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__islessequal__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = islessequal(p, arg2);
-    // cppcheck-suppress memleak
+void test__wmemchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wmemchr(arg1, arg2, arg3);
 }
 
-void test__islessequal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = islessequal(x, arg2);
+void test__wmemchr__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wmemchr(arg1, arg2, arg3) > 10) || (wmemchr(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__islessequal__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = islessequal(arg1, x);
+void test__wmemchr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wmemchr(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__islessequal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::islessequal(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wmemchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wmemchr(NULL, arg2, arg3);
 }
 
-void test__std__islessequal__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::islessequal(arg1, arg2);
+void test__wmemchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wmemchr(x, arg2, arg3);
 }
 
-void test__std__islessequal__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::islessequal(arg1, arg2) > 10) || (std::islessequal(arg1, arg2) < 100)) {}
+void test__wmemchr__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = wmemchr(arg1, !x, arg3);
 }
 
-void test__std__islessequal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::islessequal(x, arg2);
+void test__wmemchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wmemchr(arg1, x, arg3);
 }
 
-void test__std__islessequal__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::islessequal(arg1, x);
+void test__wmemchr__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = wmemchr(arg1, arg2, !x);
 }
 
-void test__islessgreater__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = islessgreater(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wmemchr__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wmemchr(arg1, arg2, x);
 }
 
-void test__islessgreater__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    islessgreater(arg1, arg2);
+void test__std__wmemchr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wmemchr(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__islessgreater__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((islessgreater(arg1, arg2) > 10) || (islessgreater(arg1, arg2) < 100)) {}
+void test__std__wmemchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wmemchr(arg1, arg2, arg3);
 }
 
-void test__islessgreater__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = islessgreater(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__wmemchr__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wmemchr(arg1, arg2, arg3) > 10) || (std::wmemchr(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__islessgreater__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = islessgreater(x, arg2);
+void test__std__wmemchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wmemchr(NULL, arg2, arg3);
 }
 
-void test__islessgreater__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = islessgreater(arg1, x);
+void test__std__wmemchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wmemchr(x, arg2, arg3);
 }
 
-void test__std__islessgreater__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::islessgreater(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wmemchr__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::wmemchr(arg1, !x, arg3);
 }
 
-void test__std__islessgreater__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::islessgreater(arg1, arg2);
+void test__std__wmemchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wmemchr(arg1, x, arg3);
 }
 
-void test__std__islessgreater__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::islessgreater(arg1, arg2) > 10) || (std::islessgreater(arg1, arg2) < 100)) {}
+void test__std__wmemchr__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::wmemchr(arg1, arg2, !x);
 }
 
-void test__std__islessgreater__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::islessgreater(x, arg2);
+void test__std__wmemchr__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wmemchr(arg1, arg2, x);
 }
 
-void test__std__islessgreater__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::islessgreater(arg1, x);
+void test__memcmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = memcmp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nan__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = nan(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__memcmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  memcmp(arg1, arg2, arg3);
 }
 
-void test__nan__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    nan(arg1);
+void test__memcmp__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((memcmp(arg1, arg2, arg3) > 10) || (memcmp(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__nan__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((nan(arg1) > 10) || (nan(arg1) < 100)) {}
+void test__memcmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = memcmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__nan__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = nan(p);
-    // cppcheck-suppress memleak
+void test__memcmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = memcmp(NULL, arg2, arg3);
 }
 
-void test__nan__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = nan(NULL);
+void test__memcmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = memcmp(x, arg2, arg3);
 }
 
-void test__nan__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = nan(x);
+void test__memcmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = memcmp(arg1, NULL, arg3);
 }
 
-void test__std__nan__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::nan(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__memcmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = memcmp(arg1, x, arg3);
 }
 
-void test__std__nan__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::nan(arg1);
+void test__memcmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = memcmp(arg1, arg2, !x);
 }
 
-void test__std__nan__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::nan(arg1) > 10) || (std::nan(arg1) < 100)) {}
+void test__memcmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = memcmp(arg1, arg2, x);
 }
 
-void test__std__nan__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::nan(NULL);
+void test__std__memcmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::memcmp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__nan__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::nan(x);
+void test__std__memcmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::memcmp(arg1, arg2, arg3);
 }
 
-void test__nanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = nanf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__memcmp__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::memcmp(arg1, arg2, arg3) > 10) || (std::memcmp(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__nanf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    nanf(arg1);
+void test__std__memcmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::memcmp(NULL, arg2, arg3);
 }
 
-void test__nanf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((nanf(arg1) > 10) || (nanf(arg1) < 100)) {}
+void test__std__memcmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::memcmp(x, arg2, arg3);
 }
 
-void test__nanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = nanf(p);
-    // cppcheck-suppress memleak
+void test__std__memcmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::memcmp(arg1, NULL, arg3);
 }
 
-void test__nanf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = nanf(NULL);
+void test__std__memcmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::memcmp(arg1, x, arg3);
 }
 
-void test__nanf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = nanf(x);
+void test__std__memcmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::memcmp(arg1, arg2, !x);
 }
 
-void test__std__nanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::nanf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__memcmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::memcmp(arg1, arg2, x);
 }
 
-void test__std__nanf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::nanf(arg1);
+void test__wmemcmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wmemcmp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__nanf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::nanf(arg1) > 10) || (std::nanf(arg1) < 100)) {}
+void test__wmemcmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wmemcmp(arg1, arg2, arg3);
 }
 
-void test__std__nanf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::nanf(NULL);
+void test__wmemcmp__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wmemcmp(arg1, arg2, arg3) > 10) || (wmemcmp(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__nanf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::nanf(x);
+void test__wmemcmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wmemcmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__nanl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = nanl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wmemcmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wmemcmp(NULL, arg2, arg3);
 }
 
-void test__nanl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    nanl(arg1);
+void test__wmemcmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wmemcmp(x, arg2, arg3);
 }
 
-void test__nanl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((nanl(arg1) > 10) || (nanl(arg1) < 100)) {}
+void test__wmemcmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wmemcmp(arg1, NULL, arg3);
 }
 
-void test__nanl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = nanl(p);
-    // cppcheck-suppress memleak
+void test__wmemcmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wmemcmp(arg1, x, arg3);
 }
 
-void test__nanl__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = nanl(NULL);
+void test__wmemcmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = wmemcmp(arg1, arg2, !x);
 }
 
-void test__nanl__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = nanl(x);
+void test__wmemcmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wmemcmp(arg1, arg2, x);
 }
 
-void test__std__nanl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::nanl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wmemcmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wmemcmp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__nanl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::nanl(arg1);
+void test__std__wmemcmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wmemcmp(arg1, arg2, arg3);
 }
 
-void test__std__nanl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::nanl(arg1) > 10) || (std::nanl(arg1) < 100)) {}
+void test__std__wmemcmp__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wmemcmp(arg1, arg2, arg3) > 10) || (std::wmemcmp(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__nanl__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::nanl(NULL);
+void test__std__wmemcmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wmemcmp(NULL, arg2, arg3);
 }
 
-void test__std__nanl__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::nanl(x);
+void test__std__wmemcmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wmemcmp(x, arg2, arg3);
 }
 
-void test__isnan__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isnan(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wmemcmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wmemcmp(arg1, NULL, arg3);
 }
 
-void test__isnan__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isnan(arg1);
+void test__std__wmemcmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wmemcmp(arg1, x, arg3);
 }
 
-void test__isnan__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isnan(arg1) > 10) || (isnan(arg1) < 100)) {}
+void test__std__wmemcmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::wmemcmp(arg1, arg2, !x);
 }
 
-void test__isnan__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isnan(p);
-    // cppcheck-suppress memleak
+void test__std__wmemcmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wmemcmp(arg1, arg2, x);
 }
 
-void test__isnan__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isnan(x);
+void test__memcpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; memcpy(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__isnan__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isnan(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__memcpy__leakignore() {
+  char *p = malloc(10); *p=0;
+  memcpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__isnan__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isnan(arg1);
+void test__memcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  memcpy(NULL, arg2, arg3);
 }
 
-void test__std__isnan__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isnan(arg1) > 10) || (std::isnan(arg1) < 100)) {}
+void test__memcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  memcpy(arg1, NULL, arg3);
 }
 
-void test__std__isnan__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isnan(x);
+void test__memcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  memcpy(arg1, x, arg3);
 }
 
-void test__isnormal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isnormal(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__memcpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  memcpy(arg1, arg2, !x);
 }
 
-void test__isnormal__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isnormal(arg1);
+void test__memcpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memcpy(arg1, arg2, x);
 }
 
-void test__isnormal__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isnormal(arg1) > 10) || (isnormal(arg1) < 100)) {}
+void test__std__memcpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::memcpy(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isnormal__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isnormal(p);
-    // cppcheck-suppress memleak
+void test__std__memcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::memcpy(NULL, arg2, arg3);
 }
 
-void test__isnormal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isnormal(x);
+void test__std__memcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::memcpy(arg1, NULL, arg3);
 }
 
-void test__std__isnormal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isnormal(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__memcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::memcpy(arg1, x, arg3);
 }
 
-void test__std__isnormal__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isnormal(arg1);
+void test__std__memcpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::memcpy(arg1, arg2, !x);
 }
 
-void test__std__isnormal__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isnormal(arg1) > 10) || (std::isnormal(arg1) < 100)) {}
+void test__std__memcpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::memcpy(arg1, arg2, x);
 }
 
-void test__std__isnormal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isnormal(x);
+void test__wmemcpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wmemcpy(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__isunordered__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = isunordered(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wmemcpy__leakignore() {
+  char *p = malloc(10); *p=0;
+  wmemcpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__isunordered__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    isunordered(arg1, arg2);
+void test__wmemcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wmemcpy(NULL, arg2, arg3);
 }
 
-void test__isunordered__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((isunordered(arg1, arg2) > 10) || (isunordered(arg1, arg2) < 100)) {}
+void test__wmemcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wmemcpy(arg1, NULL, arg3);
 }
 
-void test__isunordered__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = isunordered(p, arg2);
-    // cppcheck-suppress memleak
+void test__wmemcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wmemcpy(arg1, x, arg3);
 }
 
-void test__isunordered__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isunordered(x, arg2);
+void test__wmemcpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wmemcpy(arg1, arg2, !x);
 }
 
-void test__isunordered__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = isunordered(arg1, x);
+void test__wmemcpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wmemcpy(arg1, arg2, x);
 }
 
-void test__std__isunordered__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::isunordered(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wmemcpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wmemcpy(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__isunordered__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::isunordered(arg1, arg2);
+void test__std__wmemcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wmemcpy(NULL, arg2, arg3);
 }
 
-void test__std__isunordered__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::isunordered(arg1, arg2) > 10) || (std::isunordered(arg1, arg2) < 100)) {}
+void test__std__wmemcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wmemcpy(arg1, NULL, arg3);
 }
 
-void test__std__isunordered__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isunordered(x, arg2);
+void test__std__wmemcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wmemcpy(arg1, x, arg3);
 }
 
-void test__std__isunordered__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::isunordered(arg1, x);
+void test__std__wmemcpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::wmemcpy(arg1, arg2, !x);
 }
 
-void test__ilogb__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ilogb(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wmemcpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wmemcpy(arg1, arg2, x);
 }
 
-void test__ilogb__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ilogb(arg1);
+void test__memcpy_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; memcpy_s(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ilogb__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ilogb(arg1) > 10) || (ilogb(arg1) < 100)) {}
+void test__memcpy_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  memcpy_s(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__ilogb__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ilogb(p);
-    // cppcheck-suppress memleak
+void test__memcpy_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  memcpy_s(NULL, arg2, arg3, arg4);
 }
 
-void test__ilogb__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ilogb(x);
+void test__memcpy_s__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  memcpy_s(arg1, !x, arg3, arg4);
 }
 
-void test__std__ilogb__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ilogb(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__memcpy_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memcpy_s(arg1, x, arg3, arg4);
 }
 
-void test__std__ilogb__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ilogb(arg1);
+void test__memcpy_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  memcpy_s(arg1, arg2, NULL, arg4);
 }
 
-void test__std__ilogb__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::ilogb(arg1) > 10) || (std::ilogb(arg1) < 100)) {}
+void test__memcpy_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  memcpy_s(arg1, arg2, x, arg4);
 }
 
-void test__std__ilogb__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::ilogb(x);
+void test__memcpy_s__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  memcpy_s(arg1, arg2, arg3, !x);
 }
 
-void test__ilogbf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ilogbf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__memcpy_s__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memcpy_s(arg1, arg2, arg3, x);
 }
 
-void test__ilogbf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ilogbf(arg1);
+void test__wmemcpy_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wmemcpy_s(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ilogbf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ilogbf(arg1) > 10) || (ilogbf(arg1) < 100)) {}
+void test__wmemcpy_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  wmemcpy_s(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__ilogbf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ilogbf(p);
-    // cppcheck-suppress memleak
+void test__wmemcpy_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wmemcpy_s(NULL, arg2, arg3, arg4);
 }
 
-void test__ilogbf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ilogbf(x);
+void test__wmemcpy_s__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wmemcpy_s(arg1, !x, arg3, arg4);
 }
 
-void test__std__ilogbf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ilogbf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wmemcpy_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wmemcpy_s(arg1, x, arg3, arg4);
 }
 
-void test__std__ilogbf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ilogbf(arg1);
+void test__wmemcpy_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  wmemcpy_s(arg1, arg2, NULL, arg4);
 }
 
-void test__std__ilogbf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::ilogbf(arg1) > 10) || (std::ilogbf(arg1) < 100)) {}
+void test__wmemcpy_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wmemcpy_s(arg1, arg2, x, arg4);
 }
 
-void test__std__ilogbf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::ilogbf(x);
+void test__wmemcpy_s__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wmemcpy_s(arg1, arg2, arg3, !x);
 }
 
-void test__ilogbl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ilogbl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wmemcpy_s__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wmemcpy_s(arg1, arg2, arg3, x);
 }
 
-void test__ilogbl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ilogbl(arg1);
+void test__memmove__noreturn() {
+  int x = 1;
+  if (cond) { x=100; memmove(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ilogbl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((ilogbl(arg1) > 10) || (ilogbl(arg1) < 100)) {}
+void test__memmove__leakignore() {
+  char *p = malloc(10); *p=0;
+  memmove(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__ilogbl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ilogbl(p);
-    // cppcheck-suppress memleak
+void test__memmove__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  memmove(NULL, arg2, arg3);
 }
 
-void test__ilogbl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ilogbl(x);
+void test__memmove__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  memmove(arg1, NULL, arg3);
 }
 
-void test__std__ilogbl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ilogbl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__memmove__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  memmove(arg1, x, arg3);
 }
 
-void test__std__ilogbl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ilogbl(arg1);
+void test__memmove__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  memmove(arg1, arg2, !x);
 }
 
-void test__std__ilogbl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::ilogbl(arg1) > 10) || (std::ilogbl(arg1) < 100)) {}
+void test__memmove__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memmove(arg1, arg2, x);
 }
 
-void test__std__ilogbl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::ilogbl(x);
+void test__std__memmove__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::memmove(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__log10__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = log10(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__memmove__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::memmove(NULL, arg2, arg3);
 }
 
-void test__log10__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    log10(arg1);
+void test__std__memmove__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::memmove(arg1, NULL, arg3);
 }
 
-void test__log10__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((log10(arg1) > 10) || (log10(arg1) < 100)) {}
+void test__std__memmove__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::memmove(arg1, x, arg3);
 }
 
-void test__log10__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = log10(p);
-    // cppcheck-suppress memleak
+void test__std__memmove__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::memmove(arg1, arg2, !x);
 }
 
-void test__log10__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = log10(x);
+void test__std__memmove__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::memmove(arg1, arg2, x);
 }
 
-void test__std__log10__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::log10(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wmemmove__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wmemmove(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__log10__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::log10(arg1);
+void test__wmemmove__leakignore() {
+  char *p = malloc(10); *p=0;
+  wmemmove(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__log10__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::log10(arg1) > 10) || (std::log10(arg1) < 100)) {}
+void test__wmemmove__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wmemmove(NULL, arg2, arg3);
 }
 
-void test__std__log10__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::log10(x);
+void test__wmemmove__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wmemmove(arg1, NULL, arg3);
 }
 
-void test__log10f__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = log10f(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wmemmove__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wmemmove(arg1, x, arg3);
 }
 
-void test__log10f__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    log10f(arg1);
+void test__wmemmove__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wmemmove(arg1, arg2, !x);
 }
 
-void test__log10f__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((log10f(arg1) > 10) || (log10f(arg1) < 100)) {}
+void test__wmemmove__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wmemmove(arg1, arg2, x);
 }
 
-void test__log10f__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = log10f(p);
-    // cppcheck-suppress memleak
+void test__std__wmemmove__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wmemmove(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__log10f__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = log10f(x);
+void test__std__wmemmove__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wmemmove(NULL, arg2, arg3);
 }
 
-void test__std__log10f__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::log10f(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wmemmove__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wmemmove(arg1, NULL, arg3);
 }
 
-void test__std__log10f__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::log10f(arg1);
+void test__std__wmemmove__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wmemmove(arg1, x, arg3);
 }
 
-void test__std__log10f__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::log10f(arg1) > 10) || (std::log10f(arg1) < 100)) {}
+void test__std__wmemmove__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::wmemmove(arg1, arg2, !x);
 }
 
-void test__std__log10f__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::log10f(x);
+void test__std__wmemmove__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wmemmove(arg1, arg2, x);
 }
 
-void test__log10l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = log10l(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__memset_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; memset_s(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__log10l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    log10l(arg1);
+void test__memset_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  memset_s(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__log10l__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((log10l(arg1) > 10) || (log10l(arg1) < 100)) {}
+void test__memset_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  memset_s(NULL, arg2, arg3, arg4);
 }
 
-void test__log10l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = log10l(p);
-    // cppcheck-suppress memleak
+void test__memset_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memset_s(arg1, x, arg3, arg4);
 }
 
-void test__log10l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = log10l(x);
+void test__memset_s__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memset_s(arg1, arg2, x, arg4);
 }
 
-void test__std__log10l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::log10l(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__memset_s__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memset_s(arg1, arg2, arg3, x);
 }
 
-void test__std__log10l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::log10l(arg1);
+void test__memset__noreturn() {
+  int x = 1;
+  if (cond) { x=100; memset(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__log10l__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::log10l(arg1) > 10) || (std::log10l(arg1) < 100)) {}
+void test__memset__leakignore() {
+  char *p = malloc(10); *p=0;
+  memset(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__log10l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::log10l(x);
+void test__memset__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  memset(NULL, arg2, arg3);
 }
 
-void test__log1p__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = log1p(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__memset__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memset(arg1, x, arg3);
 }
 
-void test__log1p__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    log1p(arg1);
+void test__memset__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  memset(arg1, arg2, !x);
 }
 
-void test__log1p__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((log1p(arg1) > 10) || (log1p(arg1) < 100)) {}
+void test__memset__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memset(arg1, arg2, x);
 }
 
-void test__log1p__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = log1p(p);
-    // cppcheck-suppress memleak
+void test__std__memset__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::memset(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__log1p__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = log1p(x);
+void test__std__memset__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::memset(NULL, arg2, arg3);
 }
 
-void test__std__log1p__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::log1p(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__memset__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::memset(arg1, x, arg3);
 }
 
-void test__std__log1p__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::log1p(arg1);
+void test__std__memset__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::memset(arg1, arg2, !x);
 }
 
-void test__std__log1p__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::log1p(arg1) > 10) || (std::log1p(arg1) < 100)) {}
+void test__std__memset__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::memset(arg1, arg2, x);
 }
 
-void test__std__log1p__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::log1p(x);
+void test__wmemset__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wmemset(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__log1pf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = log1pf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wmemset__leakignore() {
+  char *p = malloc(10); *p=0;
+  wmemset(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__log1pf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    log1pf(arg1);
+void test__wmemset__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wmemset(NULL, arg2, arg3);
 }
 
-void test__log1pf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((log1pf(arg1) > 10) || (log1pf(arg1) < 100)) {}
+void test__wmemset__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wmemset(arg1, x, arg3);
 }
 
-void test__log1pf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = log1pf(p);
-    // cppcheck-suppress memleak
+void test__wmemset__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wmemset(arg1, arg2, !x);
 }
 
-void test__log1pf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = log1pf(x);
+void test__wmemset__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wmemset(arg1, arg2, x);
 }
 
-void test__std__log1pf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::log1pf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wmemset__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wmemset(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__log1pf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::log1pf(arg1);
+void test__std__wmemset__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wmemset(NULL, arg2, arg3);
 }
 
-void test__std__log1pf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::log1pf(arg1) > 10) || (std::log1pf(arg1) < 100)) {}
+void test__std__wmemset__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wmemset(arg1, x, arg3);
 }
 
-void test__std__log1pf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::log1pf(x);
+void test__std__wmemset__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::wmemset(arg1, arg2, !x);
 }
 
-void test__log1pl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = log1pl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wmemset__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wmemset(arg1, arg2, x);
 }
 
-void test__log1pl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    log1pl(arg1);
+void test__mktime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mktime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__log1pl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((log1pl(arg1) > 10) || (log1pl(arg1) < 100)) {}
+void test__mktime__leakignore() {
+  char *p = malloc(10); *p=0;
+  mktime(p);
+  // cppcheck-suppress memleak
 }
 
-void test__log1pl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = log1pl(p);
-    // cppcheck-suppress memleak
+void test__mktime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mktime(NULL);
 }
 
-void test__log1pl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = log1pl(x);
+void test__mktime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mktime(x);
 }
 
-void test__std__log1pl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::log1pl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__mktime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::mktime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__log1pl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::log1pl(arg1);
+void test__std__mktime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::mktime(NULL);
 }
 
-void test__std__log1pl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::log1pl(arg1) > 10) || (std::log1pl(arg1) < 100)) {}
+void test__std__mktime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::mktime(x);
 }
 
-void test__std__log1pl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::log1pl(x);
+void test__mkxtime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mkxtime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__log2__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = log2(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mkxtime__leakignore() {
+  char *p = malloc(10); *p=0;
+  mkxtime(p);
+  // cppcheck-suppress memleak
 }
 
-void test__log2__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    log2(arg1);
+void test__mkxtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mkxtime(NULL);
 }
 
-void test__log2__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((log2(arg1) > 10) || (log2(arg1) < 100)) {}
+void test__mkxtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mkxtime(x);
 }
 
-void test__log2__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = log2(p);
-    // cppcheck-suppress memleak
+void test__modf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; modf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__log2__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = log2(x);
+void test__modf__leakignore() {
+  char *p = malloc(10); *p=0;
+  modf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__log2__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::log2(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__modf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  modf(x, arg2);
 }
 
-void test__std__log2__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::log2(arg1);
+void test__modf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  modf(arg1, NULL);
 }
 
-void test__std__log2__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::log2(arg1) > 10) || (std::log2(arg1) < 100)) {}
+void test__std__modf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::modf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__log2__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::log2(x);
+void test__std__modf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::modf(x, arg2);
 }
 
-void test__log2f__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = log2f(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__modf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::modf(arg1, NULL);
 }
 
-void test__log2f__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    log2f(arg1);
+void test__modff__noreturn() {
+  int x = 1;
+  if (cond) { x=100; modff(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__log2f__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((log2f(arg1) > 10) || (log2f(arg1) < 100)) {}
+void test__modff__leakignore() {
+  char *p = malloc(10); *p=0;
+  modff(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__log2f__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = log2f(p);
-    // cppcheck-suppress memleak
+void test__modff__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  modff(x, arg2);
 }
 
-void test__log2f__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = log2f(x);
+void test__modff__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  modff(arg1, NULL);
 }
 
-void test__std__log2f__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::log2f(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__modff__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::modff(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__log2f__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::log2f(arg1);
+void test__std__modff__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::modff(x, arg2);
 }
 
-void test__std__log2f__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::log2f(arg1) > 10) || (std::log2f(arg1) < 100)) {}
+void test__std__modff__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::modff(arg1, NULL);
 }
 
-void test__std__log2f__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::log2f(x);
+void test__modfl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; modfl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__log2l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = log2l(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__modfl__leakignore() {
+  char *p = malloc(10); *p=0;
+  modfl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__log2l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    log2l(arg1);
+void test__modfl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  modfl(x, arg2);
 }
 
-void test__log2l__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((log2l(arg1) > 10) || (log2l(arg1) < 100)) {}
+void test__modfl__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  modfl(arg1, NULL);
 }
 
-void test__log2l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = log2l(p);
-    // cppcheck-suppress memleak
+void test__std__modfl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::modfl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__log2l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = log2l(x);
+void test__std__modfl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::modfl(x, arg2);
 }
 
-void test__std__log2l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::log2l(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__modfl__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::modfl(arg1, NULL);
 }
 
-void test__std__log2l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::log2l(arg1);
+void test__perror__noreturn() {
+  int x = 1;
+  if (cond) { x=100; perror(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__log2l__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::log2l(arg1) > 10) || (std::log2l(arg1) < 100)) {}
+void test__perror__leakignore() {
+  char *p = malloc(10); *p=0;
+  perror(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__log2l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::log2l(x);
+void test__perror__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  perror(x);
 }
 
-void test__nearbyint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = nearbyint(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__perror__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::perror(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nearbyint__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    nearbyint(arg1);
+void test__std__perror__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::perror(x);
 }
 
-void test__nearbyint__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((nearbyint(arg1) > 10) || (nearbyint(arg1) < 100)) {}
+void test__pow__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = pow(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nearbyint__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = nearbyint(p);
-    // cppcheck-suppress memleak
+void test__pow__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  pow(arg1, arg2);
 }
 
-void test__nearbyint__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = nearbyint(x);
+void test__pow__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((pow(arg1, arg2) > 10) || (pow(arg1, arg2) < 100)) {}
 }
 
-void test__std__nearbyint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::nearbyint(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__pow__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = pow(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__nearbyint__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::nearbyint(arg1);
+void test__pow__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = pow(x, arg2);
 }
 
-void test__std__nearbyint__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::nearbyint(arg1) > 10) || (std::nearbyint(arg1) < 100)) {}
+void test__pow__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = pow(arg1, x);
 }
 
-void test__std__nearbyint__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::nearbyint(x);
+void test__std__pow__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::pow(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nearbyintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = nearbyintf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__pow__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::pow(arg1, arg2);
 }
 
-void test__nearbyintf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    nearbyintf(arg1);
+void test__std__pow__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::pow(arg1, arg2) > 10) || (std::pow(arg1, arg2) < 100)) {}
 }
 
-void test__nearbyintf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((nearbyintf(arg1) > 10) || (nearbyintf(arg1) < 100)) {}
+void test__std__pow__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::pow(x, arg2);
 }
 
-void test__nearbyintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = nearbyintf(p);
-    // cppcheck-suppress memleak
+void test__std__pow__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::pow(arg1, x);
 }
 
-void test__nearbyintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = nearbyintf(x);
+void test__powf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = powf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__nearbyintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::nearbyintf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__powf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  powf(arg1, arg2);
 }
 
-void test__std__nearbyintf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::nearbyintf(arg1);
+void test__powf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((powf(arg1, arg2) > 10) || (powf(arg1, arg2) < 100)) {}
 }
 
-void test__std__nearbyintf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::nearbyintf(arg1) > 10) || (std::nearbyintf(arg1) < 100)) {}
+void test__powf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = powf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__nearbyintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::nearbyintf(x);
+void test__powf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = powf(x, arg2);
 }
 
-void test__nearbyintl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = nearbyintl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__powf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = powf(arg1, x);
 }
 
-void test__nearbyintl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    nearbyintl(arg1);
+void test__std__powf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::powf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nearbyintl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((nearbyintl(arg1) > 10) || (nearbyintl(arg1) < 100)) {}
+void test__std__powf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::powf(arg1, arg2);
 }
 
-void test__nearbyintl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = nearbyintl(p);
-    // cppcheck-suppress memleak
+void test__std__powf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::powf(arg1, arg2) > 10) || (std::powf(arg1, arg2) < 100)) {}
 }
 
-void test__nearbyintl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = nearbyintl(x);
+void test__std__powf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::powf(x, arg2);
 }
 
-void test__std__nearbyintl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::nearbyintl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__powf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::powf(arg1, x);
 }
 
-void test__std__nearbyintl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::nearbyintl(arg1);
+void test__powl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = powl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__nearbyintl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::nearbyintl(arg1) > 10) || (std::nearbyintl(arg1) < 100)) {}
+void test__powl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  powl(arg1, arg2);
 }
 
-void test__std__nearbyintl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::nearbyintl(x);
+void test__powl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((powl(arg1, arg2) > 10) || (powl(arg1, arg2) < 100)) {}
 }
 
-void test__nextafter__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = nextafter(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__powl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = powl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__nextafter__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    nextafter(arg1, arg2);
+void test__powl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = powl(x, arg2);
 }
 
-void test__nextafter__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((nextafter(arg1, arg2) > 10) || (nextafter(arg1, arg2) < 100)) {}
+void test__powl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = powl(arg1, x);
 }
 
-void test__nextafter__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = nextafter(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__powl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::powl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nextafter__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = nextafter(x, arg2);
+void test__std__powl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::powl(arg1, arg2);
 }
 
-void test__nextafter__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = nextafter(arg1, x);
+void test__std__powl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::powl(arg1, arg2) > 10) || (std::powl(arg1, arg2) < 100)) {}
 }
 
-void test__std__nextafter__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::nextafter(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__powl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::powl(x, arg2);
 }
 
-void test__std__nextafter__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::nextafter(arg1, arg2);
+void test__std__powl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::powl(arg1, x);
 }
 
-void test__std__nextafter__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::nextafter(arg1, arg2) > 10) || (std::nextafter(arg1, arg2) < 100)) {}
+void test__cpow__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cpow(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__nextafter__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::nextafter(x, arg2);
+void test__cpow__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cpow(arg1, arg2);
 }
 
-void test__std__nextafter__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::nextafter(arg1, x);
+void test__cpow__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cpow(arg1, arg2) > 10) || (cpow(arg1, arg2) < 100)) {}
 }
 
-void test__nextafterf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = nextafterf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cpow__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cpow(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__nextafterf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    nextafterf(arg1, arg2);
+void test__cpow__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cpow(x, arg2);
 }
 
-void test__nextafterf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((nextafterf(arg1, arg2) > 10) || (nextafterf(arg1, arg2) < 100)) {}
+void test__cpow__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cpow(arg1, x);
 }
 
-void test__nextafterf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = nextafterf(p, arg2);
-    // cppcheck-suppress memleak
+void test__cpowf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cpowf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nextafterf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = nextafterf(x, arg2);
+void test__cpowf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cpowf(arg1, arg2);
 }
 
-void test__nextafterf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = nextafterf(arg1, x);
+void test__cpowf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cpowf(arg1, arg2) > 10) || (cpowf(arg1, arg2) < 100)) {}
 }
 
-void test__std__nextafterf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::nextafterf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cpowf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cpowf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__nextafterf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::nextafterf(arg1, arg2);
+void test__cpowf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cpowf(x, arg2);
 }
 
-void test__std__nextafterf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::nextafterf(arg1, arg2) > 10) || (std::nextafterf(arg1, arg2) < 100)) {}
+void test__cpowf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cpowf(arg1, x);
 }
 
-void test__std__nextafterf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::nextafterf(x, arg2);
+void test__cpowl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = cpowl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__nextafterf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::nextafterf(arg1, x);
+void test__cpowl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cpowl(arg1, arg2);
 }
 
-void test__nextafterl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = nextafterl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__cpowl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cpowl(arg1, arg2) > 10) || (cpowl(arg1, arg2) < 100)) {}
 }
 
-void test__nextafterl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    nextafterl(arg1, arg2);
+void test__cpowl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = cpowl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__nextafterl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((nextafterl(arg1, arg2) > 10) || (nextafterl(arg1, arg2) < 100)) {}
+void test__cpowl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cpowl(x, arg2);
 }
 
-void test__nextafterl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = nextafterl(p, arg2);
-    // cppcheck-suppress memleak
+void test__cpowl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cpowl(arg1, x);
 }
 
-void test__nextafterl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = nextafterl(x, arg2);
+void test__remainder__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = remainder(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nextafterl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = nextafterl(arg1, x);
+void test__remainder__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  remainder(arg1, arg2);
 }
 
-void test__std__nextafterl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::nextafterl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__remainder__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((remainder(arg1, arg2) > 10) || (remainder(arg1, arg2) < 100)) {}
 }
 
-void test__std__nextafterl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::nextafterl(arg1, arg2);
+void test__remainder__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = remainder(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__nextafterl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::nextafterl(arg1, arg2) > 10) || (std::nextafterl(arg1, arg2) < 100)) {}
+void test__remainder__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remainder(x, arg2);
 }
 
-void test__std__nextafterl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::nextafterl(x, arg2);
+void test__remainder__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remainder(arg1, x);
 }
 
-void test__std__nextafterl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::nextafterl(arg1, x);
+void test__std__remainder__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::remainder(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nexttoward__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = nexttoward(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__remainder__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::remainder(arg1, arg2);
 }
 
-void test__nexttoward__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    nexttoward(arg1, arg2);
+void test__std__remainder__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::remainder(arg1, arg2) > 10) || (std::remainder(arg1, arg2) < 100)) {}
 }
 
-void test__nexttoward__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((nexttoward(arg1, arg2) > 10) || (nexttoward(arg1, arg2) < 100)) {}
+void test__std__remainder__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remainder(x, arg2);
 }
 
-void test__nexttoward__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = nexttoward(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__remainder__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remainder(arg1, x);
 }
 
-void test__nexttoward__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = nexttoward(x, arg2);
+void test__remainderf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = remainderf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nexttoward__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = nexttoward(arg1, x);
+void test__remainderf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  remainderf(arg1, arg2);
 }
 
-void test__std__nexttoward__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::nexttoward(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__remainderf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((remainderf(arg1, arg2) > 10) || (remainderf(arg1, arg2) < 100)) {}
 }
 
-void test__std__nexttoward__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::nexttoward(arg1, arg2);
+void test__remainderf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = remainderf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__nexttoward__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::nexttoward(arg1, arg2) > 10) || (std::nexttoward(arg1, arg2) < 100)) {}
+void test__remainderf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remainderf(x, arg2);
 }
 
-void test__std__nexttoward__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::nexttoward(x, arg2);
+void test__remainderf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remainderf(arg1, x);
 }
 
-void test__std__nexttoward__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::nexttoward(arg1, x);
+void test__std__remainderf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::remainderf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nexttowardf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = nexttowardf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__remainderf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::remainderf(arg1, arg2);
 }
 
-void test__nexttowardf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    nexttowardf(arg1, arg2);
+void test__std__remainderf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::remainderf(arg1, arg2) > 10) || (std::remainderf(arg1, arg2) < 100)) {}
 }
 
-void test__nexttowardf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((nexttowardf(arg1, arg2) > 10) || (nexttowardf(arg1, arg2) < 100)) {}
+void test__std__remainderf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remainderf(x, arg2);
 }
 
-void test__nexttowardf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = nexttowardf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__remainderf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remainderf(arg1, x);
 }
 
-void test__nexttowardf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = nexttowardf(x, arg2);
+void test__remainderl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = remainderl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nexttowardf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = nexttowardf(arg1, x);
+void test__remainderl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  remainderl(arg1, arg2);
 }
 
-void test__std__nexttowardf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::nexttowardf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__remainderl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((remainderl(arg1, arg2) > 10) || (remainderl(arg1, arg2) < 100)) {}
 }
 
-void test__std__nexttowardf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::nexttowardf(arg1, arg2);
+void test__remainderl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = remainderl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__nexttowardf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::nexttowardf(arg1, arg2) > 10) || (std::nexttowardf(arg1, arg2) < 100)) {}
+void test__remainderl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remainderl(x, arg2);
 }
 
-void test__std__nexttowardf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::nexttowardf(x, arg2);
+void test__remainderl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remainderl(arg1, x);
 }
 
-void test__std__nexttowardf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::nexttowardf(arg1, x);
+void test__std__remainderl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::remainderl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nexttowardl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = nexttowardl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__remainderl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::remainderl(arg1, arg2);
 }
 
-void test__nexttowardl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    nexttowardl(arg1, arg2);
+void test__std__remainderl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::remainderl(arg1, arg2) > 10) || (std::remainderl(arg1, arg2) < 100)) {}
 }
 
-void test__nexttowardl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((nexttowardl(arg1, arg2) > 10) || (nexttowardl(arg1, arg2) < 100)) {}
+void test__std__remainderl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remainderl(x, arg2);
 }
 
-void test__nexttowardl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = nexttowardl(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__remainderl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remainderl(arg1, x);
 }
 
-void test__nexttowardl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = nexttowardl(x, arg2);
+void test__remquo__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = remquo(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__nexttowardl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = nexttowardl(arg1, x);
+void test__remquo__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  remquo(arg1, arg2, arg3);
 }
 
-void test__std__nexttowardl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::nexttowardl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__remquo__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((remquo(arg1, arg2, arg3) > 10) || (remquo(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__nexttowardl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::nexttowardl(arg1, arg2);
+void test__remquo__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = remquo(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__nexttowardl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::nexttowardl(arg1, arg2) > 10) || (std::nexttowardl(arg1, arg2) < 100)) {}
+void test__remquo__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remquo(x, arg2, arg3);
 }
 
-void test__std__nexttowardl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::nexttowardl(x, arg2);
+void test__remquo__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remquo(arg1, x, arg3);
 }
 
-void test__std__nexttowardl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::nexttowardl(arg1, x);
+void test__remquo__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = remquo(arg1, arg2, NULL);
 }
 
-void test__longjmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        longjmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__remquo__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::remquo(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__longjmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    longjmp(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__remquo__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::remquo(arg1, arg2, arg3);
 }
 
-void test__longjmp__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    longjmp(x, arg2);
+void test__std__remquo__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::remquo(arg1, arg2, arg3) > 10) || (std::remquo(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__longjmp__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    longjmp(arg1, x);
+void test__std__remquo__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remquo(x, arg2, arg3);
 }
 
-void test__std__longjmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::longjmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__remquo__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remquo(arg1, x, arg3);
 }
 
-void test__std__longjmp__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::longjmp(x, arg2);
+void test__std__remquo__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::remquo(arg1, arg2, NULL);
 }
 
-void test__std__longjmp__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::longjmp(arg1, x);
+void test__remquof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = remquof(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__malloc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = malloc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__remquof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  remquof(arg1, arg2, arg3);
 }
 
-void test__malloc__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    malloc(arg1);
+void test__remquof__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((remquof(arg1, arg2, arg3) > 10) || (remquof(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__malloc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = malloc(x);
+void test__remquof__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = remquof(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__malloc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::malloc(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__remquof__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remquof(x, arg2, arg3);
 }
 
-void test__std__malloc__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::malloc(arg1);
+void test__remquof__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remquof(arg1, x, arg3);
 }
 
-void test__std__malloc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::malloc(x);
+void test__remquof__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = remquof(arg1, arg2, NULL);
 }
 
-void test__alloca__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = alloca(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__remquof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::remquof(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__alloca__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    alloca(arg1);
+void test__std__remquof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::remquof(arg1, arg2, arg3);
 }
 
-void test__alloca__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = alloca(x);
+void test__std__remquof__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::remquof(arg1, arg2, arg3) > 10) || (std::remquof(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__memchr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = memchr(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__remquof__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remquof(x, arg2, arg3);
 }
 
-void test__memchr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    memchr(arg1, arg2, arg3);
+void test__std__remquof__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remquof(arg1, x, arg3);
 }
 
-void test__memchr__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((memchr(arg1, arg2, arg3) > 10) || (memchr(arg1, arg2, arg3) < 100)) {}
+void test__std__remquof__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::remquof(arg1, arg2, NULL);
 }
 
-void test__memchr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = memchr(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__remquol__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = remquol(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__memchr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = memchr(NULL, arg2, arg3);
+void test__remquol__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  remquol(arg1, arg2, arg3);
 }
 
-void test__memchr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = memchr(x, arg2, arg3);
+void test__remquol__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((remquol(arg1, arg2, arg3) > 10) || (remquol(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__memchr__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = memchr(arg1, !x, arg3);
+void test__remquol__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = remquol(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__memchr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = memchr(arg1, x, arg3);
+void test__remquol__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remquol(x, arg2, arg3);
 }
 
-void test__memchr__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = memchr(arg1, arg2, !x);
+void test__remquol__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remquol(arg1, x, arg3);
 }
 
-void test__memchr__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = memchr(arg1, arg2, x);
+void test__remquol__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = remquol(arg1, arg2, NULL);
 }
 
-void test__std__memchr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::memchr(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__remquol__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::remquol(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__memchr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::memchr(arg1, arg2, arg3);
+void test__std__remquol__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::remquol(arg1, arg2, arg3);
 }
 
-void test__std__memchr__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::memchr(arg1, arg2, arg3) > 10) || (std::memchr(arg1, arg2, arg3) < 100)) {}
+void test__std__remquol__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::remquol(arg1, arg2, arg3) > 10) || (std::remquol(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__memchr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::memchr(NULL, arg2, arg3);
+void test__std__remquol__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remquol(x, arg2, arg3);
 }
 
-void test__std__memchr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::memchr(x, arg2, arg3);
+void test__std__remquol__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remquol(arg1, x, arg3);
 }
 
-void test__std__memchr__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = std::memchr(arg1, !x, arg3);
+void test__std__remquol__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::remquol(arg1, arg2, NULL);
 }
 
-void test__std__memchr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::memchr(arg1, x, arg3);
+void test__printf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; printf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__memchr__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = std::memchr(arg1, arg2, !x);
+void test__printf__leakignore() {
+  char *p = malloc(10); *p=0;
+  printf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__memchr__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::memchr(arg1, arg2, x);
+void test__printf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  printf(x);
 }
 
-void test__wmemchr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wmemchr(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__printf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::printf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wmemchr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wmemchr(arg1, arg2, arg3);
+void test__std__printf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::printf(x);
 }
 
-void test__wmemchr__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((wmemchr(arg1, arg2, arg3) > 10) || (wmemchr(arg1, arg2, arg3) < 100)) {}
+void test__vprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vprintf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wmemchr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wmemchr(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__vprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  vprintf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__wmemchr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wmemchr(NULL, arg2, arg3);
+void test__vprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vprintf(x, arg2);
 }
 
-void test__wmemchr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wmemchr(x, arg2, arg3);
+void test__std__vprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vprintf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wmemchr__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = wmemchr(arg1, !x, arg3);
+void test__std__vprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vprintf(x, arg2);
 }
 
-void test__wmemchr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wmemchr(arg1, x, arg3);
+void test__vwprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vwprintf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wmemchr__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = wmemchr(arg1, arg2, !x);
+void test__vwprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  vwprintf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__wmemchr__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wmemchr(arg1, arg2, x);
+void test__vwprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vwprintf(x, arg2);
 }
 
-void test__std__wmemchr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wmemchr(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vwprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vwprintf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wmemchr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wmemchr(arg1, arg2, arg3);
+void test__std__vwprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vwprintf(x, arg2);
 }
 
-void test__std__wmemchr__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::wmemchr(arg1, arg2, arg3) > 10) || (std::wmemchr(arg1, arg2, arg3) < 100)) {}
+void test__bsearch__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = bsearch(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wmemchr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wmemchr(NULL, arg2, arg3);
+void test__bsearch__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  bsearch(arg1, arg2, arg3, arg4, arg5);
 }
 
-void test__std__wmemchr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wmemchr(x, arg2, arg3);
+void test__bsearch__pure(int arg1,int arg2,int arg3,int arg4,int arg5) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((bsearch(arg1, arg2, arg3, arg4, arg5) > 10) || (bsearch(arg1, arg2, arg3, arg4, arg5) < 100)) {}
 }
 
-void test__std__wmemchr__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = std::wmemchr(arg1, !x, arg3);
+void test__bsearch__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = bsearch(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wmemchr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wmemchr(arg1, x, arg3);
+void test__bsearch__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = bsearch(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test__std__wmemchr__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = std::wmemchr(arg1, arg2, !x);
+void test__bsearch__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = bsearch(x, arg2, arg3, arg4, arg5);
 }
 
-void test__std__wmemchr__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wmemchr(arg1, arg2, x);
+void test__bsearch__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = bsearch(arg1, NULL, arg3, arg4, arg5);
 }
 
-void test__memcmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = memcmp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__bsearch__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = bsearch(arg1, x, arg3, arg4, arg5);
 }
 
-void test__memcmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    memcmp(arg1, arg2, arg3);
+void test__bsearch__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = bsearch(arg1, arg2, x, arg4, arg5);
 }
 
-void test__memcmp__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((memcmp(arg1, arg2, arg3) > 10) || (memcmp(arg1, arg2, arg3) < 100)) {}
+void test__bsearch__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = bsearch(arg1, arg2, arg3, x, arg5);
 }
 
-void test__memcmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = memcmp(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__bsearch__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  result = bsearch(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test__memcmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = memcmp(NULL, arg2, arg3);
+void test__bsearch__arg5__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = bsearch(arg1, arg2, arg3, arg4, x);
 }
 
-void test__memcmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = memcmp(x, arg2, arg3);
+void test__std__bsearch__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::bsearch(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__memcmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = memcmp(arg1, NULL, arg3);
+void test__std__bsearch__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::bsearch(arg1, arg2, arg3, arg4, arg5);
 }
 
-void test__memcmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = memcmp(arg1, x, arg3);
+void test__std__bsearch__pure(int arg1,int arg2,int arg3,int arg4,int arg5) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::bsearch(arg1, arg2, arg3, arg4, arg5) > 10) || (std::bsearch(arg1, arg2, arg3, arg4, arg5) < 100)) {}
 }
 
-void test__memcmp__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = memcmp(arg1, arg2, !x);
+void test__std__bsearch__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::bsearch(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test__memcmp__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = memcmp(arg1, arg2, x);
+void test__std__bsearch__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::bsearch(x, arg2, arg3, arg4, arg5);
 }
 
-void test__std__memcmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::memcmp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__bsearch__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::bsearch(arg1, NULL, arg3, arg4, arg5);
 }
 
-void test__std__memcmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::memcmp(arg1, arg2, arg3);
+void test__std__bsearch__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::bsearch(arg1, x, arg3, arg4, arg5);
 }
 
-void test__std__memcmp__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::memcmp(arg1, arg2, arg3) > 10) || (std::memcmp(arg1, arg2, arg3) < 100)) {}
+void test__std__bsearch__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::bsearch(arg1, arg2, x, arg4, arg5);
 }
 
-void test__std__memcmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::memcmp(NULL, arg2, arg3);
+void test__std__bsearch__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::bsearch(arg1, arg2, arg3, x, arg5);
 }
 
-void test__std__memcmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::memcmp(x, arg2, arg3);
+void test__std__bsearch__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::bsearch(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test__std__memcmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::memcmp(arg1, NULL, arg3);
+void test__std__bsearch__arg5__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::bsearch(arg1, arg2, arg3, arg4, x);
 }
 
-void test__std__memcmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::memcmp(arg1, x, arg3);
+void test__qsort__noreturn() {
+  int x = 1;
+  if (cond) { x=100; qsort(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__memcmp__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = std::memcmp(arg1, arg2, !x);
+void test__qsort__leakignore() {
+  char *p = malloc(10); *p=0;
+  qsort(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__std__memcmp__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::memcmp(arg1, arg2, x);
+void test__qsort__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  qsort(NULL, arg2, arg3, arg4);
 }
 
-void test__wmemcmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wmemcmp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__qsort__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  qsort(x, arg2, arg3, arg4);
 }
 
-void test__wmemcmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wmemcmp(arg1, arg2, arg3);
+void test__qsort__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qsort(arg1, x, arg3, arg4);
 }
 
-void test__wmemcmp__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((wmemcmp(arg1, arg2, arg3) > 10) || (wmemcmp(arg1, arg2, arg3) < 100)) {}
+void test__qsort__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qsort(arg1, arg2, x, arg4);
 }
 
-void test__wmemcmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wmemcmp(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__qsort__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  qsort(arg1, arg2, arg3, NULL);
 }
 
-void test__wmemcmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wmemcmp(NULL, arg2, arg3);
+void test__qsort__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  qsort(arg1, arg2, arg3, x);
 }
 
-void test__wmemcmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wmemcmp(x, arg2, arg3);
+void test__std__qsort__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::qsort(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wmemcmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wmemcmp(arg1, NULL, arg3);
+void test__std__qsort__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::qsort(NULL, arg2, arg3, arg4);
 }
 
-void test__wmemcmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wmemcmp(arg1, x, arg3);
+void test__std__qsort__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::qsort(x, arg2, arg3, arg4);
 }
 
-void test__wmemcmp__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = wmemcmp(arg1, arg2, !x);
+void test__std__qsort__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::qsort(arg1, x, arg3, arg4);
 }
 
-void test__wmemcmp__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wmemcmp(arg1, arg2, x);
+void test__std__qsort__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::qsort(arg1, arg2, x, arg4);
 }
 
-void test__std__wmemcmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wmemcmp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__qsort__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  std::qsort(arg1, arg2, arg3, NULL);
 }
 
-void test__std__wmemcmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wmemcmp(arg1, arg2, arg3);
+void test__std__qsort__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::qsort(arg1, arg2, arg3, x);
 }
 
-void test__std__wmemcmp__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::wmemcmp(arg1, arg2, arg3) > 10) || (std::wmemcmp(arg1, arg2, arg3) < 100)) {}
+void test__putc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; putc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wmemcmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wmemcmp(NULL, arg2, arg3);
+void test__putc__leakignore() {
+  char *p = malloc(10); *p=0;
+  putc(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wmemcmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wmemcmp(x, arg2, arg3);
+void test__putc__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  putc(!x, arg2);
 }
 
-void test__std__wmemcmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wmemcmp(arg1, NULL, arg3);
+void test__putc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  putc(x, arg2);
 }
 
-void test__std__wmemcmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wmemcmp(arg1, x, arg3);
+void test__putc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  putc(arg1, NULL);
 }
 
-void test__std__wmemcmp__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = std::wmemcmp(arg1, arg2, !x);
+void test__putc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  putc(arg1, x);
 }
 
-void test__std__wmemcmp__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wmemcmp(arg1, arg2, x);
+void test__std__putc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::putc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__memcpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        memcpy(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__putc__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::putc(!x, arg2);
 }
 
-void test__memcpy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    memcpy(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__putc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::putc(x, arg2);
 }
 
-void test__memcpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    memcpy(NULL, arg2, arg3);
+void test__std__putc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::putc(arg1, NULL);
 }
 
-void test__memcpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    memcpy(arg1, NULL, arg3);
+void test__std__putc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::putc(arg1, x);
 }
 
-void test__memcpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    memcpy(arg1, x, arg3);
+void test__putwc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; putwc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__memcpy__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    memcpy(arg1, arg2, !x);
+void test__putwc__leakignore() {
+  char *p = malloc(10); *p=0;
+  putwc(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__memcpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    memcpy(arg1, arg2, x);
+void test__putwc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  putwc(x, arg2);
 }
 
-void test__std__memcpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::memcpy(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__putwc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  putwc(arg1, NULL);
 }
 
-void test__std__memcpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::memcpy(NULL, arg2, arg3);
+void test__putwc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  putwc(arg1, x);
 }
 
-void test__std__memcpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::memcpy(arg1, NULL, arg3);
+void test__std__putwc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::putwc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__memcpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::memcpy(arg1, x, arg3);
+void test__std__putwc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::putwc(x, arg2);
 }
 
-void test__std__memcpy__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::memcpy(arg1, arg2, !x);
+void test__std__putwc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::putwc(arg1, NULL);
 }
 
-void test__std__memcpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::memcpy(arg1, arg2, x);
+void test__std__putwc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::putwc(arg1, x);
 }
 
-void test__wmemcpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wmemcpy(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__putchar__noreturn() {
+  int x = 1;
+  if (cond) { x=100; putchar(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wmemcpy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wmemcpy(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__putchar__leakignore() {
+  char *p = malloc(10); *p=0;
+  putchar(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wmemcpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wmemcpy(NULL, arg2, arg3);
+void test__putchar__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  putchar(!x);
 }
 
-void test__wmemcpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wmemcpy(arg1, NULL, arg3);
+void test__putchar__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  putchar(x);
 }
 
-void test__wmemcpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wmemcpy(arg1, x, arg3);
+void test__std__putchar__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::putchar(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wmemcpy__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wmemcpy(arg1, arg2, !x);
+void test__std__putchar__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::putchar(!x);
 }
 
-void test__wmemcpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wmemcpy(arg1, arg2, x);
+void test__std__putchar__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::putchar(x);
 }
 
-void test__std__wmemcpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wmemcpy(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__putwchar__noreturn() {
+  int x = 1;
+  if (cond) { x=100; putwchar(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wmemcpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wmemcpy(NULL, arg2, arg3);
+void test__putwchar__leakignore() {
+  char *p = malloc(10); *p=0;
+  putwchar(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wmemcpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wmemcpy(arg1, NULL, arg3);
+void test__putwchar__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  putwchar(x);
 }
 
-void test__std__wmemcpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wmemcpy(arg1, x, arg3);
+void test__std__putwchar__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::putwchar(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wmemcpy__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::wmemcpy(arg1, arg2, !x);
+void test__std__putwchar__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::putwchar(x);
 }
 
-void test__std__wmemcpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wmemcpy(arg1, arg2, x);
+void test__puts__noreturn() {
+  int x = 1;
+  if (cond) { x=100; puts(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__memcpy_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        memcpy_s(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__puts__leakignore() {
+  char *p = malloc(10); *p=0;
+  puts(p);
+  // cppcheck-suppress memleak
 }
 
-void test__memcpy_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    memcpy_s(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__puts__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  puts(!x);
 }
 
-void test__memcpy_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    memcpy_s(NULL, arg2, arg3, arg4);
+void test__puts__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  puts(NULL);
 }
 
-void test__memcpy_s__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    memcpy_s(arg1, !x, arg3, arg4);
+void test__puts__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  puts(x);
 }
 
-void test__memcpy_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    memcpy_s(arg1, x, arg3, arg4);
+void test__std__puts__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::puts(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__memcpy_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    memcpy_s(arg1, arg2, NULL, arg4);
+void test__std__puts__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::puts(!x);
 }
 
-void test__memcpy_s__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    memcpy_s(arg1, arg2, x, arg4);
+void test__std__puts__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::puts(NULL);
 }
 
-void test__memcpy_s__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    memcpy_s(arg1, arg2, arg3, !x);
+void test__std__puts__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::puts(x);
 }
 
-void test__memcpy_s__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    memcpy_s(arg1, arg2, arg3, x);
+void test__realloc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; realloc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wmemcpy_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wmemcpy_s(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__realloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  realloc(x, arg2);
 }
 
-void test__wmemcpy_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wmemcpy_s(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__realloc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  realloc(arg1, x);
 }
 
-void test__wmemcpy_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wmemcpy_s(NULL, arg2, arg3, arg4);
+void test__std__realloc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::realloc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wmemcpy_s__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wmemcpy_s(arg1, !x, arg3, arg4);
+void test__std__realloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::realloc(x, arg2);
 }
 
-void test__wmemcpy_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wmemcpy_s(arg1, x, arg3, arg4);
+void test__std__realloc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::realloc(arg1, x);
 }
 
-void test__wmemcpy_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wmemcpy_s(arg1, arg2, NULL, arg4);
+void test__remove__noreturn() {
+  int x = 1;
+  if (cond) { x=100; remove(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wmemcpy_s__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wmemcpy_s(arg1, arg2, x, arg4);
+void test__remove__leakignore() {
+  char *p = malloc(10); *p=0;
+  remove(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wmemcpy_s__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wmemcpy_s(arg1, arg2, arg3, !x);
+void test__remove__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  remove(NULL);
 }
 
-void test__wmemcpy_s__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wmemcpy_s(arg1, arg2, arg3, x);
+void test__remove__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  remove(x);
 }
 
-void test__memmove__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        memmove(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__remove__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::remove(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__memmove__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    memmove(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__remove__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::remove(NULL);
 }
 
-void test__memmove__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    memmove(NULL, arg2, arg3);
+void test__std__remove__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::remove(x);
 }
 
-void test__memmove__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    memmove(arg1, NULL, arg3);
+void test__rename__noreturn() {
+  int x = 1;
+  if (cond) { x=100; rename(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__memmove__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    memmove(arg1, x, arg3);
+void test__rename__leakignore() {
+  char *p = malloc(10); *p=0;
+  rename(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__memmove__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    memmove(arg1, arg2, !x);
+void test__rename__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  rename(NULL, arg2);
 }
 
-void test__memmove__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    memmove(arg1, arg2, x);
+void test__rename__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  rename(x, arg2);
 }
 
-void test__std__memmove__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::memmove(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__rename__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  rename(arg1, NULL);
 }
 
-void test__std__memmove__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::memmove(NULL, arg2, arg3);
+void test__rename__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  rename(arg1, x);
 }
 
-void test__std__memmove__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::memmove(arg1, NULL, arg3);
+void test__std__rename__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::rename(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__memmove__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::memmove(arg1, x, arg3);
+void test__std__rename__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::rename(NULL, arg2);
 }
 
-void test__std__memmove__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::memmove(arg1, arg2, !x);
+void test__std__rename__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::rename(x, arg2);
 }
 
-void test__std__memmove__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::memmove(arg1, arg2, x);
+void test__std__rename__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::rename(arg1, NULL);
 }
 
-void test__wmemmove__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wmemmove(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__rename__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::rename(arg1, x);
 }
 
-void test__wmemmove__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wmemmove(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__rewind__noreturn() {
+  int x = 1;
+  if (cond) { x=100; rewind(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wmemmove__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wmemmove(NULL, arg2, arg3);
+void test__rewind__leakignore() {
+  char *p = malloc(10); *p=0;
+  rewind(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wmemmove__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wmemmove(arg1, NULL, arg3);
+void test__rewind__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  rewind(NULL);
 }
 
-void test__wmemmove__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wmemmove(arg1, x, arg3);
+void test__rewind__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  rewind(x);
 }
 
-void test__wmemmove__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wmemmove(arg1, arg2, !x);
+void test__std__rewind__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::rewind(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wmemmove__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wmemmove(arg1, arg2, x);
+void test__std__rewind__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::rewind(NULL);
 }
 
-void test__std__wmemmove__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wmemmove(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__rewind__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::rewind(x);
 }
 
-void test__std__wmemmove__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wmemmove(NULL, arg2, arg3);
+void test__round__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = round(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wmemmove__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wmemmove(arg1, NULL, arg3);
+void test__round__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  round(arg1);
 }
 
-void test__std__wmemmove__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wmemmove(arg1, x, arg3);
+void test__round__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((round(arg1) > 10) || (round(arg1) < 100)) {}
 }
 
-void test__std__wmemmove__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::wmemmove(arg1, arg2, !x);
+void test__round__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = round(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wmemmove__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wmemmove(arg1, arg2, x);
+void test__round__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = round(x);
 }
 
-void test__memset_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        memset_s(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__round__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::round(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__memset_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    memset_s(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__std__round__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::round(arg1);
 }
 
-void test__memset_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    memset_s(NULL, arg2, arg3, arg4);
+void test__std__round__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::round(arg1) > 10) || (std::round(arg1) < 100)) {}
 }
 
-void test__memset_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    memset_s(arg1, x, arg3, arg4);
+void test__std__round__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::round(x);
 }
 
-void test__memset_s__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    memset_s(arg1, arg2, x, arg4);
+void test__roundf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = roundf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__memset_s__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    memset_s(arg1, arg2, arg3, x);
+void test__roundf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  roundf(arg1);
 }
 
-void test__memset__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        memset(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__roundf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((roundf(arg1) > 10) || (roundf(arg1) < 100)) {}
 }
 
-void test__memset__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    memset(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__roundf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = roundf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__memset__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    memset(NULL, arg2, arg3);
+void test__roundf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = roundf(x);
 }
 
-void test__memset__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    memset(arg1, x, arg3);
+void test__std__roundf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::roundf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__memset__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    memset(arg1, arg2, !x);
+void test__std__roundf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::roundf(arg1);
 }
 
-void test__memset__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    memset(arg1, arg2, x);
+void test__std__roundf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::roundf(arg1) > 10) || (std::roundf(arg1) < 100)) {}
 }
 
-void test__std__memset__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::memset(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__roundf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::roundf(x);
 }
 
-void test__std__memset__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::memset(NULL, arg2, arg3);
+void test__roundl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = roundl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__memset__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::memset(arg1, x, arg3);
+void test__roundl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  roundl(arg1);
 }
 
-void test__std__memset__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::memset(arg1, arg2, !x);
+void test__roundl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((roundl(arg1) > 10) || (roundl(arg1) < 100)) {}
 }
 
-void test__std__memset__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::memset(arg1, arg2, x);
+void test__roundl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = roundl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wmemset__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wmemset(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__roundl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = roundl(x);
 }
 
-void test__wmemset__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wmemset(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__roundl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::roundl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wmemset__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wmemset(NULL, arg2, arg3);
+void test__std__roundl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::roundl(arg1);
 }
 
-void test__wmemset__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wmemset(arg1, x, arg3);
+void test__std__roundl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::roundl(arg1) > 10) || (std::roundl(arg1) < 100)) {}
 }
 
-void test__wmemset__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wmemset(arg1, arg2, !x);
+void test__std__roundl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::roundl(x);
 }
 
-void test__wmemset__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wmemset(arg1, arg2, x);
+void test__scalbn__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = scalbn(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wmemset__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wmemset(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__scalbn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  scalbn(arg1, arg2);
 }
 
-void test__std__wmemset__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wmemset(NULL, arg2, arg3);
+void test__scalbn__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((scalbn(arg1, arg2) > 10) || (scalbn(arg1, arg2) < 100)) {}
 }
 
-void test__std__wmemset__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wmemset(arg1, x, arg3);
+void test__scalbn__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = scalbn(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wmemset__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::wmemset(arg1, arg2, !x);
+void test__scalbn__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbn(x, arg2);
 }
 
-void test__std__wmemset__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wmemset(arg1, arg2, x);
+void test__scalbn__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbn(arg1, x);
 }
 
-void test__mktime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mktime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__scalbn__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::scalbn(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mktime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mktime(p);
-    // cppcheck-suppress memleak
+void test__std__scalbn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::scalbn(arg1, arg2);
 }
 
-void test__mktime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mktime(NULL);
+void test__std__scalbn__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::scalbn(arg1, arg2) > 10) || (std::scalbn(arg1, arg2) < 100)) {}
 }
 
-void test__mktime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    mktime(x);
+void test__std__scalbn__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbn(x, arg2);
 }
 
-void test__std__mktime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::mktime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__scalbn__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbn(arg1, x);
 }
 
-void test__std__mktime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::mktime(NULL);
+void test__scalbnf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = scalbnf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__mktime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::mktime(x);
+void test__scalbnf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  scalbnf(arg1, arg2);
 }
 
-void test__mkxtime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mkxtime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__scalbnf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((scalbnf(arg1, arg2) > 10) || (scalbnf(arg1, arg2) < 100)) {}
 }
 
-void test__mkxtime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mkxtime(p);
-    // cppcheck-suppress memleak
+void test__scalbnf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = scalbnf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__mkxtime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mkxtime(NULL);
+void test__scalbnf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbnf(x, arg2);
 }
 
-void test__mkxtime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    mkxtime(x);
+void test__scalbnf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbnf(arg1, x);
 }
 
-void test__modf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        modf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__scalbnf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::scalbnf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__modf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    modf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__scalbnf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::scalbnf(arg1, arg2);
 }
 
-void test__modf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    modf(x, arg2);
+void test__std__scalbnf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::scalbnf(arg1, arg2) > 10) || (std::scalbnf(arg1, arg2) < 100)) {}
 }
 
-void test__modf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    modf(arg1, NULL);
+void test__std__scalbnf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbnf(x, arg2);
 }
 
-void test__std__modf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::modf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__scalbnf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbnf(arg1, x);
 }
 
-void test__std__modf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::modf(x, arg2);
+void test__scalbnl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = scalbnl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__modf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::modf(arg1, NULL);
+void test__scalbnl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  scalbnl(arg1, arg2);
 }
 
-void test__modff__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        modff(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__scalbnl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((scalbnl(arg1, arg2) > 10) || (scalbnl(arg1, arg2) < 100)) {}
 }
 
-void test__modff__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    modff(p, arg2);
-    // cppcheck-suppress memleak
+void test__scalbnl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = scalbnl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__modff__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    modff(x, arg2);
+void test__scalbnl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbnl(x, arg2);
 }
 
-void test__modff__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    modff(arg1, NULL);
+void test__scalbnl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbnl(arg1, x);
 }
 
-void test__std__modff__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::modff(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__scalbnl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::scalbnl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__modff__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::modff(x, arg2);
+void test__std__scalbnl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::scalbnl(arg1, arg2);
 }
 
-void test__std__modff__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::modff(arg1, NULL);
+void test__std__scalbnl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::scalbnl(arg1, arg2) > 10) || (std::scalbnl(arg1, arg2) < 100)) {}
 }
 
-void test__modfl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        modfl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__std__scalbnl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbnl(x, arg2);
+}
 
-void test__modfl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    modfl(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__scalbnl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbnl(arg1, x);
 }
 
-void test__modfl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    modfl(x, arg2);
+void test__scalbln__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = scalbln(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__modfl__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    modfl(arg1, NULL);
+void test__scalbln__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  scalbln(arg1, arg2);
 }
 
-void test__std__modfl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::modfl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__scalbln__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((scalbln(arg1, arg2) > 10) || (scalbln(arg1, arg2) < 100)) {}
 }
 
-void test__std__modfl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::modfl(x, arg2);
+void test__scalbln__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = scalbln(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__modfl__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::modfl(arg1, NULL);
+void test__scalbln__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbln(x, arg2);
 }
 
-void test__perror__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        perror(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__scalbln__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbln(arg1, x);
 }
 
-void test__perror__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    perror(p);
-    // cppcheck-suppress memleak
+void test__std__scalbln__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::scalbln(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__perror__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    perror(x);
+void test__std__scalbln__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::scalbln(arg1, arg2);
 }
 
-void test__std__perror__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::perror(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__scalbln__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::scalbln(arg1, arg2) > 10) || (std::scalbln(arg1, arg2) < 100)) {}
 }
 
-void test__std__perror__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::perror(x);
+void test__std__scalbln__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbln(x, arg2);
 }
 
-void test__pow__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = pow(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__scalbln__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbln(arg1, x);
 }
 
-void test__pow__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    pow(arg1, arg2);
+void test__scalblnf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = scalblnf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__pow__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((pow(arg1, arg2) > 10) || (pow(arg1, arg2) < 100)) {}
+void test__scalblnf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  scalblnf(arg1, arg2);
 }
 
-void test__pow__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = pow(p, arg2);
-    // cppcheck-suppress memleak
+void test__scalblnf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((scalblnf(arg1, arg2) > 10) || (scalblnf(arg1, arg2) < 100)) {}
 }
 
-void test__pow__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = pow(x, arg2);
+void test__scalblnf__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = scalblnf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__pow__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = pow(arg1, x);
+void test__scalblnf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalblnf(x, arg2);
 }
 
-void test__std__pow__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::pow(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__scalblnf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalblnf(arg1, x);
 }
 
-void test__std__pow__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::pow(arg1, arg2);
+void test__std__scalblnf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::scalblnf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__pow__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::pow(arg1, arg2) > 10) || (std::pow(arg1, arg2) < 100)) {}
+void test__std__scalblnf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::scalblnf(arg1, arg2);
 }
 
-void test__std__pow__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::pow(x, arg2);
+void test__std__scalblnf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::scalblnf(arg1, arg2) > 10) || (std::scalblnf(arg1, arg2) < 100)) {}
 }
 
-void test__std__pow__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::pow(arg1, x);
+void test__std__scalblnf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalblnf(x, arg2);
 }
 
-void test__powf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = powf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__scalblnf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalblnf(arg1, x);
 }
 
-void test__powf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    powf(arg1, arg2);
+void test__scalblnl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = scalblnl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__powf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((powf(arg1, arg2) > 10) || (powf(arg1, arg2) < 100)) {}
+void test__scalblnl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  scalblnl(arg1, arg2);
 }
 
-void test__powf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = powf(p, arg2);
-    // cppcheck-suppress memleak
+void test__scalblnl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((scalblnl(arg1, arg2) > 10) || (scalblnl(arg1, arg2) < 100)) {}
 }
 
-void test__powf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = powf(x, arg2);
+void test__scalblnl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = scalblnl(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__powf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = powf(arg1, x);
+void test__scalblnl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalblnl(x, arg2);
 }
 
-void test__std__powf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::powf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__scalblnl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalblnl(arg1, x);
 }
 
-void test__std__powf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::powf(arg1, arg2);
+void test__std__scalblnl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::scalblnl(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__powf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::powf(arg1, arg2) > 10) || (std::powf(arg1, arg2) < 100)) {}
+void test__std__scalblnl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::scalblnl(arg1, arg2);
 }
 
-void test__std__powf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::powf(x, arg2);
+void test__std__scalblnl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::scalblnl(arg1, arg2) > 10) || (std::scalblnl(arg1, arg2) < 100)) {}
 }
 
-void test__std__powf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::powf(arg1, x);
+void test__std__scalblnl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalblnl(x, arg2);
 }
 
-void test__powl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = powl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__scalblnl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalblnl(arg1, x);
 }
 
-void test__powl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    powl(arg1, arg2);
+void test__signbit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = signbit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__powl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((powl(arg1, arg2) > 10) || (powl(arg1, arg2) < 100)) {}
+void test__signbit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  signbit(arg1);
 }
 
-void test__powl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = powl(p, arg2);
-    // cppcheck-suppress memleak
+void test__signbit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((signbit(arg1) > 10) || (signbit(arg1) < 100)) {}
 }
 
-void test__powl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = powl(x, arg2);
+void test__signbit__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = signbit(p);
+  // cppcheck-suppress memleak
 }
 
-void test__powl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = powl(arg1, x);
+void test__signbit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = signbit(x);
 }
 
-void test__std__powl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::powl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__signbit__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::signbit(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__powl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::powl(arg1, arg2);
+void test__std__signbit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::signbit(arg1);
 }
 
-void test__std__powl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::powl(arg1, arg2) > 10) || (std::powl(arg1, arg2) < 100)) {}
+void test__std__signbit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::signbit(arg1) > 10) || (std::signbit(arg1) < 100)) {}
 }
 
-void test__std__powl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::powl(x, arg2);
+void test__std__signbit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::signbit(x);
 }
 
-void test__std__powl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::powl(arg1, x);
+void test__signal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; signal(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cpow__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cpow(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__signal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  signal(x, arg2);
 }
 
-void test__cpow__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cpow(arg1, arg2);
+void test__std__signal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::signal(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cpow__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cpow(arg1, arg2) > 10) || (cpow(arg1, arg2) < 100)) {}
+void test__std__signal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::signal(x, arg2);
 }
 
-void test__cpow__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cpow(p, arg2);
-    // cppcheck-suppress memleak
+void test__raise__noreturn() {
+  int x = 1;
+  if (cond) { x=100; raise(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cpow__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cpow(x, arg2);
+void test__raise__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  raise(x);
 }
 
-void test__cpow__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cpow(arg1, x);
+void test__std__raise__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::raise(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cpowf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cpowf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__raise__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::raise(x);
 }
 
-void test__cpowf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cpowf(arg1, arg2);
+void test__scanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; scanf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cpowf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cpowf(arg1, arg2) > 10) || (cpowf(arg1, arg2) < 100)) {}
+void test__scanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  scanf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__cpowf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cpowf(p, arg2);
-    // cppcheck-suppress memleak
+void test__scanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  scanf(NULL);
 }
 
-void test__cpowf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cpowf(x, arg2);
+void test__scanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  scanf(x);
 }
 
-void test__cpowf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cpowf(arg1, x);
+void test__std__scanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::scanf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cpowl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = cpowl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__scanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::scanf(NULL);
 }
 
-void test__cpowl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    cpowl(arg1, arg2);
+void test__std__scanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::scanf(x);
 }
 
-void test__cpowl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((cpowl(arg1, arg2) > 10) || (cpowl(arg1, arg2) < 100)) {}
+void test__vsscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vsscanf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__cpowl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = cpowl(p, arg2);
-    // cppcheck-suppress memleak
+void test__vsscanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  vsscanf(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__cpowl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cpowl(x, arg2);
+void test__vsscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vsscanf(NULL, arg2, arg3);
 }
 
-void test__cpowl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = cpowl(arg1, x);
+void test__vsscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vsscanf(x, arg2, arg3);
 }
 
-void test__remainder__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = remainder(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__vsscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  vsscanf(arg1, NULL, arg3);
 }
 
-void test__remainder__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    remainder(arg1, arg2);
+void test__vsscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vsscanf(arg1, x, arg3);
 }
 
-void test__remainder__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((remainder(arg1, arg2) > 10) || (remainder(arg1, arg2) < 100)) {}
+void test__std__vsscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vsscanf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__remainder__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = remainder(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__vsscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vsscanf(NULL, arg2, arg3);
 }
 
-void test__remainder__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = remainder(x, arg2);
+void test__std__vsscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vsscanf(x, arg2, arg3);
 }
 
-void test__remainder__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = remainder(arg1, x);
+void test__std__vsscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vsscanf(arg1, NULL, arg3);
 }
 
-void test__std__remainder__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::remainder(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vsscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vsscanf(arg1, x, arg3);
 }
 
-void test__std__remainder__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::remainder(arg1, arg2);
+void test__vswscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vswscanf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__remainder__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::remainder(arg1, arg2) > 10) || (std::remainder(arg1, arg2) < 100)) {}
+void test__vswscanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  vswscanf(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__remainder__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::remainder(x, arg2);
+void test__vswscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vswscanf(NULL, arg2, arg3);
 }
 
-void test__std__remainder__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::remainder(arg1, x);
+void test__vswscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vswscanf(x, arg2, arg3);
 }
 
-void test__remainderf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = remainderf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__vswscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  vswscanf(arg1, NULL, arg3);
 }
 
-void test__remainderf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    remainderf(arg1, arg2);
+void test__vswscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vswscanf(arg1, x, arg3);
 }
 
-void test__remainderf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((remainderf(arg1, arg2) > 10) || (remainderf(arg1, arg2) < 100)) {}
+void test__std__vswscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vswscanf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__remainderf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = remainderf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__vswscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vswscanf(NULL, arg2, arg3);
 }
 
-void test__remainderf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = remainderf(x, arg2);
+void test__std__vswscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vswscanf(x, arg2, arg3);
 }
 
-void test__remainderf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = remainderf(arg1, x);
+void test__std__vswscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vswscanf(arg1, NULL, arg3);
 }
 
-void test__std__remainderf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::remainderf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vswscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vswscanf(arg1, x, arg3);
 }
 
-void test__std__remainderf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::remainderf(arg1, arg2);
+void test__vscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vscanf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__remainderf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::remainderf(arg1, arg2) > 10) || (std::remainderf(arg1, arg2) < 100)) {}
+void test__vscanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  vscanf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__remainderf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::remainderf(x, arg2);
+void test__vscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vscanf(NULL, arg2);
 }
 
-void test__std__remainderf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::remainderf(arg1, x);
+void test__vscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vscanf(x, arg2);
 }
 
-void test__remainderl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = remainderl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vscanf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__remainderl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    remainderl(arg1, arg2);
+void test__std__vscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vscanf(NULL, arg2);
 }
 
-void test__remainderl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((remainderl(arg1, arg2) > 10) || (remainderl(arg1, arg2) < 100)) {}
+void test__std__vscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vscanf(x, arg2);
 }
 
-void test__remainderl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = remainderl(p, arg2);
-    // cppcheck-suppress memleak
+void test__vwscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vwscanf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__remainderl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = remainderl(x, arg2);
+void test__vwscanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  vwscanf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__remainderl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = remainderl(arg1, x);
+void test__vwscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vwscanf(NULL, arg2);
 }
 
-void test__std__remainderl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::remainderl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vwscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vwscanf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__remainderl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::remainderl(arg1, arg2);
+void test__std__vwscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vwscanf(NULL, arg2);
 }
 
-void test__std__remainderl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::remainderl(arg1, arg2) > 10) || (std::remainderl(arg1, arg2) < 100)) {}
+void test__setbuf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setbuf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__remainderl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::remainderl(x, arg2);
+void test__setbuf__leakignore() {
+  char *p = malloc(10); *p=0;
+  setbuf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__remainderl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::remainderl(arg1, x);
+void test__setbuf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  setbuf(NULL, arg2);
 }
 
-void test__remquo__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = remquo(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__setbuf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  setbuf(x, arg2);
 }
 
-void test__remquo__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    remquo(arg1, arg2, arg3);
+void test__setbuf__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  setbuf(arg1, !x);
 }
 
-void test__remquo__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((remquo(arg1, arg2, arg3) > 10) || (remquo(arg1, arg2, arg3) < 100)) {}
+void test__std__setbuf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::setbuf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__remquo__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = remquo(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__setbuf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::setbuf(NULL, arg2);
 }
 
-void test__remquo__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = remquo(x, arg2, arg3);
+void test__std__setbuf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::setbuf(x, arg2);
 }
 
-void test__remquo__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = remquo(arg1, x, arg3);
+void test__std__setbuf__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::setbuf(arg1, !x);
 }
 
-void test__remquo__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = remquo(arg1, arg2, NULL);
+void test__setvbuf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setvbuf(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__remquo__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::remquo(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__setvbuf__leakignore() {
+  char *p = malloc(10); *p=0;
+  setvbuf(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__std__remquo__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::remquo(arg1, arg2, arg3);
+void test__setvbuf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  setvbuf(NULL, arg2, arg3, arg4);
 }
 
-void test__std__remquo__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::remquo(arg1, arg2, arg3) > 10) || (std::remquo(arg1, arg2, arg3) < 100)) {}
+void test__setvbuf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  setvbuf(x, arg2, arg3, arg4);
 }
 
-void test__std__remquo__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::remquo(x, arg2, arg3);
+void test__setvbuf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setvbuf(arg1, x, arg3, arg4);
 }
 
-void test__std__remquo__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::remquo(arg1, x, arg3);
+void test__setvbuf__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setvbuf(arg1, arg2, x, arg4);
 }
 
-void test__std__remquo__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::remquo(arg1, arg2, NULL);
+void test__setvbuf__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setvbuf(arg1, arg2, arg3, x);
 }
 
-void test__remquof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = remquof(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__setvbuf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::setvbuf(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__remquof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    remquof(arg1, arg2, arg3);
+void test__std__setvbuf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::setvbuf(NULL, arg2, arg3, arg4);
 }
 
-void test__remquof__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((remquof(arg1, arg2, arg3) > 10) || (remquof(arg1, arg2, arg3) < 100)) {}
+void test__std__setvbuf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::setvbuf(x, arg2, arg3, arg4);
 }
 
-void test__remquof__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = remquof(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__setvbuf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setvbuf(arg1, x, arg3, arg4);
 }
 
-void test__remquof__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = remquof(x, arg2, arg3);
+void test__std__setvbuf__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setvbuf(arg1, arg2, x, arg4);
 }
 
-void test__remquof__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = remquof(arg1, x, arg3);
+void test__std__setvbuf__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setvbuf(arg1, arg2, arg3, x);
 }
 
-void test__remquof__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = remquof(arg1, arg2, NULL);
+void test__setjmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setjmp(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__remquof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::remquof(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__setjmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  setjmp(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__remquof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::remquof(arg1, arg2, arg3);
+void test__strcat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strcat(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__remquof__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::remquof(arg1, arg2, arg3) > 10) || (std::remquof(arg1, arg2, arg3) < 100)) {}
+void test__strcat__leakignore() {
+  char *p = malloc(10); *p=0;
+  strcat(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__remquof__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::remquof(x, arg2, arg3);
+void test__strcat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strcat(NULL, arg2);
 }
 
-void test__std__remquof__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::remquof(arg1, x, arg3);
+void test__strcat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strcat(x, arg2);
 }
 
-void test__std__remquof__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::remquof(arg1, arg2, NULL);
+void test__strcat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strcat(arg1, NULL);
 }
 
-void test__remquol__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = remquol(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strcat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strcat(arg1, x);
 }
 
-void test__remquol__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    remquol(arg1, arg2, arg3);
+void test__std__strcat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strcat(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__remquol__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((remquol(arg1, arg2, arg3) > 10) || (remquol(arg1, arg2, arg3) < 100)) {}
+void test__std__strcat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strcat(NULL, arg2);
 }
 
-void test__remquol__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = remquol(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__strcat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strcat(x, arg2);
 }
 
-void test__remquol__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = remquol(x, arg2, arg3);
+void test__std__strcat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strcat(arg1, NULL);
 }
 
-void test__remquol__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = remquol(arg1, x, arg3);
+void test__std__strcat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strcat(arg1, x);
 }
 
-void test__remquol__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = remquol(arg1, arg2, NULL);
+void test__wcscat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcscat(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__remquol__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::remquol(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcscat__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcscat(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__remquol__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::remquol(arg1, arg2, arg3);
+void test__wcscat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcscat(NULL, arg2);
 }
 
-void test__std__remquol__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::remquol(arg1, arg2, arg3) > 10) || (std::remquol(arg1, arg2, arg3) < 100)) {}
+void test__wcscat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcscat(arg1, NULL);
 }
 
-void test__std__remquol__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::remquol(x, arg2, arg3);
+void test__wcscat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcscat(arg1, x);
 }
 
-void test__std__remquol__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::remquol(arg1, x, arg3);
+void test__std__wcscat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wcscat(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__remquol__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::remquol(arg1, arg2, NULL);
+void test__std__wcscat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcscat(NULL, arg2);
 }
 
-void test__printf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        printf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcscat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcscat(arg1, NULL);
 }
 
-void test__printf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    printf(p);
-    // cppcheck-suppress memleak
+void test__std__wcscat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcscat(arg1, x);
 }
 
-void test__printf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    printf(x);
+void test__wcrtomb__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcrtomb(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__printf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::printf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcrtomb__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcrtomb(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
-
-void test__std__printf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::printf(x);
-}
-
-void test__vprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vprintf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__wcrtomb__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcrtomb(arg1, x, arg3);
 }
 
-void test__vprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vprintf(p, arg2);
-    // cppcheck-suppress memleak
-}
+void test__std__wcrtomb__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wcrtomb(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__vprintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    vprintf(x, arg2);
+void test__std__wcrtomb__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcrtomb(arg1, x, arg3);
 }
 
-void test__std__vprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vprintf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vprintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::vprintf(x, arg2);
-}
-
-void test__vwprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vwprintf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strchr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strchr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vwprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vwprintf(p, arg2);
-    // cppcheck-suppress memleak
+void test__strchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strchr(arg1, arg2);
 }
 
-void test__vwprintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    vwprintf(x, arg2);
+void test__strchr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = strchr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__vwprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vwprintf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strchr(NULL, arg2);
 }
 
-void test__std__vwprintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::vwprintf(x, arg2);
+void test__strchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strchr(x, arg2);
 }
 
-void test__bsearch__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = bsearch(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strchr(arg1, x);
 }
 
-void test__bsearch__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    bsearch(arg1, arg2, arg3, arg4, arg5);
+void test__std__strchr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::strchr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__bsearch__pure(int arg1,int arg2,int arg3,int arg4,int arg5)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((bsearch(arg1, arg2, arg3, arg4, arg5) > 10) || (bsearch(arg1, arg2, arg3, arg4, arg5) < 100)) {}
+void test__std__strchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strchr(arg1, arg2);
 }
 
-void test__bsearch__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = bsearch(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test__std__strchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strchr(NULL, arg2);
 }
 
-void test__bsearch__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = bsearch(NULL, arg2, arg3, arg4, arg5);
+void test__std__strchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strchr(x, arg2);
 }
 
-void test__bsearch__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = bsearch(x, arg2, arg3, arg4, arg5);
+void test__std__strchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::strchr(arg1, x);
 }
 
-void test__bsearch__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = bsearch(arg1, NULL, arg3, arg4, arg5);
+void test__wcschr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcschr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__bsearch__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = bsearch(arg1, x, arg3, arg4, arg5);
+void test__wcschr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcschr(arg1, arg2);
 }
 
-void test__bsearch__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = bsearch(arg1, arg2, x, arg4, arg5);
+void test__wcschr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcschr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__bsearch__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = bsearch(arg1, arg2, arg3, x, arg5);
+void test__wcschr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcschr(NULL, arg2);
 }
 
-void test__bsearch__arg5__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = bsearch(arg1, arg2, arg3, arg4, NULL);
+void test__wcschr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcschr(x, arg2);
 }
 
-void test__bsearch__arg5__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = bsearch(arg1, arg2, arg3, arg4, x);
+void test__wcschr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcschr(arg1, x);
 }
 
-void test__std__bsearch__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::bsearch(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcschr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wcschr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__bsearch__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::bsearch(arg1, arg2, arg3, arg4, arg5);
+void test__std__wcschr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcschr(arg1, arg2);
 }
 
-void test__std__bsearch__pure(int arg1,int arg2,int arg3,int arg4,int arg5)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::bsearch(arg1, arg2, arg3, arg4, arg5) > 10) || (std::bsearch(arg1, arg2, arg3, arg4, arg5) < 100)) {}
+void test__std__wcschr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcschr(NULL, arg2);
 }
 
-void test__std__bsearch__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::bsearch(NULL, arg2, arg3, arg4, arg5);
+void test__std__wcschr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcschr(x, arg2);
 }
 
-void test__std__bsearch__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::bsearch(x, arg2, arg3, arg4, arg5);
+void test__std__wcschr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wcschr(arg1, x);
 }
 
-void test__std__bsearch__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::bsearch(arg1, NULL, arg3, arg4, arg5);
+void test__strcmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strcmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__bsearch__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::bsearch(arg1, x, arg3, arg4, arg5);
+void test__strcmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strcmp(arg1, arg2);
 }
 
-void test__std__bsearch__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::bsearch(arg1, arg2, x, arg4, arg5);
+void test__strcmp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strcmp(arg1, arg2) > 10) || (strcmp(arg1, arg2) < 100)) {}
 }
 
-void test__std__bsearch__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::bsearch(arg1, arg2, arg3, x, arg5);
+void test__strcmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = strcmp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__bsearch__arg5__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::bsearch(arg1, arg2, arg3, arg4, NULL);
+void test__strcmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strcmp(NULL, arg2);
 }
 
-void test__std__bsearch__arg5__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::bsearch(arg1, arg2, arg3, arg4, x);
+void test__strcmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strcmp(x, arg2);
 }
 
-void test__qsort__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        qsort(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strcmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strcmp(arg1, NULL);
 }
 
-void test__qsort__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    qsort(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__strcmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strcmp(arg1, x);
 }
 
-void test__qsort__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    qsort(NULL, arg2, arg3, arg4);
+void test__std__strcmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::strcmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__qsort__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    qsort(x, arg2, arg3, arg4);
+void test__std__strcmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strcmp(arg1, arg2);
 }
 
-void test__qsort__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    qsort(arg1, x, arg3, arg4);
+void test__std__strcmp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::strcmp(arg1, arg2) > 10) || (std::strcmp(arg1, arg2) < 100)) {}
 }
 
-void test__qsort__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    qsort(arg1, arg2, x, arg4);
+void test__std__strcmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strcmp(NULL, arg2);
 }
 
-void test__qsort__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    qsort(arg1, arg2, arg3, NULL);
+void test__std__strcmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strcmp(x, arg2);
 }
 
-void test__qsort__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    qsort(arg1, arg2, arg3, x);
+void test__std__strcmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strcmp(arg1, NULL);
 }
 
-void test__std__qsort__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::qsort(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strcmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strcmp(arg1, x);
 }
 
-void test__std__qsort__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::qsort(NULL, arg2, arg3, arg4);
+void test__wcscmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcscmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__qsort__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::qsort(x, arg2, arg3, arg4);
+void test__wcscmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcscmp(arg1, arg2);
 }
 
-void test__std__qsort__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::qsort(arg1, x, arg3, arg4);
+void test__wcscmp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wcscmp(arg1, arg2) > 10) || (wcscmp(arg1, arg2) < 100)) {}
 }
 
-void test__std__qsort__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::qsort(arg1, arg2, x, arg4);
+void test__wcscmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcscmp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__qsort__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::qsort(arg1, arg2, arg3, NULL);
+void test__wcscmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcscmp(NULL, arg2);
 }
 
-void test__std__qsort__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::qsort(arg1, arg2, arg3, x);
+void test__wcscmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcscmp(x, arg2);
 }
 
-void test__putc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        putc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcscmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcscmp(arg1, NULL);
 }
 
-void test__putc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    putc(p, arg2);
-    // cppcheck-suppress memleak
+void test__wcscmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcscmp(arg1, x);
 }
 
-void test__putc__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    putc(!x, arg2);
+void test__std__wcscmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wcscmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__putc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    putc(x, arg2);
+void test__std__wcscmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcscmp(arg1, arg2);
 }
 
-void test__putc__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    putc(arg1, NULL);
+void test__std__wcscmp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wcscmp(arg1, arg2) > 10) || (std::wcscmp(arg1, arg2) < 100)) {}
 }
 
-void test__putc__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    putc(arg1, x);
+void test__std__wcscmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcscmp(NULL, arg2);
 }
 
-void test__std__putc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::putc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcscmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcscmp(x, arg2);
 }
 
-void test__std__putc__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::putc(!x, arg2);
+void test__std__wcscmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcscmp(arg1, NULL);
 }
 
-void test__std__putc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::putc(x, arg2);
+void test__std__wcscmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcscmp(arg1, x);
 }
 
-void test__std__putc__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::putc(arg1, NULL);
+void test__strcpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strcpy(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__putc__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::putc(arg1, x);
+void test__strcpy__leakignore() {
+  char *p = malloc(10); *p=0;
+  strcpy(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__putwc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        putwc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strcpy(NULL, arg2);
 }
 
-void test__putwc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    putwc(p, arg2);
-    // cppcheck-suppress memleak
+void test__strcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strcpy(arg1, NULL);
 }
 
-void test__putwc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    putwc(x, arg2);
+void test__strcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strcpy(arg1, x);
 }
 
-void test__putwc__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    putwc(arg1, NULL);
+void test__std__strcpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strcpy(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__putwc__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    putwc(arg1, x);
+void test__std__strcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strcpy(NULL, arg2);
 }
 
-void test__std__putwc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::putwc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strcpy(arg1, NULL);
 }
 
-void test__std__putwc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::putwc(x, arg2);
+void test__std__strcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strcpy(arg1, x);
 }
 
-void test__std__putwc__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::putwc(arg1, NULL);
+void test__wcscpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcscpy(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__putwc__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::putwc(arg1, x);
+void test__wcscpy__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcscpy(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__putchar__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        putchar(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcscpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcscpy(NULL, arg2);
 }
 
-void test__putchar__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    putchar(p);
-    // cppcheck-suppress memleak
-}
+void test__wcscpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcscpy(arg1, NULL);
+}
 
-void test__putchar__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    putchar(!x);
-}
+void test__wcscpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcscpy(arg1, x);
+}
 
-void test__putchar__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    putchar(x);
+void test__std__wcscpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wcscpy(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__putchar__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::putchar(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcscpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcscpy(NULL, arg2);
 }
 
-void test__std__putchar__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::putchar(!x);
+void test__std__wcscpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcscpy(arg1, NULL);
 }
 
-void test__std__putchar__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::putchar(x);
+void test__std__wcscpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcscpy(arg1, x);
 }
 
-void test__putwchar__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        putwchar(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strftime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strftime(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__putwchar__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    putwchar(p);
-    // cppcheck-suppress memleak
+void test__strftime__leakignore() {
+  char *p = malloc(10); *p=0;
+  strftime(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__putwchar__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    putwchar(x);
+void test__strftime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strftime(NULL, arg2, arg3, arg4);
 }
 
-void test__std__putwchar__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::putwchar(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strftime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strftime(arg1, x, arg3, arg4);
 }
 
-void test__std__putwchar__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::putwchar(x);
+void test__strftime__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  strftime(arg1, arg2, NULL, arg4);
 }
-
-void test__puts__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        puts(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__strftime__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strftime(arg1, arg2, x, arg4);
 }
 
-void test__puts__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    puts(p);
-    // cppcheck-suppress memleak
+void test__strftime__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  strftime(arg1, arg2, arg3, NULL);
 }
 
-void test__puts__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    puts(!x);
+void test__strftime__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strftime(arg1, arg2, arg3, x);
 }
-
-void test__puts__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    puts(NULL);
+
+void test__std__strftime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strftime(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__puts__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    puts(x);
+void test__std__strftime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strftime(NULL, arg2, arg3, arg4);
 }
 
-void test__std__puts__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::puts(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strftime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strftime(arg1, x, arg3, arg4);
 }
 
-void test__std__puts__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::puts(!x);
+void test__std__strftime__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strftime(arg1, arg2, NULL, arg4);
 }
 
-void test__std__puts__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::puts(NULL);
-}
+void test__std__strftime__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strftime(arg1, arg2, x, arg4);
+}
 
-void test__std__puts__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::puts(x);
+void test__std__strftime__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strftime(arg1, arg2, arg3, NULL);
 }
 
-void test__realloc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        realloc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strftime__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strftime(arg1, arg2, arg3, x);
 }
 
-void test__realloc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    realloc(x, arg2);
+void test__strfxtime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strfxtime(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__realloc__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    realloc(arg1, x);
+void test__strfxtime__leakignore() {
+  char *p = malloc(10); *p=0;
+  strfxtime(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__std__realloc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::realloc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strfxtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strfxtime(NULL, arg2, arg3, arg4);
 }
 
-void test__std__realloc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::realloc(x, arg2);
+void test__strfxtime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strfxtime(arg1, x, arg3, arg4);
 }
 
-void test__std__realloc__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::realloc(arg1, x);
+void test__strfxtime__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  strfxtime(arg1, arg2, NULL, arg4);
 }
 
-void test__remove__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        remove(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strfxtime__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strfxtime(arg1, arg2, x, arg4);
 }
 
-void test__remove__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    remove(p);
-    // cppcheck-suppress memleak
+void test__strfxtime__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  strfxtime(arg1, arg2, arg3, NULL);
 }
 
-void test__remove__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    remove(NULL);
+void test__strfxtime__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strfxtime(arg1, arg2, arg3, x);
 }
 
-void test__remove__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    remove(x);
+void test__strlen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strlen(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__remove__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::remove(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strlen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strlen(arg1);
 }
 
-void test__std__remove__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::remove(NULL);
+void test__strlen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strlen(arg1) > 10) || (strlen(arg1) < 100)) {}
 }
 
-void test__std__remove__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::remove(x);
+void test__strlen__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = strlen(p);
+  // cppcheck-suppress memleak
 }
 
-void test__rename__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        rename(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strlen(NULL);
 }
 
-void test__rename__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    rename(p, arg2);
-    // cppcheck-suppress memleak
+void test__strlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strlen(x);
 }
 
-void test__rename__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    rename(NULL, arg2);
+void test__std__strlen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::strlen(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__rename__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    rename(x, arg2);
+void test__std__strlen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strlen(arg1);
 }
 
-void test__rename__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    rename(arg1, NULL);
+void test__std__strlen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::strlen(arg1) > 10) || (std::strlen(arg1) < 100)) {}
 }
 
-void test__rename__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    rename(arg1, x);
+void test__std__strlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strlen(NULL);
 }
 
-void test__std__rename__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::rename(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strlen(x);
 }
 
-void test__std__rename__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::rename(NULL, arg2);
+void test__wcslen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcslen(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__rename__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::rename(x, arg2);
+void test__wcslen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcslen(arg1);
 }
 
-void test__std__rename__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::rename(arg1, NULL);
+void test__wcslen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wcslen(arg1) > 10) || (wcslen(arg1) < 100)) {}
 }
 
-void test__std__rename__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::rename(arg1, x);
+void test__wcslen__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcslen(p);
+  // cppcheck-suppress memleak
 }
 
-void test__rewind__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        rewind(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcslen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcslen(NULL);
 }
 
-void test__rewind__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    rewind(p);
-    // cppcheck-suppress memleak
+void test__wcslen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcslen(x);
 }
 
-void test__rewind__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    rewind(NULL);
+void test__std__wcslen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wcslen(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__rewind__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    rewind(x);
+void test__std__wcslen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcslen(arg1);
 }
 
-void test__std__rewind__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::rewind(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcslen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wcslen(arg1) > 10) || (std::wcslen(arg1) < 100)) {}
 }
 
-void test__std__rewind__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::rewind(NULL);
+void test__std__wcslen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcslen(NULL);
 }
 
-void test__std__rewind__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::rewind(x);
+void test__std__wcslen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcslen(x);
 }
 
-void test__round__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = round(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strncpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strncpy(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__round__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    round(arg1);
+void test__strncpy__leakignore() {
+  char *p = malloc(10); *p=0;
+  strncpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__round__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((round(arg1) > 10) || (round(arg1) < 100)) {}
+void test__strncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strncpy(NULL, arg2, arg3);
 }
 
-void test__round__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = round(p);
-    // cppcheck-suppress memleak
+void test__strncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strncpy(arg1, NULL, arg3);
 }
 
-void test__round__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = round(x);
+void test__strncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strncpy(arg1, x, arg3);
 }
 
-void test__std__round__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::round(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  strncpy(arg1, arg2, !x);
 }
 
-void test__std__round__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::round(arg1);
+void test__strncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strncpy(arg1, arg2, x);
 }
 
-void test__std__round__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::round(arg1) > 10) || (std::round(arg1) < 100)) {}
+void test__std__strncpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strncpy(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__round__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::round(x);
+void test__std__strncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strncpy(NULL, arg2, arg3);
 }
 
-void test__roundf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = roundf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strncpy(arg1, NULL, arg3);
 }
 
-void test__roundf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    roundf(arg1);
+void test__std__strncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strncpy(arg1, x, arg3);
 }
 
-void test__roundf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((roundf(arg1) > 10) || (roundf(arg1) < 100)) {}
+void test__std__strncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::strncpy(arg1, arg2, !x);
 }
 
-void test__roundf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = roundf(p);
-    // cppcheck-suppress memleak
+void test__std__strncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strncpy(arg1, arg2, x);
 }
 
-void test__roundf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = roundf(x);
+void test__strpbrk__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strpbrk(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__roundf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::roundf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strpbrk__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strpbrk(arg1, arg2);
 }
 
-void test__std__roundf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::roundf(arg1);
+void test__strpbrk__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = strpbrk(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__roundf__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::roundf(arg1) > 10) || (std::roundf(arg1) < 100)) {}
+void test__strpbrk__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strpbrk(NULL, arg2);
 }
 
-void test__std__roundf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::roundf(x);
+void test__strpbrk__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strpbrk(x, arg2);
 }
 
-void test__roundl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = roundl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strpbrk__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strpbrk(arg1, NULL);
 }
 
-void test__roundl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    roundl(arg1);
+void test__strpbrk__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strpbrk(arg1, x);
 }
 
-void test__roundl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((roundl(arg1) > 10) || (roundl(arg1) < 100)) {}
+void test__std__strpbrk__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::strpbrk(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__roundl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = roundl(p);
-    // cppcheck-suppress memleak
+void test__std__strpbrk__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strpbrk(arg1, arg2);
 }
 
-void test__roundl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = roundl(x);
+void test__std__strpbrk__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strpbrk(NULL, arg2);
 }
 
-void test__std__roundl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::roundl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strpbrk__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strpbrk(x, arg2);
 }
 
-void test__std__roundl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::roundl(arg1);
+void test__std__strpbrk__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strpbrk(arg1, NULL);
 }
 
-void test__std__roundl__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::roundl(arg1) > 10) || (std::roundl(arg1) < 100)) {}
+void test__std__strpbrk__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strpbrk(arg1, x);
 }
 
-void test__std__roundl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::roundl(x);
+void test__strncat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strncat(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__scalbn__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = scalbn(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strncat__leakignore() {
+  char *p = malloc(10); *p=0;
+  strncat(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__scalbn__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    scalbn(arg1, arg2);
+void test__strncat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strncat(NULL, arg2, arg3);
 }
 
-void test__scalbn__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((scalbn(arg1, arg2) > 10) || (scalbn(arg1, arg2) < 100)) {}
+void test__strncat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strncat(x, arg2, arg3);
 }
 
-void test__scalbn__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = scalbn(p, arg2);
-    // cppcheck-suppress memleak
+void test__strncat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strncat(arg1, NULL, arg3);
 }
 
-void test__scalbn__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = scalbn(x, arg2);
+void test__strncat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strncat(arg1, x, arg3);
 }
 
-void test__scalbn__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = scalbn(arg1, x);
+void test__strncat__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  strncat(arg1, arg2, !x);
 }
 
-void test__std__scalbn__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::scalbn(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strncat__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strncat(arg1, arg2, x);
 }
 
-void test__std__scalbn__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::scalbn(arg1, arg2);
+void test__std__strncat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strncat(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__scalbn__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::scalbn(arg1, arg2) > 10) || (std::scalbn(arg1, arg2) < 100)) {}
+void test__std__strncat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strncat(NULL, arg2, arg3);
 }
 
-void test__std__scalbn__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::scalbn(x, arg2);
+void test__std__strncat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strncat(x, arg2, arg3);
 }
 
-void test__std__scalbn__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::scalbn(arg1, x);
+void test__std__strncat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strncat(arg1, NULL, arg3);
 }
 
-void test__scalbnf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = scalbnf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strncat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strncat(arg1, x, arg3);
 }
 
-void test__scalbnf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    scalbnf(arg1, arg2);
+void test__std__strncat__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::strncat(arg1, arg2, !x);
 }
 
-void test__scalbnf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((scalbnf(arg1, arg2) > 10) || (scalbnf(arg1, arg2) < 100)) {}
+void test__std__strncat__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strncat(arg1, arg2, x);
 }
 
-void test__scalbnf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = scalbnf(p, arg2);
-    // cppcheck-suppress memleak
+void test__wcsncat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcsncat(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__scalbnf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = scalbnf(x, arg2);
+void test__wcsncat__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcsncat(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__scalbnf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = scalbnf(arg1, x);
+void test__wcsncat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsncat(NULL, arg2, arg3);
 }
 
-void test__std__scalbnf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::scalbnf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsncat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsncat(x, arg2, arg3);
 }
 
-void test__std__scalbnf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::scalbnf(arg1, arg2);
+void test__wcsncat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsncat(arg1, NULL, arg3);
 }
 
-void test__std__scalbnf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::scalbnf(arg1, arg2) > 10) || (std::scalbnf(arg1, arg2) < 100)) {}
+void test__wcsncat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsncat(arg1, x, arg3);
 }
 
-void test__std__scalbnf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::scalbnf(x, arg2);
+void test__wcsncat__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wcsncat(arg1, arg2, !x);
 }
 
-void test__std__scalbnf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::scalbnf(arg1, x);
+void test__wcsncat__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcsncat(arg1, arg2, x);
 }
 
-void test__scalbnl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = scalbnl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcsncat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wcsncat(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__scalbnl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    scalbnl(arg1, arg2);
+void test__std__wcsncat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsncat(NULL, arg2, arg3);
 }
 
-void test__scalbnl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((scalbnl(arg1, arg2) > 10) || (scalbnl(arg1, arg2) < 100)) {}
+void test__std__wcsncat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcsncat(x, arg2, arg3);
 }
 
-void test__scalbnl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = scalbnl(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__wcsncat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsncat(arg1, NULL, arg3);
 }
 
-void test__scalbnl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = scalbnl(x, arg2);
+void test__std__wcsncat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcsncat(arg1, x, arg3);
 }
 
-void test__scalbnl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = scalbnl(arg1, x);
+void test__std__wcsncat__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::wcsncat(arg1, arg2, !x);
 }
 
-void test__std__scalbnl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::scalbnl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcsncat__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcsncat(arg1, arg2, x);
 }
 
-void test__std__scalbnl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::scalbnl(arg1, arg2);
+void test__strncmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strncmp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__scalbnl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::scalbnl(arg1, arg2) > 10) || (std::scalbnl(arg1, arg2) < 100)) {}
+void test__strncmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strncmp(arg1, arg2, arg3);
 }
 
-void test__std__scalbnl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::scalbnl(x, arg2);
+void test__strncmp__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strncmp(arg1, arg2, arg3) > 10) || (strncmp(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__scalbnl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::scalbnl(arg1, x);
+void test__strncmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = strncmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__scalbln__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = scalbln(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strncmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strncmp(NULL, arg2, arg3);
 }
 
-void test__scalbln__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    scalbln(arg1, arg2);
+void test__strncmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strncmp(x, arg2, arg3);
 }
 
-void test__scalbln__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((scalbln(arg1, arg2) > 10) || (scalbln(arg1, arg2) < 100)) {}
+void test__strncmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strncmp(arg1, NULL, arg3);
 }
 
-void test__scalbln__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = scalbln(p, arg2);
-    // cppcheck-suppress memleak
+void test__strncmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strncmp(arg1, x, arg3);
 }
 
-void test__scalbln__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = scalbln(x, arg2);
+void test__strncmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = strncmp(arg1, arg2, !x);
 }
 
-void test__scalbln__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = scalbln(arg1, x);
+void test__strncmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strncmp(arg1, arg2, x);
 }
 
-void test__std__scalbln__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::scalbln(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strncmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::strncmp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__scalbln__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::scalbln(arg1, arg2);
+void test__std__strncmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strncmp(arg1, arg2, arg3);
 }
 
-void test__std__scalbln__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::scalbln(arg1, arg2) > 10) || (std::scalbln(arg1, arg2) < 100)) {}
+void test__std__strncmp__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::strncmp(arg1, arg2, arg3) > 10) || (std::strncmp(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__scalbln__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::scalbln(x, arg2);
+void test__std__strncmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strncmp(NULL, arg2, arg3);
 }
 
-void test__std__scalbln__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::scalbln(arg1, x);
+void test__std__strncmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strncmp(x, arg2, arg3);
 }
 
-void test__scalblnf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = scalblnf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strncmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strncmp(arg1, NULL, arg3);
 }
 
-void test__scalblnf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    scalblnf(arg1, arg2);
+void test__std__strncmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strncmp(arg1, x, arg3);
 }
 
-void test__scalblnf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((scalblnf(arg1, arg2) > 10) || (scalblnf(arg1, arg2) < 100)) {}
+void test__std__strncmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::strncmp(arg1, arg2, !x);
 }
 
-void test__scalblnf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = scalblnf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__strncmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::strncmp(arg1, arg2, x);
 }
 
-void test__scalblnf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = scalblnf(x, arg2);
+void test__wcsncmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcsncmp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__scalblnf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = scalblnf(arg1, x);
+void test__wcsncmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcsncmp(arg1, arg2, arg3);
 }
 
-void test__std__scalblnf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::scalblnf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsncmp__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wcsncmp(arg1, arg2, arg3) > 10) || (wcsncmp(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__scalblnf__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::scalblnf(arg1, arg2);
+void test__wcsncmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcsncmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__scalblnf__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::scalblnf(arg1, arg2) > 10) || (std::scalblnf(arg1, arg2) < 100)) {}
+void test__wcsncmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsncmp(NULL, arg2, arg3);
 }
 
-void test__std__scalblnf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::scalblnf(x, arg2);
+void test__wcsncmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsncmp(x, arg2, arg3);
 }
 
-void test__std__scalblnf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::scalblnf(arg1, x);
+void test__wcsncmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsncmp(arg1, NULL, arg3);
 }
 
-void test__scalblnl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = scalblnl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsncmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsncmp(arg1, x, arg3);
 }
 
-void test__scalblnl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    scalblnl(arg1, arg2);
+void test__wcsncmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = wcsncmp(arg1, arg2, !x);
 }
 
-void test__scalblnl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((scalblnl(arg1, arg2) > 10) || (scalblnl(arg1, arg2) < 100)) {}
+void test__wcsncmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcsncmp(arg1, arg2, x);
 }
 
-void test__scalblnl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = scalblnl(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__wcsncmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wcsncmp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__scalblnl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = scalblnl(x, arg2);
+void test__std__wcsncmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcsncmp(arg1, arg2, arg3);
 }
 
-void test__scalblnl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = scalblnl(arg1, x);
+void test__std__wcsncmp__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wcsncmp(arg1, arg2, arg3) > 10) || (std::wcsncmp(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__scalblnl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::scalblnl(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcsncmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcsncmp(NULL, arg2, arg3);
 }
 
-void test__std__scalblnl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::scalblnl(arg1, arg2);
+void test__std__wcsncmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcsncmp(x, arg2, arg3);
 }
 
-void test__std__scalblnl__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::scalblnl(arg1, arg2) > 10) || (std::scalblnl(arg1, arg2) < 100)) {}
+void test__std__wcsncmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcsncmp(arg1, NULL, arg3);
 }
 
-void test__std__scalblnl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::scalblnl(x, arg2);
+void test__std__wcsncmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcsncmp(arg1, x, arg3);
 }
 
-void test__std__scalblnl__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::scalblnl(arg1, x);
+void test__std__wcsncmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::wcsncmp(arg1, arg2, !x);
 }
 
-void test__signbit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = signbit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcsncmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wcsncmp(arg1, arg2, x);
 }
 
-void test__signbit__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    signbit(arg1);
+void test__strstr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strstr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__signbit__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((signbit(arg1) > 10) || (signbit(arg1) < 100)) {}
+void test__strstr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strstr(arg1, arg2);
 }
 
-void test__signbit__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = signbit(p);
-    // cppcheck-suppress memleak
+void test__strstr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = strstr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__signbit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = signbit(x);
+void test__strstr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strstr(NULL, arg2);
 }
 
-void test__std__signbit__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::signbit(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strstr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strstr(x, arg2);
 }
-
-void test__std__signbit__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::signbit(arg1);
+
+void test__strstr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strstr(arg1, NULL);
 }
 
-void test__std__signbit__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::signbit(arg1) > 10) || (std::signbit(arg1) < 100)) {}
+void test__strstr__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strstr(arg1, x);
 }
 
-void test__std__signbit__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::signbit(x);
+void test__std__strstr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::strstr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__signal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        signal(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strstr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strstr(arg1, arg2);
 }
 
-void test__signal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    signal(x, arg2);
+void test__std__strstr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strstr(NULL, arg2);
 }
-
-void test__std__signal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::signal(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__std__strstr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strstr(x, arg2);
 }
 
-void test__std__signal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::signal(x, arg2);
-}
-
-void test__raise__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        raise(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__std__strstr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strstr(arg1, NULL);
+}
 
-void test__raise__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    raise(x);
+void test__std__strstr__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strstr(arg1, x);
 }
 
-void test__std__raise__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::raise(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__raise__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::raise(x);
-}
-
-void test__scanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        scanf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__scanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    scanf(p);
-    // cppcheck-suppress memleak
+void test__wcsstr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcsstr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__scanf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    scanf(NULL);
-}
+void test__wcsstr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcsstr(arg1, arg2);
+}
 
-void test__scanf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    scanf(x);
+void test__wcsstr__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wcsstr(arg1, arg2) > 10) || (wcsstr(arg1, arg2) < 100)) {}
 }
 
-void test__std__scanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::scanf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsstr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcsstr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__scanf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::scanf(NULL);
-}
+void test__wcsstr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsstr(NULL, arg2);
+}
 
-void test__std__scanf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::scanf(x);
+void test__wcsstr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsstr(x, arg2);
 }
 
-void test__vsscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vsscanf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsstr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsstr(arg1, NULL);
 }
 
-void test__vsscanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vsscanf(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__wcsstr__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsstr(arg1, x);
 }
 
-void test__vsscanf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vsscanf(NULL, arg2, arg3);
+void test__std__wcsstr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wcsstr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vsscanf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    vsscanf(x, arg2, arg3);
+void test__std__wcsstr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcsstr(arg1, arg2);
 }
 
-void test__vsscanf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vsscanf(arg1, NULL, arg3);
+void test__std__wcsstr__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wcsstr(arg1, arg2) > 10) || (std::wcsstr(arg1, arg2) < 100)) {}
 }
 
-void test__vsscanf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    vsscanf(arg1, x, arg3);
+void test__std__wcsstr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcsstr(NULL, arg2);
 }
 
-void test__std__vsscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vsscanf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcsstr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcsstr(x, arg2);
 }
 
-void test__std__vsscanf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::vsscanf(NULL, arg2, arg3);
+void test__std__wcsstr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcsstr(arg1, NULL);
 }
 
-void test__std__vsscanf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::vsscanf(x, arg2, arg3);
+void test__std__wcsstr__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcsstr(arg1, x);
 }
 
-void test__std__vsscanf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::vsscanf(arg1, NULL, arg3);
+void test__strspn__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strspn(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vsscanf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::vsscanf(arg1, x, arg3);
+void test__strspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strspn(arg1, arg2);
 }
 
-void test__vswscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vswscanf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strspn__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = strspn(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__vswscanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vswscanf(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__strspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strspn(NULL, arg2);
 }
 
-void test__vswscanf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vswscanf(NULL, arg2, arg3);
+void test__strspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strspn(x, arg2);
 }
 
-void test__vswscanf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    vswscanf(x, arg2, arg3);
+void test__strspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strspn(arg1, NULL);
 }
 
-void test__vswscanf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vswscanf(arg1, NULL, arg3);
+void test__strspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strspn(arg1, x);
 }
 
-void test__vswscanf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    vswscanf(arg1, x, arg3);
+void test__std__strspn__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::strspn(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vswscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vswscanf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strspn(arg1, arg2);
 }
 
-void test__std__vswscanf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::vswscanf(NULL, arg2, arg3);
+void test__std__strspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strspn(NULL, arg2);
 }
 
-void test__std__vswscanf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::vswscanf(x, arg2, arg3);
+void test__std__strspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strspn(x, arg2);
 }
 
-void test__std__vswscanf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::vswscanf(arg1, NULL, arg3);
+void test__std__strspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strspn(arg1, NULL);
 }
 
-void test__std__vswscanf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::vswscanf(arg1, x, arg3);
+void test__std__strspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strspn(arg1, x);
 }
 
-void test__vscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vscanf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strxfrm__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strxfrm(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vscanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vscanf(p, arg2);
-    // cppcheck-suppress memleak
+void test__strxfrm__leakignore() {
+  char *p = malloc(10); *p=0;
+  strxfrm(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__vscanf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vscanf(NULL, arg2);
+void test__strxfrm__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strxfrm(arg1, NULL, arg3);
 }
 
-void test__vscanf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    vscanf(x, arg2);
+void test__strxfrm__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strxfrm(arg1, x, arg3);
 }
 
-void test__std__vscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vscanf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strxfrm__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strxfrm(arg1, arg2, x);
 }
 
-void test__std__vscanf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::vscanf(NULL, arg2);
+void test__std__strxfrm__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strxfrm(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vscanf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::vscanf(x, arg2);
+void test__std__strxfrm__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strxfrm(arg1, NULL, arg3);
 }
 
-void test__vwscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vwscanf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strxfrm__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strxfrm(arg1, x, arg3);
 }
 
-void test__vwscanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vwscanf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__strxfrm__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strxfrm(arg1, arg2, x);
 }
 
-void test__vwscanf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vwscanf(NULL, arg2);
+void test__wcsxfrm__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcsxfrm(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vwscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vwscanf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsxfrm__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcsxfrm(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__vwscanf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::vwscanf(NULL, arg2);
+void test__wcsxfrm__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsxfrm(arg1, NULL, arg3);
 }
 
-void test__setbuf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setbuf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsxfrm__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsxfrm(arg1, x, arg3);
 }
 
-void test__setbuf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setbuf(p, arg2);
-    // cppcheck-suppress memleak
+void test__wcsxfrm__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcsxfrm(arg1, arg2, x);
 }
 
-void test__setbuf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    setbuf(NULL, arg2);
+void test__std__wcsxfrm__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wcsxfrm(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__setbuf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    setbuf(x, arg2);
+void test__std__wcsxfrm__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsxfrm(arg1, NULL, arg3);
 }
 
-void test__setbuf__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    setbuf(arg1, !x);
+void test__std__wcsxfrm__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcsxfrm(arg1, x, arg3);
 }
 
-void test__std__setbuf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::setbuf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcsxfrm__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcsxfrm(arg1, arg2, x);
 }
 
-void test__std__setbuf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::setbuf(NULL, arg2);
+void test__wcsspn__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcsspn(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__setbuf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::setbuf(x, arg2);
+void test__wcsspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcsspn(arg1, arg2);
 }
 
-void test__std__setbuf__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::setbuf(arg1, !x);
+void test__wcsspn__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wcsspn(arg1, arg2) > 10) || (wcsspn(arg1, arg2) < 100)) {}
 }
 
-void test__setvbuf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setvbuf(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsspn__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcsspn(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__setvbuf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setvbuf(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__wcsspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsspn(NULL, arg2);
 }
 
-void test__setvbuf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    setvbuf(NULL, arg2, arg3, arg4);
+void test__wcsspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsspn(x, arg2);
 }
 
-void test__setvbuf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    setvbuf(x, arg2, arg3, arg4);
+void test__wcsspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsspn(arg1, NULL);
 }
 
-void test__setvbuf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setvbuf(arg1, x, arg3, arg4);
+void test__wcsspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsspn(arg1, x);
 }
 
-void test__setvbuf__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setvbuf(arg1, arg2, x, arg4);
+void test__std__wcsspn__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wcsspn(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__setvbuf__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setvbuf(arg1, arg2, arg3, x);
+void test__std__wcsspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcsspn(arg1, arg2);
 }
 
-void test__std__setvbuf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::setvbuf(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcsspn__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wcsspn(arg1, arg2) > 10) || (std::wcsspn(arg1, arg2) < 100)) {}
 }
 
-void test__std__setvbuf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::setvbuf(NULL, arg2, arg3, arg4);
+void test__std__wcsspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcsspn(NULL, arg2);
 }
 
-void test__std__setvbuf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::setvbuf(x, arg2, arg3, arg4);
+void test__std__wcsspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcsspn(x, arg2);
 }
 
-void test__std__setvbuf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::setvbuf(arg1, x, arg3, arg4);
+void test__std__wcsspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcsspn(arg1, NULL);
 }
 
-void test__std__setvbuf__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::setvbuf(arg1, arg2, x, arg4);
+void test__std__wcsspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcsspn(arg1, x);
 }
 
-void test__std__setvbuf__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::setvbuf(arg1, arg2, arg3, x);
+void test__localeconv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = localeconv(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__setjmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setjmp(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__localeconv__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  localeconv();
 }
 
-void test__setjmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setjmp(p);
-    // cppcheck-suppress memleak
+void test__localeconv__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = localeconv();
+  // cppcheck-suppress memleak
 }
 
-void test__strcat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strcat(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__localeconv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::localeconv(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strcat__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strcat(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__localeconv__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::localeconv();
 }
 
-void test__strcat__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strcat(NULL, arg2);
+void test__std__locale__global__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::locale::global(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strcat__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strcat(x, arg2);
+void test__std__locale__global__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::locale::global(arg1);
 }
 
-void test__strcat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strcat(arg1, NULL);
+void test__std__locale__global__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::locale::global(x);
 }
 
-void test__strcat__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strcat(arg1, x);
+void test__std__locale__classic__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::locale::classic(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strcat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strcat(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__locale__classic__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::locale::classic();
 }
 
-void test__std__strcat__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strcat(NULL, arg2);
+void test__setlocale__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setlocale(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strcat__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strcat(x, arg2);
+void test__setlocale__leakignore() {
+  char *p = malloc(10); *p=0;
+  setlocale(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__strcat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strcat(arg1, NULL);
+void test__setlocale__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setlocale(x, arg2);
 }
 
-void test__std__strcat__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strcat(arg1, x);
+void test__setlocale__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setlocale(arg1, x);
 }
 
-void test__wcscat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcscat(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__setlocale__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::setlocale(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcscat__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcscat(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__setlocale__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setlocale(x, arg2);
 }
 
-void test__wcscat__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcscat(NULL, arg2);
+void test__std__setlocale__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setlocale(arg1, x);
 }
 
-void test__wcscat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcscat(arg1, NULL);
+void test__strerror__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strerror(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcscat__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcscat(arg1, x);
+void test__strerror__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strerror(arg1);
 }
 
-void test__std__wcscat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wcscat(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strerror__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = strerror(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wcscat__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcscat(NULL, arg2);
+void test__strerror__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strerror(x);
 }
 
-void test__std__wcscat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcscat(arg1, NULL);
+void test__std__strerror__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::strerror(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcscat__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wcscat(arg1, x);
+void test__std__strerror__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strerror(arg1);
 }
 
-void test__wcrtomb__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcrtomb(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strerror__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::strerror(x);
 }
 
-void test__wcrtomb__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcrtomb(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__strcspn__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strcspn(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcrtomb__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wcrtomb(arg1, x, arg3);
+void test__strcspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strcspn(arg1, arg2);
 }
 
-void test__std__wcrtomb__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wcrtomb(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strcspn__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strcspn(arg1, arg2) > 10) || (strcspn(arg1, arg2) < 100)) {}
 }
 
-void test__std__wcrtomb__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wcrtomb(arg1, x, arg3);
+void test__strcspn__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = strcspn(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__strchr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strchr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strcspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strcspn(NULL, arg2);
 }
 
-void test__strchr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strchr(arg1, arg2);
+void test__strcspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strcspn(x, arg2);
 }
 
-void test__strchr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = strchr(p, arg2);
-    // cppcheck-suppress memleak
+void test__strcspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strcspn(arg1, NULL);
 }
 
-void test__strchr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strchr(NULL, arg2);
+void test__strcspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strcspn(arg1, x);
 }
 
-void test__strchr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strchr(x, arg2);
+void test__std__strcspn__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::strcspn(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strchr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = strchr(arg1, x);
+void test__std__strcspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strcspn(arg1, arg2);
 }
 
-void test__std__strchr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::strchr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strcspn__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::strcspn(arg1, arg2) > 10) || (std::strcspn(arg1, arg2) < 100)) {}
 }
 
-void test__std__strchr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::strchr(arg1, arg2);
+void test__std__strcspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strcspn(NULL, arg2);
 }
 
-void test__std__strchr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strchr(NULL, arg2);
+void test__std__strcspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strcspn(x, arg2);
 }
 
-void test__std__strchr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strchr(x, arg2);
+void test__std__strcspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strcspn(arg1, NULL);
 }
 
-void test__std__strchr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::strchr(arg1, x);
+void test__std__strcspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strcspn(arg1, x);
 }
 
-void test__wcschr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcschr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcscspn__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcscspn(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcschr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcschr(arg1, arg2);
+void test__wcscspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcscspn(arg1, arg2);
 }
 
-void test__wcschr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcschr(p, arg2);
-    // cppcheck-suppress memleak
+void test__wcscspn__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wcscspn(arg1, arg2) > 10) || (wcscspn(arg1, arg2) < 100)) {}
 }
 
-void test__wcschr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcschr(NULL, arg2);
+void test__wcscspn__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcscspn(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__wcschr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcschr(x, arg2);
+void test__wcscspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcscspn(NULL, arg2);
 }
 
-void test__wcschr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wcschr(arg1, x);
+void test__wcscspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcscspn(x, arg2);
 }
 
-void test__std__wcschr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wcschr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcscspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcscspn(arg1, NULL);
 }
 
-void test__std__wcschr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wcschr(arg1, arg2);
+void test__wcscspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcscspn(arg1, x);
 }
 
-void test__std__wcschr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcschr(NULL, arg2);
+void test__std__wcscspn__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wcscspn(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcschr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcschr(x, arg2);
+void test__std__wcscspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcscspn(arg1, arg2);
 }
 
-void test__std__wcschr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wcschr(arg1, x);
+void test__std__wcscspn__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wcscspn(arg1, arg2) > 10) || (std::wcscspn(arg1, arg2) < 100)) {}
 }
 
-void test__strcmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strcmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcscspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcscspn(NULL, arg2);
 }
 
-void test__strcmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strcmp(arg1, arg2);
+void test__std__wcscspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcscspn(x, arg2);
 }
 
-void test__strcmp__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((strcmp(arg1, arg2) > 10) || (strcmp(arg1, arg2) < 100)) {}
+void test__std__wcscspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcscspn(arg1, NULL);
 }
 
-void test__strcmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = strcmp(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__wcscspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcscspn(arg1, x);
 }
 
-void test__strcmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strcmp(NULL, arg2);
+void test__wcspbrk__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcspbrk(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strcmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strcmp(x, arg2);
+void test__wcspbrk__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcspbrk(arg1, arg2);
 }
 
-void test__strcmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strcmp(arg1, NULL);
+void test__wcspbrk__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcspbrk(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__strcmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strcmp(arg1, x);
+void test__wcspbrk__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcspbrk(NULL, arg2);
 }
 
-void test__std__strcmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::strcmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcspbrk__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcspbrk(x, arg2);
 }
 
-void test__std__strcmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::strcmp(arg1, arg2);
+void test__wcspbrk__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcspbrk(arg1, x);
 }
 
-void test__std__strcmp__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::strcmp(arg1, arg2) > 10) || (std::strcmp(arg1, arg2) < 100)) {}
+void test__std__wcspbrk__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wcspbrk(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strcmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strcmp(NULL, arg2);
+void test__std__wcspbrk__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcspbrk(arg1, arg2);
 }
 
-void test__std__strcmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strcmp(x, arg2);
+void test__std__wcspbrk__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcspbrk(NULL, arg2);
 }
 
-void test__std__strcmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strcmp(arg1, NULL);
+void test__std__wcspbrk__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcspbrk(x, arg2);
 }
 
-void test__std__strcmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strcmp(arg1, x);
+void test__std__wcspbrk__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wcspbrk(arg1, x);
 }
 
-void test__wcscmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcscmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsncpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcsncpy(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcscmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcscmp(arg1, arg2);
+void test__wcsncpy__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcsncpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__wcscmp__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((wcscmp(arg1, arg2) > 10) || (wcscmp(arg1, arg2) < 100)) {}
+void test__wcsncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsncpy(NULL, arg2, arg3);
 }
 
-void test__wcscmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcscmp(p, arg2);
-    // cppcheck-suppress memleak
+void test__wcsncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsncpy(arg1, NULL, arg3);
 }
 
-void test__wcscmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcscmp(NULL, arg2);
+void test__wcsncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsncpy(arg1, x, arg3);
 }
 
-void test__wcscmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcscmp(x, arg2);
+void test__wcsncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wcsncpy(arg1, arg2, !x);
 }
 
-void test__wcscmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcscmp(arg1, NULL);
+void test__wcsncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcsncpy(arg1, arg2, x);
 }
 
-void test__wcscmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcscmp(arg1, x);
+void test__std__wcsncpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wcsncpy(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcscmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wcscmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcsncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsncpy(NULL, arg2, arg3);
 }
 
-void test__std__wcscmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wcscmp(arg1, arg2);
+void test__std__wcsncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsncpy(arg1, NULL, arg3);
 }
 
-void test__std__wcscmp__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::wcscmp(arg1, arg2) > 10) || (std::wcscmp(arg1, arg2) < 100)) {}
+void test__std__wcsncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcsncpy(arg1, x, arg3);
 }
 
-void test__std__wcscmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcscmp(NULL, arg2);
+void test__std__wcsncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::wcsncpy(arg1, arg2, !x);
 }
 
-void test__std__wcscmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcscmp(x, arg2);
+void test__std__wcsncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcsncpy(arg1, arg2, x);
 }
 
-void test__std__wcscmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcscmp(arg1, NULL);
+void test__strcoll__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strcoll(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcscmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcscmp(arg1, x);
+void test__strcoll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strcoll(arg1, arg2);
 }
 
-void test__strcpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strcpy(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strcoll__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = strcoll(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__strcpy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strcpy(p, arg2);
-    // cppcheck-suppress memleak
+void test__strcoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strcoll(NULL, arg2);
 }
 
-void test__strcpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strcpy(NULL, arg2);
+void test__strcoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strcoll(x, arg2);
 }
 
-void test__strcpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strcpy(arg1, NULL);
+void test__strcoll__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strcoll(arg1, NULL);
 }
 
-void test__strcpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strcpy(arg1, x);
+void test__strcoll__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strcoll(arg1, x);
 }
 
-void test__std__strcpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strcpy(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strcoll__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::strcoll(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strcpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strcpy(NULL, arg2);
+void test__std__strcoll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strcoll(arg1, arg2);
 }
 
-void test__std__strcpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strcpy(arg1, NULL);
+void test__std__strcoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strcoll(NULL, arg2);
 }
 
-void test__std__strcpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strcpy(arg1, x);
+void test__std__strcoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strcoll(x, arg2);
 }
 
-void test__wcscpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcscpy(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strcoll__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strcoll(arg1, NULL);
 }
 
-void test__wcscpy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcscpy(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__strcoll__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strcoll(arg1, x);
 }
 
-void test__wcscpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcscpy(NULL, arg2);
+void test__wcscoll__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcscoll(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcscpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcscpy(arg1, NULL);
+void test__wcscoll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcscoll(arg1, arg2);
 }
 
-void test__wcscpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcscpy(arg1, x);
+void test__wcscoll__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcscoll(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wcscpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wcscpy(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcscoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcscoll(NULL, arg2);
 }
 
-void test__std__wcscpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcscpy(NULL, arg2);
+void test__wcscoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcscoll(x, arg2);
 }
 
-void test__std__wcscpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcscpy(arg1, NULL);
+void test__wcscoll__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcscoll(arg1, NULL);
 }
 
-void test__std__wcscpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wcscpy(arg1, x);
+void test__wcscoll__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcscoll(arg1, x);
 }
 
-void test__strftime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strftime(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcscoll__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wcscoll(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strftime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strftime(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__std__wcscoll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcscoll(arg1, arg2);
 }
 
-void test__strftime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strftime(NULL, arg2, arg3, arg4);
+void test__std__wcscoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcscoll(NULL, arg2);
 }
 
-void test__strftime__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strftime(arg1, x, arg3, arg4);
+void test__std__wcscoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcscoll(x, arg2);
 }
 
-void test__strftime__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strftime(arg1, arg2, NULL, arg4);
+void test__std__wcscoll__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcscoll(arg1, NULL);
 }
 
-void test__strftime__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strftime(arg1, arg2, x, arg4);
+void test__std__wcscoll__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcscoll(arg1, x);
 }
 
-void test__strftime__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strftime(arg1, arg2, arg3, NULL);
+void test__strrchr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strrchr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strftime__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strftime(arg1, arg2, arg3, x);
+void test__strrchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strrchr(arg1, arg2);
 }
 
-void test__std__strftime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strftime(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strrchr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = strrchr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__strftime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strftime(NULL, arg2, arg3, arg4);
+void test__strrchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strrchr(NULL, arg2);
 }
 
-void test__std__strftime__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::strftime(arg1, x, arg3, arg4);
+void test__strrchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strrchr(x, arg2);
 }
 
-void test__std__strftime__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strftime(arg1, arg2, NULL, arg4);
+void test__strrchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strrchr(arg1, x);
 }
 
-void test__std__strftime__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strftime(arg1, arg2, x, arg4);
+void test__std__strrchr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::strrchr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strftime__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strftime(arg1, arg2, arg3, NULL);
+void test__std__strrchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strrchr(arg1, arg2);
 }
 
-void test__std__strftime__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strftime(arg1, arg2, arg3, x);
+void test__std__strrchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strrchr(NULL, arg2);
 }
 
-void test__strfxtime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strfxtime(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strrchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strrchr(x, arg2);
 }
 
-void test__strfxtime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strfxtime(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__std__strrchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::strrchr(arg1, x);
 }
 
-void test__strfxtime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strfxtime(NULL, arg2, arg3, arg4);
+void test__wcsrchr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcsrchr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strfxtime__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strfxtime(arg1, x, arg3, arg4);
+void test__wcsrchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcsrchr(arg1, arg2);
 }
 
-void test__strfxtime__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strfxtime(arg1, arg2, NULL, arg4);
+void test__wcsrchr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcsrchr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__strfxtime__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strfxtime(arg1, arg2, x, arg4);
+void test__wcsrchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsrchr(NULL, arg2);
 }
 
-void test__strfxtime__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strfxtime(arg1, arg2, arg3, NULL);
+void test__wcsrchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsrchr(x, arg2);
 }
 
-void test__strfxtime__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strfxtime(arg1, arg2, arg3, x);
+void test__wcsrchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcsrchr(arg1, x);
 }
 
-void test__strlen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strlen(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcsrchr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wcsrchr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strlen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strlen(arg1);
+void test__std__wcsrchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcsrchr(arg1, arg2);
 }
 
-void test__strlen__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((strlen(arg1) > 10) || (strlen(arg1) < 100)) {}
+void test__std__wcsrchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcsrchr(NULL, arg2);
 }
 
-void test__strlen__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = strlen(p);
-    // cppcheck-suppress memleak
+void test__std__wcsrchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcsrchr(x, arg2);
 }
 
-void test__strlen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strlen(NULL);
+void test__std__wcsrchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wcsrchr(arg1, x);
 }
 
-void test__strlen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strlen(x);
+void test__wcsrtombs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcsrtombs(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strlen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::strlen(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsrtombs__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcsrtombs(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__std__strlen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::strlen(arg1);
+void test__wcsrtombs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsrtombs(arg1, NULL, arg3, arg4);
 }
 
-void test__std__strlen__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::strlen(arg1) > 10) || (std::strlen(arg1) < 100)) {}
+void test__wcsrtombs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsrtombs(arg1, x, arg3, arg4);
 }
 
-void test__std__strlen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strlen(NULL);
+void test__wcsrtombs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcsrtombs(arg1, arg2, x, arg4);
 }
 
-void test__std__strlen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strlen(x);
+void test__wcsrtombs__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsrtombs(arg1, arg2, arg3, NULL);
 }
 
-void test__wcslen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcslen(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcsrtombs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wcsrtombs(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcslen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcslen(arg1);
+void test__std__wcsrtombs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsrtombs(arg1, NULL, arg3, arg4);
 }
 
-void test__wcslen__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((wcslen(arg1) > 10) || (wcslen(arg1) < 100)) {}
+void test__std__wcsrtombs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcsrtombs(arg1, x, arg3, arg4);
 }
 
-void test__wcslen__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcslen(p);
-    // cppcheck-suppress memleak
+void test__std__wcsrtombs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcsrtombs(arg1, arg2, x, arg4);
 }
 
-void test__wcslen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcslen(NULL);
+void test__std__wcsrtombs__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsrtombs(arg1, arg2, arg3, NULL);
 }
 
-void test__wcslen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcslen(x);
+void test__strtok__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strtok(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcslen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wcslen(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strtok__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strtok(arg1, arg2) > 10) || (strtok(arg1, arg2) < 100)) {}
 }
 
-void test__std__wcslen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wcslen(arg1);
+void test__strtok__leakignore() {
+  char *p = malloc(10); *p=0;
+  strtok(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wcslen__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::wcslen(arg1) > 10) || (std::wcslen(arg1) < 100)) {}
+void test__strtok__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtok(x, arg2);
 }
 
-void test__std__wcslen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcslen(NULL);
+void test__strtok__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strtok(arg1, NULL);
 }
 
-void test__std__wcslen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcslen(x);
+void test__strtok__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtok(arg1, x);
 }
 
-void test__strncpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strncpy(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strtok__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strtok(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strncpy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strncpy(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__strtok__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::strtok(arg1, arg2) > 10) || (std::strtok(arg1, arg2) < 100)) {}
 }
 
-void test__strncpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strncpy(NULL, arg2, arg3);
+void test__std__strtok__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strtok(x, arg2);
 }
 
-void test__strncpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strncpy(arg1, NULL, arg3);
+void test__std__strtok__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtok(arg1, NULL);
 }
 
-void test__strncpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strncpy(arg1, x, arg3);
+void test__std__strtok__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtok(arg1, x);
 }
 
-void test__strncpy__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    strncpy(arg1, arg2, !x);
+void test__strtof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strtof(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strncpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strncpy(arg1, arg2, x);
+void test__strtof__leakignore() {
+  char *p = malloc(10); *p=0;
+  strtof(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__strncpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strncpy(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strtof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtof(NULL, arg2);
 }
 
-void test__std__strncpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strncpy(NULL, arg2, arg3);
+void test__strtof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtof(x, arg2);
 }
 
-void test__std__strncpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strncpy(arg1, NULL, arg3);
+void test__std__strtof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strtof(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strncpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strncpy(arg1, x, arg3);
+void test__std__strtof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtof(NULL, arg2);
 }
 
-void test__std__strncpy__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::strncpy(arg1, arg2, !x);
+void test__std__strtof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtof(x, arg2);
 }
 
-void test__std__strncpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::strncpy(arg1, arg2, x);
+void test__strtod__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strtod(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strpbrk__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strpbrk(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strtod__leakignore() {
+  char *p = malloc(10); *p=0;
+  strtod(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__strpbrk__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strpbrk(arg1, arg2);
+void test__strtod__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtod(NULL, arg2);
 }
 
-void test__strpbrk__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = strpbrk(p, arg2);
-    // cppcheck-suppress memleak
+void test__strtod__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtod(x, arg2);
 }
 
-void test__strpbrk__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strpbrk(NULL, arg2);
+void test__std__strtod__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strtod(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strpbrk__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strpbrk(x, arg2);
+void test__std__strtod__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtod(NULL, arg2);
 }
 
-void test__strpbrk__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strpbrk(arg1, NULL);
+void test__std__strtod__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtod(x, arg2);
 }
 
-void test__strpbrk__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strpbrk(arg1, x);
+void test__strtold__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strtold(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strpbrk__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::strpbrk(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strtold__leakignore() {
+  char *p = malloc(10); *p=0;
+  strtold(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__strpbrk__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::strpbrk(arg1, arg2);
+void test__strtold__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtold(NULL, arg2);
 }
 
-void test__std__strpbrk__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strpbrk(NULL, arg2);
+void test__strtold__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtold(x, arg2);
 }
 
-void test__std__strpbrk__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strpbrk(x, arg2);
+void test__std__strtold__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strtold(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strpbrk__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strpbrk(arg1, NULL);
+void test__std__strtold__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtold(NULL, arg2);
 }
 
-void test__std__strpbrk__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strpbrk(arg1, x);
+void test__std__strtold__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtold(x, arg2);
 }
 
-void test__strncat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strncat(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strtol__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strtol(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strncat__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strncat(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__strtol__leakignore() {
+  char *p = malloc(10); *p=0;
+  strtol(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__strncat__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strncat(NULL, arg2, arg3);
+void test__strtol__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtol(NULL, arg2, arg3);
 }
 
-void test__strncat__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strncat(x, arg2, arg3);
+void test__strtol__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtol(x, arg2, arg3);
 }
 
-void test__strncat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strncat(arg1, NULL, arg3);
+void test__strtol__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtol(arg1, arg2, x);
 }
 
-void test__strncat__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strncat(arg1, x, arg3);
+void test__std__strtol__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strtol(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strncat__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    strncat(arg1, arg2, !x);
+void test__std__strtol__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtol(NULL, arg2, arg3);
 }
 
-void test__strncat__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strncat(arg1, arg2, x);
+void test__std__strtol__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtol(x, arg2, arg3);
 }
 
-void test__std__strncat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strncat(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strtol__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strtol(arg1, arg2, x);
 }
 
-void test__std__strncat__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strncat(NULL, arg2, arg3);
+void test__strtoul__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strtoul(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strncat__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strncat(x, arg2, arg3);
+void test__strtoul__leakignore() {
+  char *p = malloc(10); *p=0;
+  strtoul(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__strncat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strncat(arg1, NULL, arg3);
+void test__strtoul__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtoul(NULL, arg2, arg3);
 }
 
-void test__std__strncat__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strncat(arg1, x, arg3);
+void test__strtoul__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtoul(x, arg2, arg3);
 }
 
-void test__std__strncat__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::strncat(arg1, arg2, !x);
+void test__strtoul__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtoul(arg1, arg2, x);
 }
 
-void test__std__strncat__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::strncat(arg1, arg2, x);
+void test__std__strtoul__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strtoul(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsncat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcsncat(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strtoul__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtoul(NULL, arg2, arg3);
 }
 
-void test__wcsncat__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcsncat(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__strtoul__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtoul(x, arg2, arg3);
 }
 
-void test__wcsncat__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcsncat(NULL, arg2, arg3);
+void test__std__strtoul__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strtoul(arg1, arg2, x);
 }
 
-void test__wcsncat__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcsncat(x, arg2, arg3);
+void test__strtoll__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strtoll(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsncat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcsncat(arg1, NULL, arg3);
+void test__strtoll__leakignore() {
+  char *p = malloc(10); *p=0;
+  strtoll(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__wcsncat__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcsncat(arg1, x, arg3);
+void test__strtoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtoll(NULL, arg2, arg3);
 }
 
-void test__wcsncat__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wcsncat(arg1, arg2, !x);
+void test__strtoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtoll(x, arg2, arg3);
 }
 
-void test__wcsncat__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wcsncat(arg1, arg2, x);
+void test__strtoll__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtoll(arg1, arg2, x);
 }
 
-void test__std__wcsncat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wcsncat(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__strtoll__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strtoll(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsncat__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcsncat(NULL, arg2, arg3);
+void test__std__strtoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtoll(NULL, arg2, arg3);
 }
 
-void test__std__wcsncat__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wcsncat(x, arg2, arg3);
+void test__std__strtoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtoll(x, arg2, arg3);
 }
 
-void test__std__wcsncat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcsncat(arg1, NULL, arg3);
+void test__std__strtoll__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strtoll(arg1, arg2, x);
 }
 
-void test__std__wcsncat__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wcsncat(arg1, x, arg3);
+void test__strtoull__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strtoull(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsncat__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::wcsncat(arg1, arg2, !x);
+void test__strtoull__leakignore() {
+  char *p = malloc(10); *p=0;
+  strtoull(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wcsncat__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wcsncat(arg1, arg2, x);
+void test__strtoull__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtoull(NULL, arg2, arg3);
 }
 
-void test__strncmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strncmp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strtoull__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtoull(x, arg2, arg3);
 }
 
-void test__strncmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strncmp(arg1, arg2, arg3);
+void test__strtoull__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtoull(arg1, arg2, x);
 }
 
-void test__strncmp__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((strncmp(arg1, arg2, arg3) > 10) || (strncmp(arg1, arg2, arg3) < 100)) {}
+void test__std__strtoull__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strtoull(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strncmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = strncmp(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__strtoull__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtoull(NULL, arg2, arg3);
 }
 
-void test__strncmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strncmp(NULL, arg2, arg3);
+void test__std__strtoull__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtoull(x, arg2, arg3);
 }
 
-void test__strncmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strncmp(x, arg2, arg3);
+void test__std__strtoull__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strtoull(arg1, arg2, x);
 }
 
-void test__strncmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strncmp(arg1, NULL, arg3);
+void test__strtoimax__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strtoimax(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strncmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strncmp(arg1, x, arg3);
+void test__strtoimax__leakignore() {
+  char *p = malloc(10); *p=0;
+  strtoimax(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__strncmp__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = strncmp(arg1, arg2, !x);
+void test__strtoimax__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtoimax(NULL, arg2, arg3);
 }
 
-void test__strncmp__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = strncmp(arg1, arg2, x);
+void test__strtoimax__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtoimax(x, arg2, arg3);
 }
 
-void test__std__strncmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::strncmp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strtoimax__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtoimax(arg1, arg2, x);
 }
 
-void test__std__strncmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::strncmp(arg1, arg2, arg3);
+void test__std__strtoimax__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strtoimax(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strncmp__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::strncmp(arg1, arg2, arg3) > 10) || (std::strncmp(arg1, arg2, arg3) < 100)) {}
+void test__std__strtoimax__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtoimax(NULL, arg2, arg3);
 }
 
-void test__std__strncmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strncmp(NULL, arg2, arg3);
+void test__std__strtoimax__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtoimax(x, arg2, arg3);
 }
 
-void test__std__strncmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strncmp(x, arg2, arg3);
+void test__std__strtoimax__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strtoimax(arg1, arg2, x);
 }
 
-void test__std__strncmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strncmp(arg1, NULL, arg3);
+void test__strtoumax__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strtoumax(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strncmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strncmp(arg1, x, arg3);
+void test__strtoumax__leakignore() {
+  char *p = malloc(10); *p=0;
+  strtoumax(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__strncmp__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = std::strncmp(arg1, arg2, !x);
+void test__strtoumax__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtoumax(NULL, arg2, arg3);
 }
 
-void test__std__strncmp__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::strncmp(arg1, arg2, x);
+void test__strtoumax__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtoumax(x, arg2, arg3);
 }
 
-void test__wcsncmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcsncmp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strtoumax__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtoumax(arg1, arg2, x);
 }
 
-void test__wcsncmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcsncmp(arg1, arg2, arg3);
+void test__std__strtoumax__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::strtoumax(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsncmp__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((wcsncmp(arg1, arg2, arg3) > 10) || (wcsncmp(arg1, arg2, arg3) < 100)) {}
+void test__std__strtoumax__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtoumax(NULL, arg2, arg3);
 }
 
-void test__wcsncmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcsncmp(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__strtoumax__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtoumax(x, arg2, arg3);
 }
 
-void test__wcsncmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcsncmp(NULL, arg2, arg3);
+void test__std__strtoumax__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strtoumax(arg1, arg2, x);
 }
 
-void test__wcsncmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcsncmp(x, arg2, arg3);
+void test__time__noreturn() {
+  int x = 1;
+  if (cond) { x=100; time(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsncmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcsncmp(arg1, NULL, arg3);
+void test__time__leakignore() {
+  char *p = malloc(10); *p=0;
+  time(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wcsncmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcsncmp(arg1, x, arg3);
+void test__time__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  time(x);
 }
 
-void test__wcsncmp__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = wcsncmp(arg1, arg2, !x);
+void test__std__time__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::time(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsncmp__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wcsncmp(arg1, arg2, x);
+void test__std__time__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::time(x);
 }
 
-void test__std__wcsncmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wcsncmp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tmpnam__noreturn() {
+  int x = 1;
+  if (cond) { x=100; tmpnam(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsncmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wcsncmp(arg1, arg2, arg3);
+void test__tmpnam__leakignore() {
+  char *p = malloc(10); *p=0;
+  tmpnam(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wcsncmp__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::wcsncmp(arg1, arg2, arg3) > 10) || (std::wcsncmp(arg1, arg2, arg3) < 100)) {}
+void test__tmpnam__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tmpnam(x);
 }
 
-void test__std__wcsncmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcsncmp(NULL, arg2, arg3);
+void test__std__tmpnam__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::tmpnam(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsncmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcsncmp(x, arg2, arg3);
+void test__std__tmpnam__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::tmpnam(x);
 }
 
-void test__std__wcsncmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcsncmp(arg1, NULL, arg3);
+void test__tmpnam_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; tmpnam_s(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsncmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcsncmp(arg1, x, arg3);
+void test__tmpnam_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  tmpnam_s(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wcsncmp__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = std::wcsncmp(arg1, arg2, !x);
+void test__tmpnam_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tmpnam_s(x, arg2);
 }
 
-void test__std__wcsncmp__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wcsncmp(arg1, arg2, x);
+void test__tmpnam_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tmpnam_s(arg1, x);
 }
 
-void test__strstr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strstr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__tmpfile__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = tmpfile(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strstr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strstr(arg1, arg2);
+void test__tmpfile__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tmpfile();
 }
 
-void test__strstr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = strstr(p, arg2);
-    // cppcheck-suppress memleak
+void test__tolower__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = tolower(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strstr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strstr(NULL, arg2);
+void test__tolower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tolower(arg1);
 }
 
-void test__strstr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strstr(x, arg2);
+void test__tolower__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = tolower(p);
+  // cppcheck-suppress memleak
 }
 
-void test__strstr__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strstr(arg1, NULL);
+void test__tolower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tolower(x);
 }
 
-void test__strstr__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strstr(arg1, x);
+void test__std__tolower__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::tolower(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strstr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::strstr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__tolower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::tolower(arg1);
 }
 
-void test__std__strstr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::strstr(arg1, arg2);
+void test__std__tolower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tolower(x);
 }
 
-void test__std__strstr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strstr(NULL, arg2);
+void test__toupper__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = toupper(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strstr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strstr(x, arg2);
+void test__toupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  toupper(arg1);
 }
 
-void test__std__strstr__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strstr(arg1, NULL);
+void test__toupper__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = toupper(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__strstr__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strstr(arg1, x);
+void test__toupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = toupper(x);
 }
 
-void test__wcsstr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcsstr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__toupper__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::toupper(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsstr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcsstr(arg1, arg2);
+void test__std__toupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::toupper(arg1);
 }
 
-void test__wcsstr__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((wcsstr(arg1, arg2) > 10) || (wcsstr(arg1, arg2) < 100)) {}
+void test__std__toupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::toupper(x);
 }
 
-void test__wcsstr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcsstr(p, arg2);
-    // cppcheck-suppress memleak
+void test__typeid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = typeid(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsstr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcsstr(NULL, arg2);
+void test__typeid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  typeid(arg1);
 }
 
-void test__wcsstr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcsstr(x, arg2);
+void test__va_arg__noreturn() {
+  int x = 1;
+  if (cond) { x=100; va_arg(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsstr__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcsstr(arg1, NULL);
+void test__va_arg__leakignore() {
+  char *p = malloc(10); *p=0;
+  va_arg(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__wcsstr__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcsstr(arg1, x);
+void test__va_copy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; va_copy(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsstr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wcsstr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__va_copy__leakignore() {
+  char *p = malloc(10); *p=0;
+  va_copy(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wcsstr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wcsstr(arg1, arg2);
+void test__va_end__noreturn() {
+  int x = 1;
+  if (cond) { x=100; va_end(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsstr__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::wcsstr(arg1, arg2) > 10) || (std::wcsstr(arg1, arg2) < 100)) {}
+void test__va_end__leakignore() {
+  char *p = malloc(10); *p=0;
+  va_end(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wcsstr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcsstr(NULL, arg2);
+void test__va_start__noreturn() {
+  int x = 1;
+  if (cond) { x=100; va_start(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsstr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcsstr(x, arg2);
+void test__va_start__leakignore() {
+  char *p = malloc(10); *p=0;
+  va_start(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wcsstr__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcsstr(arg1, NULL);
+void test__wcstof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcstof(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsstr__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcsstr(arg1, x);
+void test__wcstof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcstof(arg1, arg2);
 }
 
-void test__strspn__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strspn(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcstof__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcstof(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__strspn__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strspn(arg1, arg2);
+void test__wcstof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcstof(NULL, arg2);
 }
 
-void test__strspn__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = strspn(p, arg2);
-    // cppcheck-suppress memleak
+void test__wcstof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcstof(x, arg2);
 }
 
-void test__strspn__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strspn(NULL, arg2);
+void test__std__wcstof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wcstof(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strspn__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strspn(x, arg2);
+void test__std__wcstof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcstof(arg1, arg2);
 }
 
-void test__strspn__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strspn(arg1, NULL);
+void test__std__wcstof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcstof(NULL, arg2);
 }
 
-void test__strspn__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strspn(arg1, x);
+void test__std__wcstof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcstof(x, arg2);
 }
 
-void test__std__strspn__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::strspn(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcstod__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcstod(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strspn__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::strspn(arg1, arg2);
+void test__wcstod__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcstod(arg1, arg2);
 }
 
-void test__std__strspn__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strspn(NULL, arg2);
+void test__wcstod__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcstod(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__strspn__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strspn(x, arg2);
+void test__wcstod__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcstod(NULL, arg2);
 }
 
-void test__std__strspn__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strspn(arg1, NULL);
+void test__wcstod__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcstod(x, arg2);
 }
 
-void test__std__strspn__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strspn(arg1, x);
+void test__std__wcstod__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wcstod(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strxfrm__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strxfrm(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcstod__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcstod(arg1, arg2);
 }
 
-void test__strxfrm__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strxfrm(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__wcstod__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcstod(NULL, arg2);
 }
 
-void test__strxfrm__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strxfrm(arg1, NULL, arg3);
+void test__std__wcstod__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcstod(x, arg2);
 }
 
-void test__strxfrm__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strxfrm(arg1, x, arg3);
+void test__wcstold__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcstold(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strxfrm__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strxfrm(arg1, arg2, x);
+void test__wcstold__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcstold(arg1, arg2);
 }
 
-void test__std__strxfrm__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strxfrm(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcstold__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcstold(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__strxfrm__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strxfrm(arg1, NULL, arg3);
+void test__wcstold__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcstold(NULL, arg2);
 }
 
-void test__std__strxfrm__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strxfrm(arg1, x, arg3);
+void test__wcstold__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcstold(x, arg2);
 }
 
-void test__std__strxfrm__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::strxfrm(arg1, arg2, x);
+void test__std__wcstold__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wcstold(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsxfrm__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcsxfrm(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcstold__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcstold(arg1, arg2);
 }
 
-void test__wcsxfrm__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcsxfrm(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__wcstold__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcstold(NULL, arg2);
 }
 
-void test__wcsxfrm__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcsxfrm(arg1, NULL, arg3);
+void test__std__wcstold__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcstold(x, arg2);
 }
 
-void test__wcsxfrm__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcsxfrm(arg1, x, arg3);
+void test__stof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = stof(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsxfrm__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wcsxfrm(arg1, arg2, x);
+void test__stof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stof(arg1, arg2);
 }
 
-void test__std__wcsxfrm__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wcsxfrm(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__stof__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = stof(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wcsxfrm__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcsxfrm(arg1, NULL, arg3);
+void test__stof__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stof(x, arg2);
 }
 
-void test__std__wcsxfrm__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wcsxfrm(arg1, x, arg3);
+void test__stof__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stof(arg1, x);
 }
 
-void test__std__wcsxfrm__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wcsxfrm(arg1, arg2, x);
+void test__std__stof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::stof(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsspn__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcsspn(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__stof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stof(arg1, arg2);
 }
 
-void test__wcsspn__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcsspn(arg1, arg2);
+void test__std__stof__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stof(x, arg2);
 }
 
-void test__wcsspn__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((wcsspn(arg1, arg2) > 10) || (wcsspn(arg1, arg2) < 100)) {}
+void test__std__stof__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stof(arg1, x);
 }
 
-void test__wcsspn__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcsspn(p, arg2);
-    // cppcheck-suppress memleak
+void test__stod__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = stod(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsspn__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcsspn(NULL, arg2);
+void test__stod__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stod(arg1, arg2);
 }
 
-void test__wcsspn__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcsspn(x, arg2);
+void test__stod__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = stod(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__wcsspn__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcsspn(arg1, NULL);
+void test__stod__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stod(x, arg2);
 }
 
-void test__wcsspn__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcsspn(arg1, x);
+void test__stod__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stod(arg1, x);
 }
 
-void test__std__wcsspn__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wcsspn(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__stod__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::stod(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsspn__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wcsspn(arg1, arg2);
+void test__std__stod__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stod(arg1, arg2);
 }
 
-void test__std__wcsspn__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::wcsspn(arg1, arg2) > 10) || (std::wcsspn(arg1, arg2) < 100)) {}
+void test__std__stod__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stod(x, arg2);
 }
 
-void test__std__wcsspn__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcsspn(NULL, arg2);
+void test__std__stod__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stod(arg1, x);
 }
 
-void test__std__wcsspn__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcsspn(x, arg2);
+void test__stold__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = stold(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsspn__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcsspn(arg1, NULL);
+void test__stold__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stold(arg1, arg2);
 }
 
-void test__std__wcsspn__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcsspn(arg1, x);
+void test__stold__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = stold(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__localeconv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = localeconv();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__stold__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stold(x, arg2);
 }
 
-void test__localeconv__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    localeconv();
+void test__stold__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stold(arg1, x);
 }
 
-void test__localeconv__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = localeconv();
-    // cppcheck-suppress memleak
+void test__std__stold__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::stold(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__localeconv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::localeconv();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__stold__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stold(arg1, arg2);
 }
 
-void test__std__localeconv__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::localeconv();
+void test__std__stold__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stold(x, arg2);
 }
 
-void test__std__locale__global__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::locale::global(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__stold__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stold(arg1, x);
 }
 
-void test__std__locale__global__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::locale::global(arg1);
+void test__stoi__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = stoi(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__locale__global__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::locale::global(x);
+void test__stoi__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stoi(arg1, arg2, arg3);
 }
 
-void test__std__locale__classic__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::locale::classic();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__stoi__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = stoi(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__locale__classic__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::locale::classic();
-}
-
-void test__setlocale__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setlocale(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__setlocale__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setlocale(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__setlocale__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setlocale(x, arg2);
+void test__stoi__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoi(x, arg2, arg3);
 }
 
-void test__setlocale__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setlocale(arg1, x);
+void test__stoi__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoi(arg1, x, arg3);
 }
 
-void test__std__setlocale__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::setlocale(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__setlocale__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::setlocale(x, arg2);
+void test__stoi__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoi(arg1, arg2, x);
 }
 
-void test__std__setlocale__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::setlocale(arg1, x);
+void test__std__stoi__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::stoi(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strerror__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strerror(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__stoi__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stoi(arg1, arg2, arg3);
 }
 
-void test__strerror__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strerror(arg1);
+void test__std__stoi__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoi(x, arg2, arg3);
 }
 
-void test__strerror__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = strerror(p);
-    // cppcheck-suppress memleak
+void test__std__stoi__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoi(arg1, x, arg3);
 }
 
-void test__strerror__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = strerror(x);
+void test__std__stoi__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoi(arg1, arg2, x);
 }
 
-void test__std__strerror__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::strerror(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__stol__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = stol(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strerror__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::strerror(arg1);
+void test__stol__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stol(arg1, arg2, arg3);
 }
 
-void test__std__strerror__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::strerror(x);
+void test__stol__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = stol(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__strcspn__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strcspn(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__stol__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stol(x, arg2, arg3);
 }
 
-void test__strcspn__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strcspn(arg1, arg2);
+void test__stol__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stol(arg1, x, arg3);
 }
 
-void test__strcspn__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((strcspn(arg1, arg2) > 10) || (strcspn(arg1, arg2) < 100)) {}
+void test__stol__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stol(arg1, arg2, x);
 }
 
-void test__strcspn__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = strcspn(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__stol__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::stol(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strcspn__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strcspn(NULL, arg2);
+void test__std__stol__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stol(arg1, arg2, arg3);
 }
 
-void test__strcspn__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strcspn(x, arg2);
+void test__std__stol__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stol(x, arg2, arg3);
 }
 
-void test__strcspn__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strcspn(arg1, NULL);
+void test__std__stol__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stol(arg1, x, arg3);
 }
 
-void test__strcspn__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strcspn(arg1, x);
+void test__std__stol__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stol(arg1, arg2, x);
 }
 
-void test__std__strcspn__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::strcspn(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__stoll__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = stoll(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strcspn__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::strcspn(arg1, arg2);
+void test__stoll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stoll(arg1, arg2, arg3);
 }
 
-void test__std__strcspn__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::strcspn(arg1, arg2) > 10) || (std::strcspn(arg1, arg2) < 100)) {}
+void test__stoll__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = stoll(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__strcspn__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strcspn(NULL, arg2);
+void test__stoll__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoll(x, arg2, arg3);
 }
 
-void test__std__strcspn__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strcspn(x, arg2);
+void test__stoll__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoll(arg1, x, arg3);
 }
 
-void test__std__strcspn__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strcspn(arg1, NULL);
+void test__stoll__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoll(arg1, arg2, x);
 }
 
-void test__std__strcspn__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strcspn(arg1, x);
+void test__std__stoll__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::stoll(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcscspn__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcscspn(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__stoll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stoll(arg1, arg2, arg3);
 }
 
-void test__wcscspn__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcscspn(arg1, arg2);
+void test__std__stoll__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoll(x, arg2, arg3);
 }
 
-void test__wcscspn__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((wcscspn(arg1, arg2) > 10) || (wcscspn(arg1, arg2) < 100)) {}
+void test__std__stoll__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoll(arg1, x, arg3);
 }
 
-void test__wcscspn__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcscspn(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__stoll__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoll(arg1, arg2, x);
 }
 
-void test__wcscspn__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcscspn(NULL, arg2);
+void test__stoul__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = stoul(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcscspn__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcscspn(x, arg2);
+void test__stoul__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stoul(arg1, arg2, arg3);
 }
 
-void test__wcscspn__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcscspn(arg1, NULL);
+void test__stoul__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = stoul(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__wcscspn__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcscspn(arg1, x);
+void test__stoul__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoul(x, arg2, arg3);
 }
 
-void test__std__wcscspn__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wcscspn(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__stoul__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoul(arg1, x, arg3);
 }
 
-void test__std__wcscspn__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wcscspn(arg1, arg2);
+void test__stoul__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoul(arg1, arg2, x);
 }
 
-void test__std__wcscspn__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::wcscspn(arg1, arg2) > 10) || (std::wcscspn(arg1, arg2) < 100)) {}
+void test__std__stoul__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::stoul(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcscspn__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcscspn(NULL, arg2);
+void test__std__stoul__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stoul(arg1, arg2, arg3);
 }
 
-void test__std__wcscspn__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcscspn(x, arg2);
+void test__std__stoul__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoul(x, arg2, arg3);
 }
 
-void test__std__wcscspn__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcscspn(arg1, NULL);
+void test__std__stoul__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoul(arg1, x, arg3);
 }
 
-void test__std__wcscspn__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcscspn(arg1, x);
+void test__std__stoul__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoul(arg1, arg2, x);
 }
 
-void test__wcspbrk__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcspbrk(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__stoull__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = stoull(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcspbrk__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcspbrk(arg1, arg2);
+void test__stoull__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stoull(arg1, arg2, arg3);
 }
 
-void test__wcspbrk__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcspbrk(p, arg2);
-    // cppcheck-suppress memleak
+void test__stoull__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = stoull(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__wcspbrk__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcspbrk(NULL, arg2);
+void test__stoull__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoull(x, arg2, arg3);
 }
 
-void test__wcspbrk__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcspbrk(x, arg2);
+void test__stoull__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoull(arg1, x, arg3);
 }
 
-void test__wcspbrk__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wcspbrk(arg1, x);
+void test__stoull__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoull(arg1, arg2, x);
 }
 
-void test__std__wcspbrk__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wcspbrk(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__stoull__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::stoull(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcspbrk__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wcspbrk(arg1, arg2);
+void test__std__stoull__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stoull(arg1, arg2, arg3);
 }
 
-void test__std__wcspbrk__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcspbrk(NULL, arg2);
+void test__std__stoull__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoull(x, arg2, arg3);
 }
 
-void test__std__wcspbrk__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcspbrk(x, arg2);
+void test__std__stoull__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoull(arg1, x, arg3);
 }
 
-void test__std__wcspbrk__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wcspbrk(arg1, x);
+void test__std__stoull__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoull(arg1, arg2, x);
 }
 
-void test__wcsncpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcsncpy(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__to_string__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::to_string(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsncpy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcsncpy(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__to_string__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::to_string(arg1);
 }
 
-void test__wcsncpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcsncpy(NULL, arg2, arg3);
+void test__std__to_string__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::to_string(x);
 }
 
-void test__wcsncpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcsncpy(arg1, NULL, arg3);
+void test__std__string__resize__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::string::resize(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsncpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcsncpy(arg1, x, arg3);
+void test__std__string__resize__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::string::resize(x, arg2);
 }
 
-void test__wcsncpy__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wcsncpy(arg1, arg2, !x);
+void test__std__string__resize__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::string::resize(arg1, x);
 }
 
-void test__wcsncpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wcsncpy(arg1, arg2, x);
+void test__std__wstring__resize__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wstring::resize(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsncpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wcsncpy(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wstring__resize__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wstring::resize(x, arg2);
 }
 
-void test__std__wcsncpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcsncpy(NULL, arg2, arg3);
+void test__std__wstring__resize__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wstring::resize(arg1, x);
 }
 
-void test__std__wcsncpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcsncpy(arg1, NULL, arg3);
+void test__std__to_wstring__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::to_wstring(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsncpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wcsncpy(arg1, x, arg3);
+void test__std__to_wstring__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::to_wstring(arg1);
 }
 
-void test__std__wcsncpy__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    std::wcsncpy(arg1, arg2, !x);
+void test__std__to_wstring__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::to_wstring(x);
 }
 
-void test__std__wcsncpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wcsncpy(arg1, arg2, x);
+void test__mbrtowc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mbrtowc(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strcoll__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strcoll(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mbrtowc__leakignore() {
+  char *p = malloc(10); *p=0;
+  mbrtowc(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__strcoll__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strcoll(arg1, arg2);
+void test__mbrtowc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrtowc(arg1, x, arg3, arg4);
 }
 
-void test__strcoll__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = strcoll(p, arg2);
-    // cppcheck-suppress memleak
+void test__mbrtowc__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrtowc(arg1, arg2, x, arg4);
 }
 
-void test__strcoll__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strcoll(NULL, arg2);
+void test__mbrtowc__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrtowc(arg1, arg2, arg3, x);
 }
 
-void test__strcoll__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strcoll(x, arg2);
+void test__std__mbrtowc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::mbrtowc(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strcoll__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strcoll(arg1, NULL);
+void test__std__mbrtowc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbrtowc(arg1, x, arg3, arg4);
 }
 
-void test__strcoll__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strcoll(arg1, x);
+void test__std__mbrtowc__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbrtowc(arg1, arg2, x, arg4);
 }
 
-void test__std__strcoll__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::strcoll(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__mbrtowc__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbrtowc(arg1, arg2, arg3, x);
 }
 
-void test__std__strcoll__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::strcoll(arg1, arg2);
+void test__wcstok__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcstok(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strcoll__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strcoll(NULL, arg2);
+void test__wcstok__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcstok(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__strcoll__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strcoll(x, arg2);
+void test__wcstok__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcstok(x, arg2, arg3);
 }
 
-void test__std__strcoll__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strcoll(arg1, NULL);
+void test__wcstok__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstok(arg1, NULL, arg3);
 }
 
-void test__std__strcoll__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strcoll(arg1, x);
+void test__wcstok__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcstok(arg1, x, arg3);
 }
 
-void test__wcscoll__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcscoll(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcstok__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstok(arg1, arg2, NULL);
 }
 
-void test__wcscoll__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcscoll(arg1, arg2);
+void test__std__wcstok__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wcstok(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcscoll__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcscoll(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__wcstok__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcstok(x, arg2, arg3);
 }
 
-void test__wcscoll__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcscoll(NULL, arg2);
+void test__std__wcstok__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcstok(arg1, NULL, arg3);
 }
 
-void test__wcscoll__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcscoll(x, arg2);
+void test__std__wcstok__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcstok(arg1, x, arg3);
 }
 
-void test__wcscoll__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcscoll(arg1, NULL);
+void test__std__wcstok__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcstok(arg1, arg2, NULL);
 }
 
-void test__wcscoll__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcscoll(arg1, x);
+void test__wcstoimax__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcstoimax(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcscoll__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wcscoll(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcstoimax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcstoimax(arg1, arg2, arg3);
 }
 
-void test__std__wcscoll__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wcscoll(arg1, arg2);
+void test__wcstoimax__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcstoimax(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wcscoll__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcscoll(NULL, arg2);
+void test__wcstoimax__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcstoimax(NULL, arg2, arg3);
 }
 
-void test__std__wcscoll__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcscoll(x, arg2);
+void test__wcstoimax__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcstoimax(x, arg2, arg3);
 }
 
-void test__std__wcscoll__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcscoll(arg1, NULL);
+void test__wcstoimax__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcstoimax(arg1, arg2, x);
 }
 
-void test__std__wcscoll__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcscoll(arg1, x);
+void test__std__wcstoimax__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wcstoimax(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strrchr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strrchr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcstoimax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcstoimax(arg1, arg2, arg3);
 }
 
-void test__strrchr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strrchr(arg1, arg2);
+void test__std__wcstoimax__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcstoimax(NULL, arg2, arg3);
 }
 
-void test__strrchr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = strrchr(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__wcstoimax__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcstoimax(x, arg2, arg3);
 }
 
-void test__strrchr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strrchr(NULL, arg2);
+void test__std__wcstoimax__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wcstoimax(arg1, arg2, x);
 }
 
-void test__strrchr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strrchr(x, arg2);
+void test__wcstoumax__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcstoumax(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strrchr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = strrchr(arg1, x);
+void test__wcstoumax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcstoumax(arg1, arg2, arg3);
 }
 
-void test__std__strrchr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::strrchr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcstoumax__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcstoumax(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__strrchr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::strrchr(arg1, arg2);
+void test__wcstoumax__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcstoumax(NULL, arg2, arg3);
 }
 
-void test__std__strrchr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::strrchr(NULL, arg2);
+void test__wcstoumax__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcstoumax(x, arg2, arg3);
 }
 
-void test__std__strrchr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::strrchr(x, arg2);
+void test__wcstoumax__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcstoumax(arg1, arg2, x);
 }
 
-void test__std__strrchr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::strrchr(arg1, x);
+void test__std__wcstoumax__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wcstoumax(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsrchr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcsrchr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcstoumax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcstoumax(arg1, arg2, arg3);
 }
 
-void test__wcsrchr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcsrchr(arg1, arg2);
+void test__std__wcstoumax__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcstoumax(NULL, arg2, arg3);
 }
 
-void test__wcsrchr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcsrchr(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__wcstoumax__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcstoumax(x, arg2, arg3);
 }
 
-void test__wcsrchr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcsrchr(NULL, arg2);
+void test__std__wcstoumax__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wcstoumax(arg1, arg2, x);
 }
 
-void test__wcsrchr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcsrchr(x, arg2);
+void test__wcstol__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcstol(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsrchr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wcsrchr(arg1, x);
+void test__wcstol__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcstol(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wcsrchr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wcsrchr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcstol__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstol(NULL, arg2, arg3);
 }
 
-void test__std__wcsrchr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wcsrchr(arg1, arg2);
+void test__wcstol__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcstol(x, arg2, arg3);
 }
 
-void test__std__wcsrchr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcsrchr(NULL, arg2);
+void test__wcstol__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcstol(arg1, arg2, x);
 }
 
-void test__std__wcsrchr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcsrchr(x, arg2);
+void test__std__wcstol__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wcstol(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsrchr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wcsrchr(arg1, x);
+void test__std__wcstol__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcstol(NULL, arg2, arg3);
 }
 
-void test__wcsrtombs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcsrtombs(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcstol__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcstol(x, arg2, arg3);
 }
 
-void test__wcsrtombs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcsrtombs(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__std__wcstol__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcstol(arg1, arg2, x);
 }
 
-void test__wcsrtombs__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcsrtombs(arg1, NULL, arg3, arg4);
+void test__wcstoll__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcstoll(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsrtombs__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcsrtombs(arg1, x, arg3, arg4);
+void test__wcstoll__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcstoll(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__wcsrtombs__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wcsrtombs(arg1, arg2, x, arg4);
+void test__wcstoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstoll(NULL, arg2, arg3);
 }
 
-void test__wcsrtombs__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcsrtombs(arg1, arg2, arg3, NULL);
+void test__wcstoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcstoll(x, arg2, arg3);
 }
 
-void test__std__wcsrtombs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wcsrtombs(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcstoll__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcstoll(arg1, arg2, x);
 }
 
-void test__std__wcsrtombs__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcsrtombs(arg1, NULL, arg3, arg4);
+void test__std__wcstoll__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wcstoll(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcsrtombs__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wcsrtombs(arg1, x, arg3, arg4);
+void test__std__wcstoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcstoll(NULL, arg2, arg3);
 }
 
-void test__std__wcsrtombs__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wcsrtombs(arg1, arg2, x, arg4);
+void test__std__wcstoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcstoll(x, arg2, arg3);
 }
 
-void test__std__wcsrtombs__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcsrtombs(arg1, arg2, arg3, NULL);
+void test__std__wcstoll__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcstoll(arg1, arg2, x);
 }
 
-void test__strtok__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strtok(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcstoul__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcstoul(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strtok__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((strtok(arg1, arg2) > 10) || (strtok(arg1, arg2) < 100)) {}
+void test__wcstoul__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcstoul(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__strtok__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strtok(p, arg2);
-    // cppcheck-suppress memleak
+void test__wcstoul__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstoul(NULL, arg2, arg3);
 }
 
-void test__strtok__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strtok(x, arg2);
+void test__wcstoul__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcstoul(x, arg2, arg3);
 }
 
-void test__strtok__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strtok(arg1, NULL);
+void test__wcstoul__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcstoul(arg1, arg2, x);
 }
 
-void test__strtok__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strtok(arg1, x);
+void test__std__wcstoul__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wcstoul(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strtok__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strtok(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcstoul__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcstoul(NULL, arg2, arg3);
 }
 
-void test__std__strtok__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((std::strtok(arg1, arg2) > 10) || (std::strtok(arg1, arg2) < 100)) {}
+void test__std__wcstoul__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcstoul(x, arg2, arg3);
 }
 
-void test__std__strtok__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::strtok(x, arg2);
+void test__std__wcstoul__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcstoul(arg1, arg2, x);
 }
 
-void test__std__strtok__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strtok(arg1, NULL);
+void test__wcstoull__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcstoull(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strtok__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strtok(arg1, x);
+void test__wcstoull__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcstoull(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__strtof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strtof(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcstoull__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstoull(NULL, arg2, arg3);
 }
 
-void test__strtof__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strtof(p, arg2);
-    // cppcheck-suppress memleak
+void test__wcstoull__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcstoull(x, arg2, arg3);
 }
 
-void test__strtof__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strtof(NULL, arg2);
+void test__wcstoull__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcstoull(arg1, arg2, x);
 }
 
-void test__strtof__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strtof(x, arg2);
+void test__std__wcstoull__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wcstoull(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strtof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strtof(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wcstoull__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcstoull(NULL, arg2, arg3);
 }
 
-void test__std__strtof__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strtof(NULL, arg2);
+void test__std__wcstoull__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcstoull(x, arg2, arg3);
 }
 
-void test__std__strtof__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strtof(x, arg2);
+void test__std__wcstoull__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcstoull(arg1, arg2, x);
 }
 
-void test__strtod__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strtod(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wprintf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strtod__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strtod(p, arg2);
-    // cppcheck-suppress memleak
+void test__wprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  wprintf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__strtod__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strtod(NULL, arg2);
+void test__wprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wprintf(NULL);
 }
 
-void test__strtod__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strtod(x, arg2);
+void test__std__wprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wprintf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strtod__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strtod(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wprintf(NULL);
 }
 
-void test__std__strtod__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strtod(NULL, arg2);
+void test__sprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sprintf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strtod__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strtod(x, arg2);
+void test__sprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  sprintf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__strtold__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strtold(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sprintf(x, arg2);
 }
 
-void test__strtold__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strtold(p, arg2);
-    // cppcheck-suppress memleak
+void test__sprintf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  sprintf(arg1, NULL);
 }
 
-void test__strtold__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strtold(NULL, arg2);
+void test__sprintf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  sprintf(arg1, x);
 }
 
-void test__strtold__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strtold(x, arg2);
+void test__std__sprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::sprintf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strtold__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strtold(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__sprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::sprintf(x, arg2);
 }
 
-void test__std__strtold__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strtold(NULL, arg2);
+void test__std__sprintf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::sprintf(arg1, NULL);
 }
 
-void test__std__strtold__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strtold(x, arg2);
+void test__std__sprintf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::sprintf(arg1, x);
 }
 
-void test__strtol__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strtol(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__swprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; swprintf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strtol__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strtol(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__swprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  swprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__strtol__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strtol(NULL, arg2, arg3);
+void test__swprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  swprintf(x, arg2, arg3);
 }
 
-void test__strtol__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strtol(x, arg2, arg3);
+void test__swprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  swprintf(arg1, x, arg3);
 }
 
-void test__strtol__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strtol(arg1, arg2, x);
+void test__swprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  swprintf(arg1, arg2, NULL);
 }
 
-void test__std__strtol__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strtol(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__swprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  swprintf(arg1, arg2, x);
 }
 
-void test__std__strtol__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strtol(NULL, arg2, arg3);
+void test__std__swprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::swprintf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strtol__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strtol(x, arg2, arg3);
+void test__std__swprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::swprintf(x, arg2, arg3);
 }
 
-void test__std__strtol__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::strtol(arg1, arg2, x);
+void test__std__swprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::swprintf(arg1, x, arg3);
 }
 
-void test__strtoul__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strtoul(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__swprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::swprintf(arg1, arg2, NULL);
 }
 
-void test__strtoul__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strtoul(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__swprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::swprintf(arg1, arg2, x);
 }
 
-void test__strtoul__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strtoul(NULL, arg2, arg3);
+void test__vsprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vsprintf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strtoul__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strtoul(x, arg2, arg3);
+void test__vsprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  vsprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__strtoul__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strtoul(arg1, arg2, x);
+void test__vsprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vsprintf(NULL, arg2, arg3);
 }
 
-void test__std__strtoul__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strtoul(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__vsprintf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  vsprintf(arg1, NULL, arg3);
 }
 
-void test__std__strtoul__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strtoul(NULL, arg2, arg3);
+void test__vsprintf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vsprintf(arg1, x, arg3);
 }
 
-void test__std__strtoul__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strtoul(x, arg2, arg3);
+void test__std__vsprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vsprintf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strtoul__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::strtoul(arg1, arg2, x);
+void test__std__vsprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vsprintf(NULL, arg2, arg3);
 }
 
-void test__strtoll__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strtoll(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vsprintf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vsprintf(arg1, NULL, arg3);
 }
 
-void test__strtoll__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strtoll(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__vsprintf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vsprintf(arg1, x, arg3);
 }
 
-void test__strtoll__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strtoll(NULL, arg2, arg3);
+void test__vswprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vswprintf(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strtoll__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strtoll(x, arg2, arg3);
+void test__vswprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  vswprintf(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__strtoll__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strtoll(arg1, arg2, x);
+void test__vswprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vswprintf(NULL, arg2, arg3, arg4);
 }
 
-void test__std__strtoll__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strtoll(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__vswprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vswprintf(arg1, x, arg3, arg4);
 }
 
-void test__std__strtoll__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strtoll(NULL, arg2, arg3);
+void test__vswprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  vswprintf(arg1, arg2, NULL, arg4);
 }
 
-void test__std__strtoll__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strtoll(x, arg2, arg3);
+void test__vswprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vswprintf(arg1, arg2, x, arg4);
 }
 
-void test__std__strtoll__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::strtoll(arg1, arg2, x);
+void test__std__vswprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vswprintf(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strtoull__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strtoull(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vswprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vswprintf(NULL, arg2, arg3, arg4);
 }
 
-void test__strtoull__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strtoull(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__vswprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vswprintf(arg1, x, arg3, arg4);
 }
 
-void test__strtoull__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strtoull(NULL, arg2, arg3);
+void test__std__vswprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vswprintf(arg1, arg2, NULL, arg4);
 }
 
-void test__strtoull__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strtoull(x, arg2, arg3);
+void test__std__vswprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vswprintf(arg1, arg2, x, arg4);
 }
 
-void test__strtoull__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strtoull(arg1, arg2, x);
+void test__fwprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fwprintf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strtoull__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strtoull(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fwprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  fwprintf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__strtoull__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strtoull(NULL, arg2, arg3);
+void test__fwprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fwprintf(NULL, arg2);
 }
 
-void test__std__strtoull__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strtoull(x, arg2, arg3);
+void test__fwprintf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fwprintf(arg1, NULL);
 }
 
-void test__std__strtoull__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::strtoull(arg1, arg2, x);
+void test__fwprintf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fwprintf(arg1, x);
 }
 
-void test__strtoimax__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strtoimax(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fwprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fwprintf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strtoimax__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strtoimax(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__fwprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fwprintf(NULL, arg2);
 }
 
-void test__strtoimax__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strtoimax(NULL, arg2, arg3);
+void test__std__fwprintf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fwprintf(arg1, NULL);
 }
 
-void test__strtoimax__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strtoimax(x, arg2, arg3);
+void test__std__fwprintf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fwprintf(arg1, x);
 }
 
-void test__strtoimax__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strtoimax(arg1, arg2, x);
+void test__snprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; snprintf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__strtoimax__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strtoimax(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__snprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  snprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__strtoimax__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strtoimax(NULL, arg2, arg3);
+void test__snprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  snprintf(arg1, x, arg3);
 }
 
-void test__std__strtoimax__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strtoimax(x, arg2, arg3);
+void test__snprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  snprintf(arg1, arg2, NULL);
 }
 
-void test__std__strtoimax__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::strtoimax(arg1, arg2, x);
+void test__snprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  snprintf(arg1, arg2, x);
 }
 
-void test__strtoumax__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strtoumax(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__snprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::snprintf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strtoumax__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strtoumax(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__snprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::snprintf(arg1, x, arg3);
 }
 
-void test__strtoumax__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strtoumax(NULL, arg2, arg3);
-}
+void test__std__snprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::snprintf(arg1, arg2, NULL);
+}
 
-void test__strtoumax__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strtoumax(x, arg2, arg3);
-}
-
-void test__strtoumax__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strtoumax(arg1, arg2, x);
+void test__std__snprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::snprintf(arg1, arg2, x);
 }
 
-void test__std__strtoumax__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::strtoumax(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__strtoumax__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::strtoumax(NULL, arg2, arg3);
-}
-
-void test__std__strtoumax__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::strtoumax(x, arg2, arg3);
-}
-
-void test__std__strtoumax__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::strtoumax(arg1, arg2, x);
-}
-
-void test__time__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        time(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__time__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    time(p);
-    // cppcheck-suppress memleak
-}
-
-void test__time__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    time(x);
-}
-
-void test__std__time__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::time(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__time__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::time(x);
-}
-
-void test__tmpnam__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        tmpnam(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__tmpnam__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    tmpnam(p);
-    // cppcheck-suppress memleak
-}
-
-void test__tmpnam__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    tmpnam(x);
-}
-
-void test__std__tmpnam__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::tmpnam(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__tmpnam__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::tmpnam(x);
-}
-
-void test__tmpnam_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        tmpnam_s(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__tmpnam_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    tmpnam_s(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__tmpnam_s__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    tmpnam_s(x, arg2);
-}
-
-void test__tmpnam_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    tmpnam_s(arg1, x);
-}
-
-void test__tmpfile__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = tmpfile();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__tmpfile__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    tmpfile();
-}
-
-void test__tolower__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = tolower(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__tolower__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    tolower(arg1);
+void test__vsnprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vsnprintf(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__tolower__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = tolower(p);
-    // cppcheck-suppress memleak
+
+void test__vsnprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  vsnprintf(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
-
-void test__tolower__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = tolower(x);
+
+void test__vsnprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vsnprintf(x, arg2, arg3, arg4);
 }
-
-void test__std__tolower__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::tolower(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__vsnprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vsnprintf(arg1, x, arg3, arg4);
 }
-
-void test__std__tolower__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::tolower(arg1);
+
+void test__vsnprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  vsnprintf(arg1, arg2, NULL, arg4);
 }
 
-void test__std__tolower__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::tolower(x);
-}
-
-void test__toupper__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = toupper(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__vsnprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vsnprintf(arg1, arg2, x, arg4);
+}
 
-void test__toupper__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    toupper(arg1);
-}
-
-void test__toupper__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = toupper(p);
-    // cppcheck-suppress memleak
-}
-
-void test__toupper__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = toupper(x);
-}
-
-void test__std__toupper__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::toupper(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__toupper__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::toupper(arg1);
-}
-
-void test__std__toupper__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::toupper(x);
-}
-
-void test__typeid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = typeid(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__typeid__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    typeid(arg1);
-}
-
-void test__va_arg__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        va_arg(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__va_arg__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    va_arg(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__va_copy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        va_copy(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__va_copy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    va_copy(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__vsnprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vsnprintf(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__va_end__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        va_end(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__va_end__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    va_end(p);
-    // cppcheck-suppress memleak
-}
-
-void test__va_start__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        va_start(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__va_start__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    va_start(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__wcstof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcstof(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wcstof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcstof(arg1, arg2);
+
+void test__std__vsnprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vsnprintf(x, arg2, arg3, arg4);
 }
 
-void test__wcstof__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcstof(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__wcstof__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcstof(NULL, arg2);
+void test__std__vsnprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vsnprintf(arg1, x, arg3, arg4);
 }
 
-void test__wcstof__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcstof(x, arg2);
+void test__std__vsnprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vsnprintf(arg1, arg2, NULL, arg4);
 }
 
-void test__std__wcstof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wcstof(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vsnprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vsnprintf(arg1, arg2, x, arg4);
 }
 
-void test__std__wcstof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wcstof(arg1, arg2);
+void test__wscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wscanf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstof__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcstof(NULL, arg2);
+void test__wscanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  wscanf(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wcstof__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcstof(x, arg2);
+void test__wscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wscanf(NULL);
 }
 
-void test__wcstod__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcstod(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wscanf(x);
 }
 
-void test__wcstod__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcstod(arg1, arg2);
+void test__std__wscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wscanf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstod__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcstod(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__wscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wscanf(NULL);
 }
 
-void test__wcstod__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcstod(NULL, arg2);
+void test__std__wscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wscanf(x);
 }
 
-void test__wcstod__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcstod(x, arg2);
+void test__sscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sscanf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstod__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wcstod(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sscanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  sscanf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wcstod__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wcstod(arg1, arg2);
+void test__sscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sscanf(x, arg2);
 }
 
-void test__std__wcstod__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcstod(NULL, arg2);
+void test__sscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  sscanf(arg1, NULL);
 }
 
-void test__std__wcstod__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcstod(x, arg2);
+void test__sscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  sscanf(arg1, x);
 }
 
-void test__wcstold__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcstold(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__sscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::sscanf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstold__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcstold(arg1, arg2);
+void test__std__sscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::sscanf(x, arg2);
 }
 
-void test__wcstold__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcstold(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__sscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::sscanf(arg1, NULL);
 }
 
-void test__wcstold__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcstold(NULL, arg2);
+void test__std__sscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::sscanf(arg1, x);
 }
 
-void test__wcstold__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcstold(x, arg2);
+void test__fwscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fwscanf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstold__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wcstold(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fwscanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  fwscanf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__std__wcstold__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wcstold(arg1, arg2);
+void test__fwscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fwscanf(x, arg2);
 }
 
-void test__std__wcstold__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcstold(NULL, arg2);
+void test__fwscanf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fwscanf(arg1, x);
 }
 
-void test__std__wcstold__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcstold(x, arg2);
+void test__std__fwscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fwscanf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = stof(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fwscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fwscanf(x, arg2);
 }
 
-void test__stof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    stof(arg1, arg2);
+void test__std__fwscanf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fwscanf(arg1, x);
 }
 
-void test__stof__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = stof(p, arg2);
-    // cppcheck-suppress memleak
+void test__swscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; swscanf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stof__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stof(x, arg2);
+void test__swscanf__leakignore() {
+  char *p = malloc(10); *p=0;
+  swscanf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__stof__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stof(arg1, x);
+void test__swscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  swscanf(x, arg2);
 }
 
-void test__std__stof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::stof(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__swscanf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  swscanf(arg1, x);
 }
 
-void test__std__stof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::stof(arg1, arg2);
+void test__std__swscanf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::swscanf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__stof__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stof(x, arg2);
+void test__std__swscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::swscanf(x, arg2);
 }
 
-void test__std__stof__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stof(arg1, x);
+void test__std__swscanf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::swscanf(arg1, x);
 }
 
-void test__stod__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = stod(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__system__noreturn() {
+  int x = 1;
+  if (cond) { x=100; system(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stod__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    stod(arg1, arg2);
+void test__system__leakignore() {
+  char *p = malloc(10); *p=0;
+  system(p);
+  // cppcheck-suppress memleak
 }
 
-void test__stod__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = stod(p, arg2);
-    // cppcheck-suppress memleak
+void test__system__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  system(x);
 }
 
-void test__stod__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stod(x, arg2);
+void test__std__system__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::system(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stod__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stod(arg1, x);
+void test__std__system__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::system(x);
 }
 
-void test__std__stod__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::stod(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__setw__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setw(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__stod__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::stod(arg1, arg2);
+void test__setw__leakignore() {
+  char *p = malloc(10); *p=0;
+  setw(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__stod__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stod(x, arg2);
+void test__setw__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setw(x);
 }
 
-void test__std__stod__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stod(arg1, x);
+void test__std__setw__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::setw(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stold__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = stold(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__setw__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setw(x);
 }
 
-void test__stold__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    stold(arg1, arg2);
+void test__min__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = min(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stold__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = stold(p, arg2);
-    // cppcheck-suppress memleak
+void test__min__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  min(arg1, arg2);
 }
 
-void test__stold__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stold(x, arg2);
+void test__min__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = min(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__stold__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stold(arg1, x);
+void test__min__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = min(x, arg2);
 }
 
-void test__std__stold__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::stold(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__min__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = min(arg1, x);
 }
 
-void test__std__stold__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::stold(arg1, arg2);
+void test__std__min__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::min(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__stold__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stold(x, arg2);
+void test__std__min__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::min(arg1, arg2);
 }
 
-void test__std__stold__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stold(arg1, x);
+void test__std__min__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::min(x, arg2);
 }
 
-void test__stoi__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = stoi(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__min__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::min(arg1, x);
 }
 
-void test__stoi__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    stoi(arg1, arg2, arg3);
+void test__max__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = max(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stoi__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = stoi(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__max__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  max(arg1, arg2);
 }
 
-void test__stoi__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stoi(x, arg2, arg3);
+void test__max__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = max(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__stoi__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stoi(arg1, x, arg3);
+void test__max__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = max(x, arg2);
 }
 
-void test__stoi__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stoi(arg1, arg2, x);
+void test__max__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = max(arg1, x);
 }
 
-void test__std__stoi__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::stoi(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__max__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::max(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__stoi__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::stoi(arg1, arg2, arg3);
+void test__std__max__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::max(arg1, arg2);
 }
 
-void test__std__stoi__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stoi(x, arg2, arg3);
+void test__std__max__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::max(x, arg2);
 }
 
-void test__std__stoi__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stoi(arg1, x, arg3);
+void test__std__max__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::max(arg1, x);
 }
 
-void test__std__stoi__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stoi(arg1, arg2, x);
+void test__setiosflags__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setiosflags(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stol__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = stol(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__setiosflags__leakignore() {
+  char *p = malloc(10); *p=0;
+  setiosflags(p);
+  // cppcheck-suppress memleak
 }
 
-void test__stol__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    stol(arg1, arg2, arg3);
+void test__setiosflags__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setiosflags(x);
 }
 
-void test__stol__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = stol(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__setiosflags__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::setiosflags(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stol__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stol(x, arg2, arg3);
+void test__std__setiosflags__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setiosflags(x);
 }
 
-void test__stol__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stol(arg1, x, arg3);
+void test__resetiosflags__noreturn() {
+  int x = 1;
+  if (cond) { x=100; resetiosflags(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stol__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stol(arg1, arg2, x);
+void test__resetiosflags__leakignore() {
+  char *p = malloc(10); *p=0;
+  resetiosflags(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__stol__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::stol(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__resetiosflags__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  resetiosflags(x);
 }
 
-void test__std__stol__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::stol(arg1, arg2, arg3);
+void test__std__resetiosflags__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::resetiosflags(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__stol__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stol(x, arg2, arg3);
+void test__std__resetiosflags__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::resetiosflags(x);
 }
 
-void test__std__stol__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stol(arg1, x, arg3);
+void test__setfill__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setfill(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__stol__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stol(arg1, arg2, x);
+void test__setfill__leakignore() {
+  char *p = malloc(10); *p=0;
+  setfill(p);
+  // cppcheck-suppress memleak
 }
 
-void test__stoll__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = stoll(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__setfill__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setfill(x);
 }
 
-void test__stoll__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    stoll(arg1, arg2, arg3);
+void test__std__setfill__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::setfill(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stoll__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = stoll(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__setfill__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setfill(x);
 }
 
-void test__stoll__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stoll(x, arg2, arg3);
+void test__setprecision__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setprecision(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stoll__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stoll(arg1, x, arg3);
+void test__setprecision__leakignore() {
+  char *p = malloc(10); *p=0;
+  setprecision(p);
+  // cppcheck-suppress memleak
 }
 
-void test__stoll__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stoll(arg1, arg2, x);
+void test__setprecision__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setprecision(x);
 }
 
-void test__std__stoll__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::stoll(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__setprecision__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::setprecision(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__stoll__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::stoll(arg1, arg2, arg3);
+void test__std__setprecision__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setprecision(x);
 }
 
-void test__std__stoll__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stoll(x, arg2, arg3);
+void test__setbase__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setbase(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__stoll__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stoll(arg1, x, arg3);
+void test__setbase__leakignore() {
+  char *p = malloc(10); *p=0;
+  setbase(p);
+  // cppcheck-suppress memleak
 }
 
-void test__std__stoll__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stoll(arg1, arg2, x);
+void test__setbase__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setbase(x);
 }
 
-void test__stoul__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = stoul(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__setbase__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::setbase(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stoul__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    stoul(arg1, arg2, arg3);
+void test__std__setbase__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setbase(x);
 }
 
-void test__stoul__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = stoul(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__zonetime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = zonetime(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stoul__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stoul(x, arg2, arg3);
+void test__zonetime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  zonetime(arg1, arg2);
 }
 
-void test__stoul__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stoul(arg1, x, arg3);
+void test__zonetime__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = zonetime(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__stoul__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stoul(arg1, arg2, x);
+void test__zonetime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = zonetime(NULL, arg2);
 }
 
-void test__std__stoul__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::stoul(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__zonetime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = zonetime(x, arg2);
 }
 
-void test__std__stoul__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::stoul(arg1, arg2, arg3);
+void test__zonetime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = zonetime(arg1, x);
 }
 
-void test__std__stoul__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stoul(x, arg2, arg3);
+void test__c16rtomb__noreturn() {
+  int x = 1;
+  if (cond) { x=100; c16rtomb(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__stoul__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stoul(arg1, x, arg3);
+void test__c16rtomb__leakignore() {
+  char *p = malloc(10); *p=0;
+  c16rtomb(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__stoul__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stoul(arg1, arg2, x);
+void test__c16rtomb__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  c16rtomb(arg1, x, arg3);
 }
 
-void test__stoull__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = stoull(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__c16rtomb__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  c16rtomb(arg1, arg2, NULL);
 }
 
-void test__stoull__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    stoull(arg1, arg2, arg3);
+void test__c16rtomb__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  c16rtomb(arg1, arg2, x);
 }
 
-void test__stoull__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = stoull(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__c32rtomb__noreturn() {
+  int x = 1;
+  if (cond) { x=100; c32rtomb(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stoull__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stoull(x, arg2, arg3);
+void test__c32rtomb__leakignore() {
+  char *p = malloc(10); *p=0;
+  c32rtomb(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__stoull__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stoull(arg1, x, arg3);
+void test__c32rtomb__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  c32rtomb(arg1, x, arg3);
 }
 
-void test__stoull__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = stoull(arg1, arg2, x);
+void test__c32rtomb__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  c32rtomb(arg1, arg2, NULL);
 }
 
-void test__std__stoull__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::stoull(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__c32rtomb__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  c32rtomb(arg1, arg2, x);
 }
 
-void test__std__stoull__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::stoull(arg1, arg2, arg3);
+void test__mbrtoc16__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mbrtoc16(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__stoull__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stoull(x, arg2, arg3);
+void test__mbrtoc16__leakignore() {
+  char *p = malloc(10); *p=0;
+  mbrtoc16(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__std__stoull__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stoull(arg1, x, arg3);
+void test__mbrtoc16__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrtoc16(arg1, x, arg3, arg4);
 }
 
-void test__std__stoull__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::stoull(arg1, arg2, x);
+void test__mbrtoc16__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrtoc16(arg1, arg2, x, arg4);
 }
 
-void test__std__to_string__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::to_string(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mbrtoc16__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  mbrtoc16(arg1, arg2, arg3, NULL);
 }
 
-void test__std__to_string__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::to_string(arg1);
+void test__mbrtoc16__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mbrtoc16(arg1, arg2, arg3, x);
 }
 
-void test__std__to_string__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::to_string(x);
+void test__mbrtoc32__noreturn() {
+  int x = 1;
+  if (cond) { x=100; mbrtoc32(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__string__resize__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::string::resize(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mbrtoc32__leakignore() {
+  char *p = malloc(10); *p=0;
+  mbrtoc32(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__std__string__resize__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::string::resize(x, arg2);
+void test__mbrtoc32__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrtoc32(arg1, x, arg3, arg4);
 }
 
-void test__std__string__resize__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::string::resize(arg1, x);
+void test__mbrtoc32__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrtoc32(arg1, arg2, x, arg4);
 }
 
-void test__std__wstring__resize__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wstring::resize(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__mbrtoc32__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  mbrtoc32(arg1, arg2, arg3, NULL);
 }
 
-void test__std__wstring__resize__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wstring::resize(x, arg2);
+void test__mbrtoc32__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mbrtoc32(arg1, arg2, arg3, x);
 }
 
-void test__std__wstring__resize__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wstring::resize(arg1, x);
+void test__std__swap__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::swap(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__to_wstring__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::to_wstring(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__swap__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::swap(x, arg2);
 }
 
-void test__std__to_wstring__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::to_wstring(arg1);
+void test__std__swap__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::swap(arg1, x);
 }
 
-void test__std__to_wstring__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::to_wstring(x);
+void test__std__ostringstream__str__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ostringstream::str(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbrtowc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mbrtowc(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ostringstream__str__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ostringstream::str();
 }
 
-void test__mbrtowc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mbrtowc(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__std__ios__good__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ios::good(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbrtowc__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mbrtowc(arg1, x, arg3, arg4);
+void test__std__ios__good__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ios::good();
 }
-
-void test__mbrtowc__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mbrtowc(arg1, arg2, x, arg4);
+
+void test__std__ios_base__good__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ios_base::good(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbrtowc__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mbrtowc(arg1, arg2, arg3, x);
+void test__std__ios_base__good__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ios_base::good();
 }
 
-void test__std__mbrtowc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::mbrtowc(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ostream__good__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ostream::good(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__mbrtowc__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::mbrtowc(arg1, x, arg3, arg4);
+void test__std__ostream__good__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ostream::good();
 }
 
-void test__std__mbrtowc__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::mbrtowc(arg1, arg2, x, arg4);
+void test__std__ofstream__good__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ofstream::good(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__mbrtowc__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::mbrtowc(arg1, arg2, arg3, x);
+void test__std__ofstream__good__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ofstream::good();
 }
 
-void test__wcstok__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcstok(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ostringstream__good__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ostringstream::good(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstok__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcstok(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__ostringstream__good__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ostringstream::good();
 }
 
-void test__wcstok__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wcstok(x, arg2, arg3);
+void test__std__ios__eof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ios::eof(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstok__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcstok(arg1, NULL, arg3);
+void test__std__ios__eof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ios::eof();
 }
 
-void test__wcstok__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcstok(arg1, x, arg3);
+void test__std__ios_base__eof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ios_base::eof(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstok__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcstok(arg1, arg2, NULL);
+void test__std__ios_base__eof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ios_base::eof();
 }
 
-void test__std__wcstok__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wcstok(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ostream__eof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ostream::eof(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstok__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wcstok(x, arg2, arg3);
+void test__std__ostream__eof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ostream::eof();
 }
 
-void test__std__wcstok__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcstok(arg1, NULL, arg3);
+void test__std__ofstream__eof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ofstream::eof(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstok__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wcstok(arg1, x, arg3);
+void test__std__ofstream__eof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ofstream::eof();
 }
 
-void test__std__wcstok__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcstok(arg1, arg2, NULL);
+void test__std__ostringstream__eof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ostringstream::eof(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoimax__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcstoimax(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ostringstream__eof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ostringstream::eof();
 }
 
-void test__wcstoimax__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcstoimax(arg1, arg2, arg3);
+void test__std__ios__fail__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ios::fail(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoimax__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcstoimax(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__ios__fail__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ios::fail();
 }
 
-void test__wcstoimax__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcstoimax(NULL, arg2, arg3);
+void test__std__ios_base__fail__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ios_base::fail(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoimax__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcstoimax(x, arg2, arg3);
+void test__std__ios_base__fail__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ios_base::fail();
 }
 
-void test__wcstoimax__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wcstoimax(arg1, arg2, x);
+void test__std__ostream__fail__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ostream::fail(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstoimax__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wcstoimax(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ostream__fail__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ostream::fail();
 }
 
-void test__std__wcstoimax__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wcstoimax(arg1, arg2, arg3);
+void test__std__ofstream__fail__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ofstream::fail(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstoimax__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcstoimax(NULL, arg2, arg3);
+void test__std__ofstream__fail__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ofstream::fail();
 }
 
-void test__std__wcstoimax__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcstoimax(x, arg2, arg3);
+void test__std__ostringstream__fail__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ostringstream::fail(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstoimax__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wcstoimax(arg1, arg2, x);
+void test__std__ostringstream__fail__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ostringstream::fail();
 }
 
-void test__wcstoumax__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcstoumax(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ios__bad__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ios::bad(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoumax__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcstoumax(arg1, arg2, arg3);
+void test__std__ios__bad__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ios::bad();
 }
 
-void test__wcstoumax__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcstoumax(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__ios_base__bad__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ios_base::bad(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoumax__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcstoumax(NULL, arg2, arg3);
+void test__std__ios_base__bad__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ios_base::bad();
 }
 
-void test__wcstoumax__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcstoumax(x, arg2, arg3);
+void test__std__ostream__bad__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ostream::bad(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoumax__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wcstoumax(arg1, arg2, x);
+void test__std__ostream__bad__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ostream::bad();
 }
 
-void test__std__wcstoumax__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wcstoumax(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ofstream__bad__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ofstream::bad(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstoumax__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wcstoumax(arg1, arg2, arg3);
+void test__std__ofstream__bad__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ofstream::bad();
 }
 
-void test__std__wcstoumax__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wcstoumax(NULL, arg2, arg3);
+void test__std__ostringstream__bad__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::ostringstream::bad(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstoumax__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wcstoumax(x, arg2, arg3);
+void test__std__ostringstream__bad__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ostringstream::bad();
 }
 
-void test__std__wcstoumax__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wcstoumax(arg1, arg2, x);
+void test__std__array__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::array::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstol__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcstol(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__deque__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::deque::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstol__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcstol(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__list__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::list::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstol__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcstol(NULL, arg2, arg3);
+void test__std__forward_list__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::forward_list::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstol__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcstol(x, arg2, arg3);
+void test__std__map__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::map::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstol__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wcstol(arg1, arg2, x);
+void test__std__unordered_map__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::unordered_map::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstol__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wcstol(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__queue__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::queue::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstol__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcstol(NULL, arg2, arg3);
+void test__std__set__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::set::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstol__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wcstol(x, arg2, arg3);
+void test__std__unordered_set__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::unordered_set::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstol__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wcstol(arg1, arg2, x);
+void test__std__stack__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::stack::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoll__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcstoll(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__string__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::string::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoll__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcstoll(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__wstring__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wstring::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoll__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcstoll(NULL, arg2, arg3);
+void test__std__basic_string__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::basic_string::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoll__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcstoll(x, arg2, arg3);
+void test__std__vector__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vector::clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoll__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wcstoll(arg1, arg2, x);
+void test__std__array__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::array::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstoll__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wcstoll(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__array__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::array::empty();
 }
 
-void test__std__wcstoll__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcstoll(NULL, arg2, arg3);
+void test__std__deque__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::deque::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstoll__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wcstoll(x, arg2, arg3);
+void test__std__deque__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::deque::empty();
 }
 
-void test__std__wcstoll__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wcstoll(arg1, arg2, x);
+void test__std__list__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::list::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoul__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcstoul(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__list__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::list::empty();
 }
 
-void test__wcstoul__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcstoul(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__forward_list__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::forward_list::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoul__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcstoul(NULL, arg2, arg3);
+void test__std__forward_list__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::forward_list::empty();
 }
 
-void test__wcstoul__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcstoul(x, arg2, arg3);
+void test__std__map__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::map::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoul__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wcstoul(arg1, arg2, x);
+void test__std__map__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::map::empty();
 }
 
-void test__std__wcstoul__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wcstoul(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__unordered_map__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::unordered_map::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstoul__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcstoul(NULL, arg2, arg3);
+void test__std__unordered_map__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::unordered_map::empty();
 }
 
-void test__std__wcstoul__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wcstoul(x, arg2, arg3);
+void test__std__queue__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::queue::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstoul__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wcstoul(arg1, arg2, x);
+void test__std__queue__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::queue::empty();
 }
 
-void test__wcstoull__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcstoull(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__set__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::set::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoull__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcstoull(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__set__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::set::empty();
 }
 
-void test__wcstoull__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcstoull(NULL, arg2, arg3);
+void test__std__unordered_set__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::unordered_set::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstoull__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcstoull(x, arg2, arg3);
+void test__std__unordered_set__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::unordered_set::empty();
 }
 
-void test__wcstoull__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wcstoull(arg1, arg2, x);
+void test__std__stack__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::stack::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstoull__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wcstoull(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__stack__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stack::empty();
 }
 
-void test__std__wcstoull__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wcstoull(NULL, arg2, arg3);
+void test__std__string__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::string::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wcstoull__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wcstoull(x, arg2, arg3);
+void test__std__string__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::empty();
 }
 
-void test__std__wcstoull__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wcstoull(arg1, arg2, x);
+void test__std__wstring__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wstring::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wprintf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wstring__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::empty();
 }
 
-void test__wprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wprintf(p);
-    // cppcheck-suppress memleak
+void test__std__basic_string__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::basic_string::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wprintf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wprintf(NULL);
+void test__std__basic_string__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::empty();
 }
 
-void test__std__wprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wprintf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vector__empty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::vector::empty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wprintf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wprintf(NULL);
+void test__std__vector__empty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::vector::empty();
 }
 
-void test__sprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sprintf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__deque__push_back__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::deque::push_back(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sprintf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__deque__push_back__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::deque::push_back(x);
 }
 
-void test__sprintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sprintf(x, arg2);
+void test__std__deque__push_front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::deque::push_front(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sprintf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    sprintf(arg1, NULL);
+void test__std__deque__push_front__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::deque::push_front(x);
 }
 
-void test__sprintf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    sprintf(arg1, x);
+void test__std__list__push_back__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::list::push_back(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__sprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::sprintf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__list__push_back__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::list::push_back(x);
 }
 
-void test__std__sprintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::sprintf(x, arg2);
+void test__std__list__push_front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::list::push_front(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__sprintf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::sprintf(arg1, NULL);
+void test__std__list__push_front__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::list::push_front(x);
 }
 
-void test__std__sprintf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::sprintf(arg1, x);
+void test__std__forward_list__push_front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::forward_list::push_front(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__swprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        swprintf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__forward_list__push_front__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::forward_list::push_front(x);
 }
 
-void test__swprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    swprintf(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__queue__push__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::queue::push(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__swprintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    swprintf(x, arg2, arg3);
+void test__std__queue__push__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::queue::push(x);
 }
 
-void test__swprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    swprintf(arg1, x, arg3);
+void test__std__stack__push__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::stack::push(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__swprintf__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    swprintf(arg1, arg2, NULL);
+void test__std__stack__push__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::stack::push(x);
 }
 
-void test__swprintf__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    swprintf(arg1, arg2, x);
+void test__std__vector__push_back__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vector::push_back(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__swprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::swprintf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vector__push_back__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vector::push_back(x);
 }
 
-void test__std__swprintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::swprintf(x, arg2, arg3);
+void test__std__vector__push_front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vector::push_front(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__swprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::swprintf(arg1, x, arg3);
+void test__std__vector__push_front__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vector::push_front(x);
 }
 
-void test__std__swprintf__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::swprintf(arg1, arg2, NULL);
+void test__std__list__insert__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::list::insert(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__swprintf__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::swprintf(arg1, arg2, x);
+void test__std__list__insert__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::list::insert(x);
 }
 
-void test__vsprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vsprintf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__multimap__insert__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::multimap::insert(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vsprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vsprintf(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__multimap__insert__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::multimap::insert(x);
 }
 
-void test__vsprintf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vsprintf(NULL, arg2, arg3);
+void test__std__set__insert__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::set::insert(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vsprintf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vsprintf(arg1, NULL, arg3);
+void test__std__set__insert__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::set::insert(x);
 }
 
-void test__vsprintf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    vsprintf(arg1, x, arg3);
+void test__std__string__insert__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::string::insert(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vsprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vsprintf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__string__insert__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::string::insert(x);
 }
 
-void test__std__vsprintf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::vsprintf(NULL, arg2, arg3);
+void test__std__vector__insert__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vector::insert(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vsprintf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::vsprintf(arg1, NULL, arg3);
+void test__std__vector__insert__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vector::insert(x);
 }
 
-void test__std__vsprintf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::vsprintf(arg1, x, arg3);
+void test__std__deque__emplace_back__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::deque::emplace_back(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vswprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vswprintf(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__deque__emplace_front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::deque::emplace_front(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vswprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vswprintf(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__std__list__emplace_back__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::list::emplace_back(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vswprintf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vswprintf(NULL, arg2, arg3, arg4);
+void test__std__list__emplace_front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::list::emplace_front(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vswprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    vswprintf(arg1, x, arg3, arg4);
+void test__std__forward_list__emplace_front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::forward_list::emplace_front(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vswprintf__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vswprintf(arg1, arg2, NULL, arg4);
+void test__std__queue__emplace__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::queue::emplace(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vswprintf__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    vswprintf(arg1, arg2, x, arg4);
+void test__std__stack__emplace__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::stack::emplace(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vswprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vswprintf(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vector__emplace_back__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vector::emplace_back(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vswprintf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::vswprintf(NULL, arg2, arg3, arg4);
+void test__std__vector__emplace_front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vector::emplace_front(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vswprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::vswprintf(arg1, x, arg3, arg4);
+void test__std__list__find__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::list::find(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vswprintf__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::vswprintf(arg1, arg2, NULL, arg4);
+void test__std__list__find__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::list::find(arg1);
 }
 
-void test__std__vswprintf__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::vswprintf(arg1, arg2, x, arg4);
+void test__std__list__find__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::list::find(x);
 }
 
-void test__fwprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fwprintf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__map__find__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::map::find(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fwprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fwprintf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__map__find__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::map::find(arg1);
 }
 
-void test__fwprintf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fwprintf(NULL, arg2);
+void test__std__map__find__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::map::find(x);
 }
 
-void test__fwprintf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fwprintf(arg1, NULL);
+void test__std__set__find__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::set::find(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fwprintf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fwprintf(arg1, x);
+void test__std__set__find__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::set::find(arg1);
 }
 
-void test__std__fwprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fwprintf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__set__find__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::set::find(x);
 }
 
-void test__std__fwprintf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fwprintf(NULL, arg2);
+void test__std__vector__find__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::vector::find(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fwprintf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::fwprintf(arg1, NULL);
+void test__std__vector__find__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::vector::find(arg1);
 }
 
-void test__std__fwprintf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::fwprintf(arg1, x);
+void test__std__vector__find__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::vector::find(x);
 }
 
-void test__snprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        snprintf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__deque__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::deque::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__snprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    snprintf(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__deque__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::deque::size();
 }
 
-void test__snprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    snprintf(arg1, x, arg3);
+void test__std__deque__max_size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::deque::max_size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__snprintf__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    snprintf(arg1, arg2, NULL);
+void test__std__deque__max_size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::deque::max_size();
 }
 
-void test__snprintf__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    snprintf(arg1, arg2, x);
+void test__std__list__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::list::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__snprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::snprintf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__list__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::list::size();
 }
 
-void test__std__snprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::snprintf(arg1, x, arg3);
+void test__std__list__max_size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::list::max_size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__snprintf__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::snprintf(arg1, arg2, NULL);
+void test__std__list__max_size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::list::max_size();
 }
 
-void test__std__snprintf__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::snprintf(arg1, arg2, x);
+void test__std__map__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::map::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vsnprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vsnprintf(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__map__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::map::size();
 }
 
-void test__vsnprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vsnprintf(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__std__map__max_size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::map::max_size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vsnprintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    vsnprintf(x, arg2, arg3, arg4);
+void test__std__map__max_size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::map::max_size();
 }
 
-void test__vsnprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    vsnprintf(arg1, x, arg3, arg4);
+void test__std__unordered_map__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::unordered_map::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vsnprintf__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vsnprintf(arg1, arg2, NULL, arg4);
+void test__std__unordered_map__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::unordered_map::size();
 }
 
-void test__vsnprintf__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    vsnprintf(arg1, arg2, x, arg4);
+void test__std__unordered_map__max_size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::unordered_map::max_size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vsnprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vsnprintf(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__unordered_map__max_size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::unordered_map::max_size();
 }
 
-void test__std__vsnprintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::vsnprintf(x, arg2, arg3, arg4);
+void test__std__queue__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::queue::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vsnprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::vsnprintf(arg1, x, arg3, arg4);
+void test__std__queue__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::queue::size();
 }
 
-void test__std__vsnprintf__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::vsnprintf(arg1, arg2, NULL, arg4);
+void test__std__set__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::set::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__vsnprintf__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::vsnprintf(arg1, arg2, x, arg4);
+void test__std__set__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::set::size();
 }
 
-void test__wscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wscanf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__set__max_size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::set::max_size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wscanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wscanf(p);
-    // cppcheck-suppress memleak
+void test__std__set__max_size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::set::max_size();
 }
 
-void test__wscanf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wscanf(NULL);
+void test__std__unordered_set__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::unordered_set::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wscanf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wscanf(x);
+void test__std__unordered_set__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::unordered_set::size();
 }
 
-void test__std__wscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wscanf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__unordered_set__max_size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::unordered_set::max_size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wscanf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::wscanf(NULL);
+void test__std__unordered_set__max_size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::unordered_set::max_size();
 }
 
-void test__std__wscanf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::wscanf(x);
+void test__std__stack__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::stack::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sscanf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__stack__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stack::size();
 }
 
-void test__sscanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sscanf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__string__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::string::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sscanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sscanf(x, arg2);
+void test__std__string__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::size();
 }
 
-void test__sscanf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    sscanf(arg1, NULL);
+void test__std__wstring__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wstring::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sscanf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    sscanf(arg1, x);
-}
+void test__std__wstring__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::size();
+}
 
-void test__std__sscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::sscanf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vector__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::vector::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__sscanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::sscanf(x, arg2);
+void test__std__vector__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::vector::size();
 }
 
-void test__std__sscanf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::sscanf(arg1, NULL);
+void test__std__vector__capacity__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::vector::capacity(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__sscanf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    std::sscanf(arg1, x);
-}
-
-void test__fwscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fwscanf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vector__capacity__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::vector::capacity();
 }
 
-void test__fwscanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fwscanf(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__vector__max_size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::vector::max_size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fwscanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fwscanf(x, arg2);
-}
-
-void test__fwscanf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    fwscanf(arg1, x);
-}
-
-void test__std__fwscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fwscanf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vector__max_size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::vector::max_size();
 }
 
-void test__std__fwscanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fwscanf(x, arg2);
-}
-
-void test__std__fwscanf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fwscanf(arg1, x);
-}
-
-void test__swscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        swscanf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__swscanf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    swscanf(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__swscanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    swscanf(x, arg2);
-}
-
-void test__swscanf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    swscanf(arg1, x);
-}
-
-void test__std__swscanf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::swscanf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__swscanf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::swscanf(x, arg2);
-}
-
-void test__std__swscanf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::swscanf(arg1, x);
-}
-
-void test__system__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        system(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__system__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    system(p);
-    // cppcheck-suppress memleak
-}
-
-void test__system__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    system(x);
-}
-
-void test__std__system__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::system(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__system__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::system(x);
-}
-
-void test__setw__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setw(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__setw__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setw(p);
-    // cppcheck-suppress memleak
-}
-
-void test__setw__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setw(x);
-}
-
-void test__std__setw__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::setw(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__setw__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::setw(x);
-}
-
-void test__min__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = min(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__array__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::array::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__min__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    min(arg1, arg2);
-}
-
-void test__min__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = min(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__min__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = min(x, arg2);
-}
-
-void test__min__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = min(arg1, x);
-}
-
-void test__std__min__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::min(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__min__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::min(arg1, arg2);
+void test__std__array__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::array::size();
 }
-
-void test__std__min__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::min(x, arg2);
+
+void test__std__array__max_size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::array::max_size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__min__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::min(arg1, x);
+void test__std__array__max_size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::array::max_size();
 }
 
-void test__max__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = max(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__list__back__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::list::back(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__max__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    max(arg1, arg2);
+void test__std__list__back__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::list::back();
 }
 
-void test__max__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = max(p, arg2);
-    // cppcheck-suppress memleak
-}
+void test__std__list__front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::list::front(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__max__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = max(x, arg2);
-}
-
-void test__max__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = max(arg1, x);
+void test__std__list__front__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::list::front();
 }
 
-void test__std__max__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::max(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__max__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::max(arg1, arg2);
-}
-
-void test__std__max__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::max(x, arg2);
-}
-
-void test__std__max__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::max(arg1, x);
-}
-
-void test__setiosflags__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setiosflags(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__setiosflags__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setiosflags(p);
-    // cppcheck-suppress memleak
-}
-
-void test__setiosflags__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setiosflags(x);
-}
-
-void test__std__setiosflags__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::setiosflags(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__setiosflags__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::setiosflags(x);
-}
-
-void test__resetiosflags__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        resetiosflags(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__resetiosflags__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    resetiosflags(p);
-    // cppcheck-suppress memleak
-}
-
-void test__resetiosflags__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    resetiosflags(x);
-}
-
-void test__std__resetiosflags__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::resetiosflags(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__resetiosflags__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::resetiosflags(x);
-}
-
-void test__setfill__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setfill(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__setfill__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setfill(p);
-    // cppcheck-suppress memleak
-}
-
-void test__setfill__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setfill(x);
-}
-
-void test__std__setfill__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::setfill(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__setfill__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::setfill(x);
-}
-
-void test__setprecision__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setprecision(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__setprecision__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setprecision(p);
-    // cppcheck-suppress memleak
-}
-
-void test__setprecision__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setprecision(x);
-}
-
-void test__std__setprecision__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::setprecision(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__setprecision__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::setprecision(x);
-}
-
-void test__setbase__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setbase(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__setbase__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setbase(p);
-    // cppcheck-suppress memleak
-}
-
-void test__setbase__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setbase(x);
-}
-
-void test__std__setbase__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::setbase(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__setbase__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::setbase(x);
-}
-
-void test__zonetime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = zonetime(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__forward_list__front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::forward_list::front(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__zonetime__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    zonetime(arg1, arg2);
+void test__std__forward_list__front__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::forward_list::front();
 }
 
-void test__zonetime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = zonetime(p, arg2);
-    // cppcheck-suppress memleak
+void test__std__queue__back__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::queue::back(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__zonetime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = zonetime(NULL, arg2);
+void test__std__queue__back__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::queue::back();
 }
-
-void test__zonetime__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = zonetime(x, arg2);
+
+void test__std__queue__front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::queue::front(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__zonetime__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = zonetime(arg1, x);
+
+void test__std__queue__front__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::queue::front();
 }
 
-void test__c16rtomb__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        c16rtomb(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vector__back__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::vector::back(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__c16rtomb__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    c16rtomb(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__vector__back__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::vector::back();
 }
 
-void test__c16rtomb__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    c16rtomb(arg1, x, arg3);
+void test__std__vector__front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::vector::front(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__c16rtomb__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    c16rtomb(arg1, arg2, NULL);
+void test__std__vector__front__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::vector::front();
 }
 
-void test__c16rtomb__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    c16rtomb(arg1, arg2, x);
+void test__std__array__front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::array::front(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__c32rtomb__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        c32rtomb(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__array__front__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::array::front();
 }
 
-void test__c32rtomb__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    c32rtomb(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__array__back__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::array::back(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__c32rtomb__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    c32rtomb(arg1, x, arg3);
+void test__std__array__back__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::array::back();
 }
 
-void test__c32rtomb__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    c32rtomb(arg1, arg2, NULL);
+void test__std__vector__at__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::vector::at(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__c32rtomb__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    c32rtomb(arg1, arg2, x);
+void test__std__vector__at__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::vector::at(arg1);
 }
 
-void test__mbrtoc16__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mbrtoc16(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__vector__at__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::vector::at(x);
 }
 
-void test__mbrtoc16__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mbrtoc16(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__std__list__pop_back__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::list::pop_back(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbrtoc16__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mbrtoc16(arg1, x, arg3, arg4);
+void test__std__list__pop_front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::list::pop_front(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbrtoc16__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mbrtoc16(arg1, arg2, x, arg4);
+void test__std__forward_list__pop_front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::forward_list::pop_front(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbrtoc16__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mbrtoc16(arg1, arg2, arg3, NULL);
+void test__std__vector__pop_back__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::vector::pop_back(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbrtoc16__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    mbrtoc16(arg1, arg2, arg3, x);
+void test__std__stack__pop__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::stack::pop(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbrtoc32__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        mbrtoc32(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__queue__pop__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::queue::pop(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbrtoc32__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    mbrtoc32(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__std__stack__top__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::stack::top(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbrtoc32__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mbrtoc32(arg1, x, arg3, arg4);
+void test__std__stack__top__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stack::top();
 }
 
-void test__mbrtoc32__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    mbrtoc32(arg1, arg2, x, arg4);
+void test__std__string__at__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::string::at(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__mbrtoc32__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    mbrtoc32(arg1, arg2, arg3, NULL);
+void test__std__string__at__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::at(arg1);
 }
 
-void test__mbrtoc32__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    mbrtoc32(arg1, arg2, arg3, x);
+void test__std__string__at__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::at(x);
 }
 
-void test__std__swap__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::swap(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__string__push_back__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::string::push_back(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__swap__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::swap(x, arg2);
+void test__std__string__push_back__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::string::push_back(x);
 }
 
-void test__std__swap__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::swap(arg1, x);
+void test__std__string__back__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::string::back(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ostringstream__str__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ostringstream::str();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ostringstream__str__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ostringstream::str();
-}
-
-void test__std__ios__good__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ios::good();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ios__good__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ios::good();
-}
-
-void test__std__ios_base__good__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ios_base::good();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ios_base__good__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ios_base::good();
-}
-
-void test__std__ostream__good__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ostream::good();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ostream__good__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ostream::good();
-}
-
-void test__std__ofstream__good__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ofstream::good();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ofstream__good__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ofstream::good();
-}
-
-void test__std__ostringstream__good__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ostringstream::good();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ostringstream__good__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ostringstream::good();
-}
-
-void test__std__ios__eof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ios::eof();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ios__eof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ios::eof();
-}
-
-void test__std__ios_base__eof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ios_base::eof();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ios_base__eof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ios_base::eof();
-}
-
-void test__std__ostream__eof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ostream::eof();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ostream__eof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ostream::eof();
-}
-
-void test__std__ofstream__eof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ofstream::eof();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ofstream__eof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ofstream::eof();
-}
-
-void test__std__ostringstream__eof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ostringstream::eof();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ostringstream__eof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ostringstream::eof();
-}
-
-void test__std__ios__fail__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ios::fail();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ios__fail__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ios::fail();
-}
-
-void test__std__ios_base__fail__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ios_base::fail();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ios_base__fail__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ios_base::fail();
-}
-
-void test__std__ostream__fail__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ostream::fail();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ostream__fail__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ostream::fail();
-}
-
-void test__std__ofstream__fail__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ofstream::fail();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ofstream__fail__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ofstream::fail();
-}
-
-void test__std__ostringstream__fail__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ostringstream::fail();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ostringstream__fail__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ostringstream::fail();
-}
-
-void test__std__ios__bad__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ios::bad();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ios__bad__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ios::bad();
-}
-
-void test__std__ios_base__bad__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ios_base::bad();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ios_base__bad__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ios_base::bad();
-}
-
-void test__std__ostream__bad__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ostream::bad();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ostream__bad__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ostream::bad();
-}
-
-void test__std__ofstream__bad__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ofstream::bad();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ofstream__bad__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ofstream::bad();
-}
-
-void test__std__ostringstream__bad__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::ostringstream::bad();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ostringstream__bad__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::ostringstream::bad();
-}
-
-void test__std__array__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::array::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__deque__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::deque::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__list__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::list::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__forward_list__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::forward_list::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__map__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::map::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__unordered_map__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::unordered_map::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__queue__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::queue::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__set__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::set::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__unordered_set__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::unordered_set::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__stack__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::stack::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__string__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::string::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__wstring__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wstring::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__basic_string__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::basic_string::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vector__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vector::clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__array__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::array::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__array__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::array::empty();
-}
-
-void test__std__deque__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::deque::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__deque__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::deque::empty();
-}
-
-void test__std__list__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::list::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__list__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::list::empty();
-}
-
-void test__std__forward_list__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::forward_list::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__forward_list__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::forward_list::empty();
-}
-
-void test__std__map__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::map::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__map__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::map::empty();
-}
-
-void test__std__unordered_map__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::unordered_map::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__unordered_map__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::unordered_map::empty();
-}
-
-void test__std__queue__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::queue::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__queue__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::queue::empty();
-}
-
-void test__std__set__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::set::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__set__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::set::empty();
-}
-
-void test__std__unordered_set__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::unordered_set::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__unordered_set__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::unordered_set::empty();
-}
-
-void test__std__stack__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::stack::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__stack__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::stack::empty();
-}
-
-void test__std__string__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::string::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__string__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::string::empty();
-}
-
-void test__std__wstring__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wstring::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__wstring__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wstring::empty();
-}
-
-void test__std__basic_string__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::basic_string::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__basic_string__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::basic_string::empty();
-}
-
-void test__std__vector__empty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::vector::empty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vector__empty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::vector::empty();
-}
-
-void test__std__deque__push_back__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::deque::push_back(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__deque__push_back__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::deque::push_back(x);
-}
-
-void test__std__deque__push_front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::deque::push_front(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__deque__push_front__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::deque::push_front(x);
-}
-
-void test__std__list__push_back__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::list::push_back(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__list__push_back__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::list::push_back(x);
-}
-
-void test__std__list__push_front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::list::push_front(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__list__push_front__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::list::push_front(x);
-}
-
-void test__std__forward_list__push_front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::forward_list::push_front(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__forward_list__push_front__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::forward_list::push_front(x);
-}
-
-void test__std__queue__push__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::queue::push(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__queue__push__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::queue::push(x);
-}
-
-void test__std__stack__push__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::stack::push(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__stack__push__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::stack::push(x);
-}
-
-void test__std__vector__push_back__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vector::push_back(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vector__push_back__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::vector::push_back(x);
-}
-
-void test__std__vector__push_front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vector::push_front(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vector__push_front__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::vector::push_front(x);
-}
-
-void test__std__list__insert__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::list::insert(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__list__insert__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::list::insert(x);
-}
-
-void test__std__multimap__insert__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::multimap::insert(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__multimap__insert__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::multimap::insert(x);
-}
-
-void test__std__set__insert__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::set::insert(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__set__insert__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::set::insert(x);
-}
-
-void test__std__string__insert__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::string::insert(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__string__insert__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::string::insert(x);
-}
-
-void test__std__vector__insert__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vector::insert(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vector__insert__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::vector::insert(x);
-}
-
-void test__std__deque__emplace_back__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::deque::emplace_back();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__deque__emplace_front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::deque::emplace_front();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__list__emplace_back__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::list::emplace_back();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__list__emplace_front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::list::emplace_front();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__forward_list__emplace_front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::forward_list::emplace_front();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__queue__emplace__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::queue::emplace();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__stack__emplace__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::stack::emplace();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vector__emplace_back__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vector::emplace_back();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vector__emplace_front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vector::emplace_front();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__list__find__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::list::find(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__list__find__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::list::find(arg1);
-}
-
-void test__std__list__find__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::list::find(x);
-}
-
-void test__std__map__find__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::map::find(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__map__find__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::map::find(arg1);
-}
-
-void test__std__map__find__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::map::find(x);
-}
-
-void test__std__set__find__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::set::find(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__set__find__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::set::find(arg1);
-}
-
-void test__std__set__find__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::set::find(x);
-}
-
-void test__std__vector__find__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::vector::find(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vector__find__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::vector::find(arg1);
-}
-
-void test__std__vector__find__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::vector::find(x);
-}
-
-void test__std__deque__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::deque::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__deque__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::deque::size();
-}
-
-void test__std__deque__max_size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::deque::max_size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__deque__max_size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::deque::max_size();
-}
-
-void test__std__list__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::list::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__list__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::list::size();
-}
-
-void test__std__list__max_size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::list::max_size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__list__max_size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::list::max_size();
-}
-
-void test__std__map__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::map::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__map__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::map::size();
-}
-
-void test__std__map__max_size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::map::max_size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__map__max_size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::map::max_size();
-}
-
-void test__std__unordered_map__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::unordered_map::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__unordered_map__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::unordered_map::size();
-}
-
-void test__std__unordered_map__max_size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::unordered_map::max_size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__unordered_map__max_size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::unordered_map::max_size();
-}
-
-void test__std__queue__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::queue::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__queue__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::queue::size();
-}
-
-void test__std__set__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::set::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__set__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::set::size();
-}
-
-void test__std__set__max_size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::set::max_size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__set__max_size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::set::max_size();
-}
-
-void test__std__unordered_set__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::unordered_set::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__unordered_set__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::unordered_set::size();
-}
-
-void test__std__unordered_set__max_size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::unordered_set::max_size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__unordered_set__max_size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::unordered_set::max_size();
-}
-
-void test__std__stack__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::stack::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__stack__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::stack::size();
-}
-
-void test__std__string__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::string::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__string__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::string::size();
-}
-
-void test__std__wstring__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wstring::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__wstring__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wstring::size();
-}
-
-void test__std__vector__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::vector::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vector__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::vector::size();
-}
-
-void test__std__vector__capacity__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::vector::capacity();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vector__capacity__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::vector::capacity();
-}
-
-void test__std__vector__max_size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::vector::max_size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vector__max_size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::vector::max_size();
-}
-
-void test__std__array__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::array::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__array__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::array::size();
-}
-
-void test__std__array__max_size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::array::max_size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__array__max_size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::array::max_size();
-}
-
-void test__std__list__back__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::list::back();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__list__back__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::list::back();
-}
-
-void test__std__list__front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::list::front();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__list__front__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::list::front();
-}
-
-void test__std__forward_list__front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::forward_list::front();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__forward_list__front__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::forward_list::front();
-}
-
-void test__std__queue__back__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::queue::back();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__queue__back__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::queue::back();
-}
-
-void test__std__queue__front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::queue::front();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__queue__front__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::queue::front();
-}
-
-void test__std__vector__back__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::vector::back();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vector__back__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::vector::back();
-}
-
-void test__std__vector__front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::vector::front();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vector__front__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::vector::front();
-}
-
-void test__std__array__front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::array::front();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__array__front__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::array::front();
-}
-
-void test__std__array__back__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::array::back();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__array__back__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::array::back();
-}
-
-void test__std__vector__at__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::vector::at(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vector__at__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::vector::at(arg1);
-}
-
-void test__std__vector__at__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::vector::at(x);
-}
-
-void test__std__list__pop_back__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::list::pop_back();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__list__pop_front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::list::pop_front();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__forward_list__pop_front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::forward_list::pop_front();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__vector__pop_back__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::vector::pop_back();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__stack__pop__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::stack::pop();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__queue__pop__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::queue::pop();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__stack__top__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::stack::top();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__stack__top__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::stack::top();
-}
-
-void test__std__string__at__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::string::at(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__string__at__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::string::at(arg1);
-}
-
-void test__std__string__at__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::string::at(x);
-}
-
-void test__std__string__push_back__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::string::push_back(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__string__push_back__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::string::push_back(x);
-}
-
-void test__std__string__back__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::string::back();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__string__back__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::string::back();
-}
-
-void test__std__string__swap__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::string::swap(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__string__c_str__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::string::c_str();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__string__c_str__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::string::c_str();
-}
-
-void test__std__string__data__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::string::data();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__string__back__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::back();
 }
 
-void test__std__string__data__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::string::data();
+void test__std__string__swap__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::string::swap(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__string__front__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::string::front();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__string__c_str__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::string::c_str(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__string__front__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::string::front();
+void test__std__string__c_str__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::c_str();
 }
 
-void test__std__basic_string__find_last_not_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::basic_string::find_last_not_of(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__string__data__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::string::data(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__basic_string__find_last_not_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::basic_string::find_last_not_of(arg1, arg2, arg3);
+void test__std__string__data__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::data();
 }
 
-void test__std__basic_string__find_last_not_of__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::basic_string::find_last_not_of(NULL, arg2, arg3);
+void test__std__string__front__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::string::front(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__basic_string__find_last_not_of__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::find_last_not_of(x, arg2, arg3);
+void test__std__string__front__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::front();
 }
 
-void test__std__basic_string__find_last_not_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::find_last_not_of(arg1, x, arg3);
+void test__std__basic_string__find_last_not_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::basic_string::find_last_not_of(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__basic_string__find_last_not_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::find_last_not_of(arg1, arg2, x);
+void test__std__basic_string__find_last_not_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::find_last_not_of(arg1, arg2, arg3);
 }
 
-void test__std__string__find_last_not_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::string::find_last_not_of(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__basic_string__find_last_not_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_last_not_of(x, arg2, arg3);
 }
 
-void test__std__string__find_last_not_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::string::find_last_not_of(arg1, arg2, arg3);
+void test__std__basic_string__find_last_not_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_last_not_of(arg1, x, arg3);
 }
 
-void test__std__string__find_last_not_of__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::string::find_last_not_of(NULL, arg2, arg3);
+void test__std__basic_string__find_last_not_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_last_not_of(arg1, arg2, x);
 }
 
-void test__std__string__find_last_not_of__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::string::find_last_not_of(x, arg2, arg3);
+void test__std__string__find_last_not_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::string::find_last_not_of(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__string__find_last_not_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::string::find_last_not_of(arg1, x, arg3);
+void test__std__string__find_last_not_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::find_last_not_of(arg1, arg2, arg3);
 }
 
-void test__std__string__find_last_not_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::string::find_last_not_of(arg1, arg2, x);
+void test__std__string__find_last_not_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_last_not_of(x, arg2, arg3);
 }
 
-void test__std__wstring__find_last_not_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wstring::find_last_not_of(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__string__find_last_not_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_last_not_of(arg1, x, arg3);
 }
 
-void test__std__wstring__find_last_not_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wstring::find_last_not_of(arg1, arg2, arg3);
+void test__std__string__find_last_not_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_last_not_of(arg1, arg2, x);
 }
 
-void test__std__wstring__find_last_not_of__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wstring::find_last_not_of(NULL, arg2, arg3);
+void test__std__wstring__find_last_not_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wstring::find_last_not_of(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wstring__find_last_not_of__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wstring::find_last_not_of(x, arg2, arg3);
+void test__std__wstring__find_last_not_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::find_last_not_of(arg1, arg2, arg3);
 }
 
-void test__std__wstring__find_last_not_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wstring::find_last_not_of(arg1, x, arg3);
+void test__std__wstring__find_last_not_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_last_not_of(x, arg2, arg3);
 }
 
-void test__std__wstring__find_last_not_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wstring::find_last_not_of(arg1, arg2, x);
+void test__std__wstring__find_last_not_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_last_not_of(arg1, x, arg3);
 }
 
-void test__std__basic_string__find_first_not_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::basic_string::find_first_not_of(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wstring__find_last_not_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_last_not_of(arg1, arg2, x);
 }
 
-void test__std__basic_string__find_first_not_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::basic_string::find_first_not_of(arg1, arg2, arg3);
+void test__std__basic_string__find_first_not_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::basic_string::find_first_not_of(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__basic_string__find_first_not_of__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::basic_string::find_first_not_of(NULL, arg2, arg3);
+void test__std__basic_string__find_first_not_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::find_first_not_of(arg1, arg2, arg3);
 }
 
-void test__std__basic_string__find_first_not_of__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::find_first_not_of(x, arg2, arg3);
+void test__std__basic_string__find_first_not_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_first_not_of(x, arg2, arg3);
 }
 
-void test__std__basic_string__find_first_not_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::find_first_not_of(arg1, x, arg3);
+void test__std__basic_string__find_first_not_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_first_not_of(arg1, x, arg3);
 }
 
-void test__std__basic_string__find_first_not_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::find_first_not_of(arg1, arg2, x);
+void test__std__basic_string__find_first_not_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_first_not_of(arg1, arg2, x);
 }
 
-void test__std__string__find_first_not_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::string::find_first_not_of(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__string__find_first_not_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::string::find_first_not_of(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__string__find_first_not_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::string::find_first_not_of(arg1, arg2, arg3);
+void test__std__string__find_first_not_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::find_first_not_of(arg1, arg2, arg3);
 }
 
-void test__std__string__find_first_not_of__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::string::find_first_not_of(NULL, arg2, arg3);
+void test__std__string__find_first_not_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_first_not_of(x, arg2, arg3);
 }
 
-void test__std__string__find_first_not_of__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::string::find_first_not_of(x, arg2, arg3);
+void test__std__string__find_first_not_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_first_not_of(arg1, x, arg3);
 }
 
-void test__std__string__find_first_not_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::string::find_first_not_of(arg1, x, arg3);
+void test__std__string__find_first_not_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_first_not_of(arg1, arg2, x);
 }
 
-void test__std__string__find_first_not_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::string::find_first_not_of(arg1, arg2, x);
+void test__std__wstring__find_first_not_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wstring::find_first_not_of(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wstring__find_first_not_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wstring::find_first_not_of(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wstring__find_first_not_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::find_first_not_of(arg1, arg2, arg3);
 }
 
-void test__std__wstring__find_first_not_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wstring::find_first_not_of(arg1, arg2, arg3);
+void test__std__wstring__find_first_not_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_first_not_of(x, arg2, arg3);
 }
 
-void test__std__wstring__find_first_not_of__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wstring::find_first_not_of(NULL, arg2, arg3);
+void test__std__wstring__find_first_not_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_first_not_of(arg1, x, arg3);
 }
 
-void test__std__wstring__find_first_not_of__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wstring::find_first_not_of(x, arg2, arg3);
+void test__std__wstring__find_first_not_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_first_not_of(arg1, arg2, x);
 }
 
-void test__std__wstring__find_first_not_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wstring::find_first_not_of(arg1, x, arg3);
+void test__std__string__find__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::string::find(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wstring__find_first_not_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wstring::find_first_not_of(arg1, arg2, x);
+void test__std__string__find__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::find(arg1, arg2, arg3);
 }
 
-void test__std__string__find__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::string::find(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__string__find__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find(x, arg2, arg3);
 }
 
-void test__std__string__find__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::string::find(arg1, arg2, arg3);
+void test__std__string__find__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find(arg1, x, arg3);
 }
 
-void test__std__string__find__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::string::find(NULL, arg2, arg3);
+void test__std__string__find__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find(arg1, arg2, x);
 }
 
-void test__std__string__find__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::string::find(x, arg2, arg3);
+void test__std__string__rfind__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::string::rfind(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__string__find__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::string::find(arg1, x, arg3);
+void test__std__string__rfind__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::rfind(arg1, arg2, arg3);
 }
 
-void test__std__string__find__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::string::find(arg1, arg2, x);
+void test__std__string__rfind__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::rfind(x, arg2, arg3);
 }
 
-void test__std__string__rfind__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::string::rfind(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__string__rfind__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::rfind(arg1, x, arg3);
 }
 
-void test__std__string__rfind__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::string::rfind(arg1, arg2, arg3);
+void test__std__string__rfind__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::rfind(arg1, arg2, x);
 }
 
-void test__std__string__rfind__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::string::rfind(NULL, arg2, arg3);
+void test__std__wstring__find__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wstring::find(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__string__rfind__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::string::rfind(x, arg2, arg3);
+void test__std__wstring__find__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::find(arg1, arg2, arg3);
 }
 
-void test__std__string__rfind__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::string::rfind(arg1, x, arg3);
+void test__std__wstring__find__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find(x, arg2, arg3);
 }
 
-void test__std__string__rfind__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::string::rfind(arg1, arg2, x);
+void test__std__wstring__find__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find(arg1, x, arg3);
 }
 
-void test__std__wstring__find__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wstring::find(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wstring__find__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find(arg1, arg2, x);
 }
 
-void test__std__wstring__find__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wstring::find(arg1, arg2, arg3);
+void test__std__wstring__rfind__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wstring::rfind(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wstring__find__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wstring::find(NULL, arg2, arg3);
+void test__std__wstring__rfind__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::rfind(arg1, arg2, arg3);
 }
 
-void test__std__wstring__find__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wstring::find(x, arg2, arg3);
+void test__std__wstring__rfind__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::rfind(x, arg2, arg3);
 }
 
-void test__std__wstring__find__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wstring::find(arg1, x, arg3);
+void test__std__wstring__rfind__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::rfind(arg1, x, arg3);
 }
 
-void test__std__wstring__find__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wstring::find(arg1, arg2, x);
+void test__std__wstring__rfind__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::rfind(arg1, arg2, x);
 }
 
-void test__std__wstring__rfind__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wstring::rfind(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__basic_string__find__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::basic_string::find(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wstring__rfind__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wstring::rfind(arg1, arg2, arg3);
+void test__std__basic_string__find__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::find(arg1, arg2, arg3);
 }
 
-void test__std__wstring__rfind__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wstring::rfind(NULL, arg2, arg3);
+void test__std__basic_string__find__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find(x, arg2, arg3);
 }
 
-void test__std__wstring__rfind__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wstring::rfind(x, arg2, arg3);
+void test__std__basic_string__find__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find(arg1, x, arg3);
 }
 
-void test__std__wstring__rfind__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wstring::rfind(arg1, x, arg3);
+void test__std__basic_string__find__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find(arg1, arg2, x);
 }
 
-void test__std__wstring__rfind__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wstring::rfind(arg1, arg2, x);
+void test__std__basic_string__rfind__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::basic_string::rfind(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__basic_string__find__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::basic_string::find(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__basic_string__rfind__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::rfind(arg1, arg2, arg3);
 }
 
-void test__std__basic_string__find__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::basic_string::find(arg1, arg2, arg3);
+void test__std__basic_string__rfind__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::rfind(x, arg2, arg3);
 }
 
-void test__std__basic_string__find__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::basic_string::find(NULL, arg2, arg3);
+void test__std__basic_string__rfind__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::rfind(arg1, x, arg3);
 }
 
-void test__std__basic_string__find__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::find(x, arg2, arg3);
+void test__std__basic_string__rfind__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::rfind(arg1, arg2, x);
 }
 
-void test__std__basic_string__find__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::find(arg1, x, arg3);
+void test__std__string__find_first_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::string::find_first_of(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__basic_string__find__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::find(arg1, arg2, x);
+void test__std__string__find_first_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::find_first_of(arg1, arg2, arg3);
 }
 
-void test__std__basic_string__rfind__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::basic_string::rfind(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__string__find_first_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_first_of(x, arg2, arg3);
 }
 
-void test__std__basic_string__rfind__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::basic_string::rfind(arg1, arg2, arg3);
+void test__std__string__find_first_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_first_of(arg1, x, arg3);
 }
 
-void test__std__basic_string__rfind__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::basic_string::rfind(NULL, arg2, arg3);
+void test__std__string__find_first_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_first_of(arg1, arg2, x);
 }
 
-void test__std__basic_string__rfind__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::rfind(x, arg2, arg3);
+void test__std__wstring__find_first_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wstring::find_first_of(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__basic_string__rfind__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::rfind(arg1, x, arg3);
+void test__std__wstring__find_first_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::find_first_of(arg1, arg2, arg3);
 }
 
-void test__std__basic_string__rfind__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::rfind(arg1, arg2, x);
+void test__std__wstring__find_first_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_first_of(x, arg2, arg3);
 }
 
-void test__std__string__find_first_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::string::find_first_of(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wstring__find_first_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_first_of(arg1, x, arg3);
 }
 
-void test__std__string__find_first_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::string::find_first_of(arg1, arg2, arg3);
+void test__std__wstring__find_first_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_first_of(arg1, arg2, x);
 }
 
-void test__std__string__find_first_of__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::string::find_first_of(NULL, arg2, arg3);
+void test__std__basic_string__find_first_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::basic_string::find_first_of(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__string__find_first_of__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::string::find_first_of(x, arg2, arg3);
+void test__std__basic_string__find_first_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::find_first_of(arg1, arg2, arg3);
 }
 
-void test__std__string__find_first_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::string::find_first_of(arg1, x, arg3);
+void test__std__basic_string__find_first_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_first_of(x, arg2, arg3);
 }
 
-void test__std__string__find_first_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::string::find_first_of(arg1, arg2, x);
+void test__std__basic_string__find_first_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_first_of(arg1, x, arg3);
 }
 
-void test__std__wstring__find_first_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wstring::find_first_of(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__basic_string__find_first_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_first_of(arg1, arg2, x);
 }
 
-void test__std__wstring__find_first_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wstring::find_first_of(arg1, arg2, arg3);
+void test__std__string__find_last_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::string::find_last_of(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wstring__find_first_of__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wstring::find_first_of(NULL, arg2, arg3);
+void test__std__string__find_last_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::find_last_of(arg1, arg2, arg3);
 }
 
-void test__std__wstring__find_first_of__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wstring::find_first_of(x, arg2, arg3);
+void test__std__string__find_last_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_last_of(x, arg2, arg3);
 }
 
-void test__std__wstring__find_first_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wstring::find_first_of(arg1, x, arg3);
+void test__std__string__find_last_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_last_of(arg1, x, arg3);
 }
 
-void test__std__wstring__find_first_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wstring::find_first_of(arg1, arg2, x);
+void test__std__string__find_last_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_last_of(arg1, arg2, x);
 }
 
-void test__std__basic_string__find_first_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::basic_string::find_first_of(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wstring__find_last_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wstring::find_last_of(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__basic_string__find_first_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::basic_string::find_first_of(arg1, arg2, arg3);
+void test__std__wstring__find_last_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::find_last_of(arg1, arg2, arg3);
 }
 
-void test__std__basic_string__find_first_of__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::basic_string::find_first_of(NULL, arg2, arg3);
+void test__std__wstring__find_last_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_last_of(x, arg2, arg3);
 }
 
-void test__std__basic_string__find_first_of__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::find_first_of(x, arg2, arg3);
+void test__std__wstring__find_last_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_last_of(arg1, x, arg3);
 }
 
-void test__std__basic_string__find_first_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::find_first_of(arg1, x, arg3);
+void test__std__wstring__find_last_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_last_of(arg1, arg2, x);
 }
 
-void test__std__basic_string__find_first_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::find_first_of(arg1, arg2, x);
+void test__std__basic_string__find_last_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::basic_string::find_last_of(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__string__find_last_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::string::find_last_of(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__basic_string__find_last_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::find_last_of(arg1, arg2, arg3);
 }
 
-void test__std__string__find_last_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::string::find_last_of(arg1, arg2, arg3);
+void test__std__basic_string__find_last_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_last_of(x, arg2, arg3);
 }
 
-void test__std__string__find_last_of__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::string::find_last_of(NULL, arg2, arg3);
+void test__std__basic_string__find_last_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_last_of(arg1, x, arg3);
 }
 
-void test__std__string__find_last_of__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::string::find_last_of(x, arg2, arg3);
+void test__std__basic_string__find_last_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_last_of(arg1, arg2, x);
 }
 
-void test__std__string__find_last_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::string::find_last_of(arg1, x, arg3);
+void test__std__string__length__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::string::length(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__string__find_last_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::string::find_last_of(arg1, arg2, x);
+void test__std__string__length__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::length();
 }
 
-void test__std__wstring__find_last_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wstring::find_last_of(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wstring__length__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wstring::length(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wstring__find_last_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wstring::find_last_of(arg1, arg2, arg3);
+void test__std__wstring__length__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::length();
 }
 
-void test__std__wstring__find_last_of__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::wstring::find_last_of(NULL, arg2, arg3);
+void test__std__basic_string__size__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::basic_string::size(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wstring__find_last_of__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::wstring::find_last_of(x, arg2, arg3);
+void test__std__basic_string__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::size();
 }
 
-void test__std__wstring__find_last_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wstring::find_last_of(arg1, x, arg3);
+void test__std__basic_string__length__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::basic_string::length(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wstring__find_last_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wstring::find_last_of(arg1, arg2, x);
+void test__std__basic_string__length__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::length();
 }
 
-void test__std__basic_string__find_last_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::basic_string::find_last_of(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__string__substr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::string::substr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__basic_string__find_last_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::basic_string::find_last_of(arg1, arg2, arg3);
+void test__std__string__substr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::substr(arg1, arg2);
 }
 
-void test__std__basic_string__find_last_of__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = std::basic_string::find_last_of(NULL, arg2, arg3);
+void test__std__string__substr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::substr(x, arg2);
 }
 
-void test__std__basic_string__find_last_of__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::find_last_of(x, arg2, arg3);
+void test__std__string__substr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::substr(arg1, x);
 }
 
-void test__std__basic_string__find_last_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::find_last_of(arg1, x, arg3);
+void test__std__wstring__substr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::wstring::substr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__basic_string__find_last_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::find_last_of(arg1, arg2, x);
+void test__std__wstring__substr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::substr(arg1, arg2);
 }
 
-void test__std__string__length__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::string::length();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wstring__substr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::substr(x, arg2);
 }
 
-void test__std__string__length__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::string::length();
+void test__std__wstring__substr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::substr(arg1, x);
 }
 
-void test__std__wstring__length__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wstring::length();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__basic_string__substr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::basic_string::substr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wstring__length__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wstring::length();
+void test__std__basic_string__substr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::substr(arg1, arg2);
 }
 
-void test__std__basic_string__size__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::basic_string::size();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__basic_string__substr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::substr(x, arg2);
 }
 
-void test__std__basic_string__size__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::basic_string::size();
+void test__std__basic_string__substr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::substr(arg1, x);
 }
 
-void test__std__basic_string__length__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::basic_string::length();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ios__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::ios::clear(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__basic_string__length__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::basic_string::length();
+void test__std__ios__clear__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ios::clear(x);
 }
 
-void test__std__string__substr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::string::substr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__fstream__clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::fstream::clear(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__string__substr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::string::substr(arg1, arg2);
+void test__std__fstream__clear__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fstream::clear(x);
 }
 
-void test__std__string__substr__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::string::substr(x, arg2);
+void test__std__istream__read__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::istream::read(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__string__substr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::string::substr(arg1, x);
+void test__std__istream__read__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::istream::read(NULL, arg2);
 }
 
-void test__std__wstring__substr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::wstring::substr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__istream__read__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::istream::read(arg1, x);
 }
 
-void test__std__wstring__substr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::wstring::substr(arg1, arg2);
+void test__std__ifstream__read__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::ifstream::read(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__wstring__substr__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wstring::substr(x, arg2);
+void test__std__ifstream__read__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::ifstream::read(NULL, arg2);
 }
 
-void test__std__wstring__substr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::wstring::substr(arg1, x);
-}
-
-void test__std__basic_string__substr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::basic_string::substr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ifstream__read__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ifstream::read(arg1, x);
 }
 
-void test__std__basic_string__substr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::basic_string::substr(arg1, arg2);
+void test__std__istream__readsome__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::istream::readsome(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__basic_string__substr__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::substr(x, arg2);
-}
-
-void test__std__basic_string__substr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::basic_string::substr(arg1, x);
+void test__std__istream__readsome__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::istream::readsome(NULL, arg2);
 }
 
-void test__std__ios__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::ios::clear(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__istream__readsome__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::istream::readsome(arg1, x);
 }
 
-void test__std__ios__clear__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::ios::clear(x);
+void test__std__ifstream__readsome__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::ifstream::readsome(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__fstream__clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::fstream::clear(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ifstream__readsome__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::ifstream::readsome(NULL, arg2);
 }
 
-void test__std__fstream__clear__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::fstream::clear(x);
+void test__std__ifstream__readsome__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ifstream::readsome(arg1, x);
 }
 
-void test__std__istream__read__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::istream::read(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__istream__getline__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::istream::getline(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__istream__read__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::istream::read(NULL, arg2);
+void test__std__istream__getline__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::istream::getline(NULL, arg2, arg3);
 }
 
-void test__std__istream__read__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::istream::read(arg1, x);
+void test__std__istream__getline__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::istream::getline(arg1, x, arg3);
 }
 
-void test__std__ifstream__read__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::ifstream::read(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__ifstream__read__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::ifstream::read(NULL, arg2);
+void test__std__istream__getline__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::istream::getline(arg1, arg2, x);
 }
 
-void test__std__ifstream__read__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::ifstream::read(arg1, x);
+void test__std__ifstream__getline__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::ifstream::getline(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__istream__readsome__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::istream::readsome(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ifstream__getline__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::ifstream::getline(NULL, arg2, arg3);
 }
 
-void test__std__istream__readsome__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::istream::readsome(NULL, arg2);
-}
-
-void test__std__istream__readsome__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::istream::readsome(arg1, x);
+void test__std__ifstream__getline__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ifstream::getline(arg1, x, arg3);
 }
 
-void test__std__ifstream__readsome__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::ifstream::readsome(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ifstream__getline__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ifstream::getline(arg1, arg2, x);
 }
 
-void test__std__ifstream__readsome__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::ifstream::readsome(NULL, arg2);
+void test__std__istream__get__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::istream::get(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ifstream__readsome__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::ifstream::readsome(arg1, x);
+void test__std__istream__get__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::istream::get(NULL, arg2, arg3);
 }
 
-void test__std__istream__getline__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::istream::getline(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__istream__get__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::istream::get(arg1, x, arg3);
 }
 
-void test__std__istream__getline__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::istream::getline(NULL, arg2, arg3);
+void test__std__istream__get__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::istream::get(arg1, arg2, x);
 }
 
-void test__std__istream__getline__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::istream::getline(arg1, x, arg3);
+void test__std__ifstream__get__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::ifstream::get(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__istream__getline__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::istream::getline(arg1, arg2, x);
+void test__std__ifstream__get__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::ifstream::get(NULL, arg2, arg3);
 }
 
-void test__std__ifstream__getline__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::ifstream::getline(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__ifstream__get__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ifstream::get(arg1, x, arg3);
 }
 
-void test__std__ifstream__getline__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::ifstream::getline(NULL, arg2, arg3);
+void test__std__ifstream__get__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ifstream::get(arg1, arg2, x);
 }
 
-void test__std__ifstream__getline__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::ifstream::getline(arg1, x, arg3);
+void test__itoa__noreturn() {
+  int x = 1;
+  if (cond) { x=100; itoa(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ifstream__getline__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::ifstream::getline(arg1, arg2, x);
+void test__itoa__leakignore() {
+  char *p = malloc(10); *p=0;
+  itoa(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__std__istream__get__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::istream::get(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__itoa__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  itoa(x, arg2, arg3);
 }
 
-void test__std__istream__get__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::istream::get(NULL, arg2, arg3);
+void test__itoa__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  itoa(arg1, NULL, arg3);
 }
 
-void test__std__istream__get__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::istream::get(arg1, x, arg3);
+void test__itoa__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  itoa(arg1, arg2, x);
 }
 
-void test__std__istream__get__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::istream::get(arg1, arg2, x);
+void test__std__string__erase__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::string::erase(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ifstream__get__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::ifstream::get(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__string__erase__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::string::erase(x, arg2);
 }
 
-void test__std__ifstream__get__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    std::ifstream::get(NULL, arg2, arg3);
+void test__std__string__erase__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::string::erase(arg1, x);
 }
 
-void test__std__ifstream__get__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::ifstream::get(arg1, x, arg3);
+void test__std__wstring__erase__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wstring::erase(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__ifstream__get__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::ifstream::get(arg1, arg2, x);
+void test__std__wstring__erase__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wstring::erase(x, arg2);
 }
 
-void test__itoa__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        itoa(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wstring__erase__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wstring::erase(arg1, x);
 }
 
-void test__itoa__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    itoa(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__std__basic_string__erase__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::basic_string::erase(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__itoa__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    itoa(x, arg2, arg3);
+void test__std__basic_string__erase__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::basic_string::erase(x, arg2);
 }
 
-void test__itoa__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    itoa(arg1, NULL, arg3);
+void test__std__basic_string__erase__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::basic_string::erase(arg1, x);
 }
 
-void test__itoa__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    itoa(arg1, arg2, x);
-}
-
-void test__std__string__erase__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::string::erase(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__string__reserve__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::string::reserve(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__string__erase__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::string::erase(x, arg2);
-}
-
-void test__std__string__erase__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::string::erase(arg1, x);
-}
-
-void test__std__wstring__erase__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wstring::erase(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__wstring__erase__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wstring::erase(x, arg2);
-}
-
-void test__std__wstring__erase__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wstring::erase(arg1, x);
-}
-
-void test__std__basic_string__erase__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::basic_string::erase(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__string__reserve__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::string::reserve(x);
 }
-
-void test__std__basic_string__erase__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::basic_string::erase(x, arg2);
+
+void test__std__wstring__reserve__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::wstring::reserve(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__basic_string__erase__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::basic_string::erase(arg1, x);
-}
-
-void test__std__string__reserve__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::string::reserve(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__wstring__reserve__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wstring::reserve(x);
 }
 
-void test__std__string__reserve__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::string::reserve(x);
+void test__std__basic_string__reserve__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::basic_string::reserve(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__std__wstring__reserve__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::wstring::reserve(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__std__wstring__reserve__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::wstring::reserve(x);
-}
-
-void test__std__basic_string__reserve__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::basic_string::reserve(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__std__basic_string__reserve__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::basic_string::reserve(x);
 }
 
-void test__std__basic_string__reserve__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::basic_string::reserve(x);
-}
+void test__std__adjacent_find__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::adjacent_find(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__std__adjacent_find__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::adjacent_find(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__adjacent_find__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::adjacent_find(arg1, arg2, arg3);
 }
 
-void test__std__adjacent_find__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::adjacent_find(arg1, arg2, arg3);
+void test__std__adjacent_find__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::adjacent_find(x, arg2, arg3);
 }
 
-void test__std__adjacent_find__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::adjacent_find(x, arg2, arg3);
-}
-
-void test__std__adjacent_find__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::adjacent_find(arg1, x, arg3);
+void test__std__adjacent_find__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::adjacent_find(arg1, x, arg3);
 }
 
-void test__std__adjacent_find__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::adjacent_find(arg1, arg2, x);
+void test__std__adjacent_find__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::adjacent_find(arg1, arg2, x);
 }
 
-void test__std__find__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::find(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__find__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::find(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__find__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::find(arg1, arg2, arg3);
+void test__std__find__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::find(arg1, arg2, arg3);
 }
 
-void test__std__find__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find(x, arg2, arg3);
+void test__std__find__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find(x, arg2, arg3);
 }
 
-void test__std__find__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find(arg1, x, arg3);
+void test__std__find__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find(arg1, x, arg3);
 }
 
-void test__std__find__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find(arg1, arg2, x);
+void test__std__find__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find(arg1, arg2, x);
 }
 
-void test__std__find_if__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::find_if(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__find_if__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::find_if(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__find_if__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::find_if(arg1, arg2, arg3);
+void test__std__find_if__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::find_if(arg1, arg2, arg3);
 }
 
-void test__std__find_if__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_if(x, arg2, arg3);
+void test__std__find_if__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_if(x, arg2, arg3);
 }
 
-void test__std__find_if__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_if(arg1, x, arg3);
+void test__std__find_if__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_if(arg1, x, arg3);
 }
 
-void test__std__find_if__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_if(arg1, arg2, x);
+void test__std__find_if__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_if(arg1, arg2, x);
 }
 
-void test__std__find_if_not__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::find_if_not(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__find_if_not__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::find_if_not(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__find_if_not__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::find_if_not(arg1, arg2, arg3);
+void test__std__find_if_not__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::find_if_not(arg1, arg2, arg3);
 }
 
-void test__std__find_if_not__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_if_not(x, arg2, arg3);
+void test__std__find_if_not__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_if_not(x, arg2, arg3);
 }
 
-void test__std__find_if_not__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_if_not(arg1, x, arg3);
+void test__std__find_if_not__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_if_not(arg1, x, arg3);
 }
 
-void test__std__find_if_not__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_if_not(arg1, arg2, x);
+void test__std__find_if_not__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_if_not(arg1, arg2, x);
 }
 
-void test__std__copy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::copy(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__copy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::copy(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__copy__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::copy(x, arg2, arg3);
+void test__std__copy__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::copy(x, arg2, arg3);
 }
 
-void test__std__copy__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::copy(arg1, x, arg3);
+void test__std__copy__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::copy(arg1, x, arg3);
 }
 
-void test__std__copy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::copy(arg1, arg2, x);
+void test__std__copy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::copy(arg1, arg2, x);
 }
 
-void test__std__all_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::all_of(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__all_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::all_of(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__all_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::all_of(arg1, arg2, arg3);
+void test__std__all_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::all_of(arg1, arg2, arg3);
 }
 
-void test__std__all_of__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::all_of(x, arg2, arg3);
+void test__std__all_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::all_of(x, arg2, arg3);
 }
 
-void test__std__all_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::all_of(arg1, x, arg3);
+void test__std__all_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::all_of(arg1, x, arg3);
 }
 
-void test__std__all_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::all_of(arg1, arg2, x);
+void test__std__all_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::all_of(arg1, arg2, x);
 }
 
-void test__std__any_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::any_of(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__any_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::any_of(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__any_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::any_of(arg1, arg2, arg3);
+void test__std__any_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::any_of(arg1, arg2, arg3);
 }
 
-void test__std__any_of__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::any_of(x, arg2, arg3);
+void test__std__any_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::any_of(x, arg2, arg3);
 }
 
-void test__std__any_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::any_of(arg1, x, arg3);
+void test__std__any_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::any_of(arg1, x, arg3);
 }
 
-void test__std__any_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::any_of(arg1, arg2, x);
+void test__std__any_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::any_of(arg1, arg2, x);
 }
 
-void test__std__none_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::none_of(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__none_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::none_of(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__none_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::none_of(arg1, arg2, arg3);
+void test__std__none_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::none_of(arg1, arg2, arg3);
 }
 
-void test__std__none_of__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::none_of(x, arg2, arg3);
+void test__std__none_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::none_of(x, arg2, arg3);
 }
 
-void test__std__none_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::none_of(arg1, x, arg3);
+void test__std__none_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::none_of(arg1, x, arg3);
 }
 
-void test__std__none_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::none_of(arg1, arg2, x);
+void test__std__none_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::none_of(arg1, arg2, x);
 }
 
-void test__std__count__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::count(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__count__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::count(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__count__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::count(arg1, arg2, arg3);
+void test__std__count__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::count(arg1, arg2, arg3);
 }
 
-void test__std__count__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::count(x, arg2, arg3);
+void test__std__count__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::count(x, arg2, arg3);
 }
 
-void test__std__count__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::count(arg1, x, arg3);
+void test__std__count__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::count(arg1, x, arg3);
 }
 
-void test__std__count__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::count(arg1, arg2, x);
+void test__std__count__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::count(arg1, arg2, x);
 }
 
-void test__std__count_if__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::count_if(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__count_if__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::count_if(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__count_if__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::count_if(arg1, arg2, arg3);
+void test__std__count_if__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::count_if(arg1, arg2, arg3);
 }
 
-void test__std__count_if__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::count_if(x, arg2, arg3);
+void test__std__count_if__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::count_if(x, arg2, arg3);
 }
 
-void test__std__count_if__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::count_if(arg1, x, arg3);
+void test__std__count_if__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::count_if(arg1, x, arg3);
 }
 
-void test__std__count_if__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::count_if(arg1, arg2, x);
+void test__std__count_if__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::count_if(arg1, arg2, x);
 }
 
-void test__std__for_each__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::for_each(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__for_each__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::for_each(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__for_each__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::for_each(x, arg2, arg3);
+void test__std__for_each__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::for_each(x, arg2, arg3);
 }
 
-void test__std__for_each__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::for_each(arg1, x, arg3);
+void test__std__for_each__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::for_each(arg1, x, arg3);
 }
 
-void test__std__for_each__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::for_each(arg1, arg2, x);
+void test__std__for_each__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::for_each(arg1, arg2, x);
 }
 
-void test__std__search_n__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::search_n(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__search_n__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::search_n(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__search_n__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::search_n(arg1, arg2, arg3, arg4, arg5);
+void test__std__search_n__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::search_n(arg1, arg2, arg3, arg4, arg5);
 }
 
-void test__std__search_n__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::search_n(x, arg2, arg3, arg4, arg5);
+void test__std__search_n__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::search_n(x, arg2, arg3, arg4, arg5);
 }
 
-void test__std__search_n__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::search_n(arg1, x, arg3, arg4, arg5);
+void test__std__search_n__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::search_n(arg1, x, arg3, arg4, arg5);
 }
 
-void test__std__search_n__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::search_n(arg1, arg2, x, arg4, arg5);
+void test__std__search_n__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::search_n(arg1, arg2, x, arg4, arg5);
 }
 
-void test__std__search_n__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::search_n(arg1, arg2, arg3, x, arg5);
+void test__std__search_n__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::search_n(arg1, arg2, arg3, x, arg5);
 }
 
-void test__std__find_end__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::find_end(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__find_end__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::find_end(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__find_end__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::find_end(arg1, arg2, arg3, arg4, arg5);
+void test__std__find_end__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::find_end(arg1, arg2, arg3, arg4, arg5);
 }
 
-void test__std__find_end__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_end(x, arg2, arg3, arg4, arg5);
+void test__std__find_end__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_end(x, arg2, arg3, arg4, arg5);
 }
 
-void test__std__find_end__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_end(arg1, x, arg3, arg4, arg5);
+void test__std__find_end__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_end(arg1, x, arg3, arg4, arg5);
 }
 
-void test__std__find_end__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_end(arg1, arg2, x, arg4, arg5);
+void test__std__find_end__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_end(arg1, arg2, x, arg4, arg5);
 }
 
-void test__std__find_end__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_end(arg1, arg2, arg3, x, arg5);
+void test__std__find_end__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_end(arg1, arg2, arg3, x, arg5);
 }
 
-void test__std__find_end__arg5__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = std::find_end(arg1, arg2, arg3, arg4, !x);
+void test__std__find_end__arg5__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::find_end(arg1, arg2, arg3, arg4, !x);
 }
 
-void test__std__find_end__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_end(arg1, arg2, arg3, arg4, x);
+void test__std__find_end__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_end(arg1, arg2, arg3, arg4, x);
 }
 
-void test__std__find_first_of__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::find_first_of(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__find_first_of__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::find_first_of(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__find_first_of__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::find_first_of(arg1, arg2, arg3, arg4, arg5);
+void test__std__find_first_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::find_first_of(arg1, arg2, arg3, arg4, arg5);
 }
 
-void test__std__find_first_of__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_first_of(x, arg2, arg3, arg4, arg5);
+void test__std__find_first_of__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_first_of(x, arg2, arg3, arg4, arg5);
 }
 
-void test__std__find_first_of__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_first_of(arg1, x, arg3, arg4, arg5);
+void test__std__find_first_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_first_of(arg1, x, arg3, arg4, arg5);
 }
 
-void test__std__find_first_of__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_first_of(arg1, arg2, x, arg4, arg5);
+void test__std__find_first_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_first_of(arg1, arg2, x, arg4, arg5);
 }
 
-void test__std__find_first_of__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_first_of(arg1, arg2, arg3, x, arg5);
+void test__std__find_first_of__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_first_of(arg1, arg2, arg3, x, arg5);
 }
 
-void test__std__find_first_of__arg5__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = std::find_first_of(arg1, arg2, arg3, arg4, !x);
+void test__std__find_first_of__arg5__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::find_first_of(arg1, arg2, arg3, arg4, !x);
 }
 
-void test__std__find_first_of__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::find_first_of(arg1, arg2, arg3, arg4, x);
+void test__std__find_first_of__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_first_of(arg1, arg2, arg3, arg4, x);
 }
 
-void test__std__search__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::search(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__search__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::search(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__search__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::search(arg1, arg2, arg3, arg4, arg5);
+void test__std__search__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::search(arg1, arg2, arg3, arg4, arg5);
 }
 
-void test__std__search__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::search(x, arg2, arg3, arg4, arg5);
+void test__std__search__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::search(x, arg2, arg3, arg4, arg5);
 }
 
-void test__std__search__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::search(arg1, x, arg3, arg4, arg5);
+void test__std__search__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::search(arg1, x, arg3, arg4, arg5);
 }
 
-void test__std__search__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::search(arg1, arg2, x, arg4, arg5);
+void test__std__search__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::search(arg1, arg2, x, arg4, arg5);
 }
 
-void test__std__search__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::search(arg1, arg2, arg3, x, arg5);
+void test__std__search__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::search(arg1, arg2, arg3, x, arg5);
 }
 
-void test__std__search__arg5__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = std::search(arg1, arg2, arg3, arg4, !x);
+void test__std__search__arg5__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::search(arg1, arg2, arg3, arg4, !x);
 }
 
-void test__std__search__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::search(arg1, arg2, arg3, arg4, x);
+void test__std__search__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::search(arg1, arg2, arg3, arg4, x);
 }
 
-void test__std__inplace_merge__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        std::inplace_merge(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__inplace_merge__noreturn() {
+  int x = 1;
+  if (cond) { x=100; std::inplace_merge(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__inplace_merge__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::inplace_merge(x, arg2, arg3);
+void test__std__inplace_merge__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::inplace_merge(x, arg2, arg3);
 }
 
-void test__std__inplace_merge__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::inplace_merge(arg1, x, arg3);
+void test__std__inplace_merge__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::inplace_merge(arg1, x, arg3);
 }
 
-void test__std__inplace_merge__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    std::inplace_merge(arg1, arg2, x);
+void test__std__inplace_merge__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::inplace_merge(arg1, arg2, x);
 }
 
-void test__std__equal__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::equal(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__equal__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::equal(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__equal__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::equal(arg1, arg2, arg3);
+void test__std__equal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::equal(arg1, arg2, arg3);
 }
 
-void test__std__equal__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::equal(x, arg2, arg3);
+void test__std__equal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::equal(x, arg2, arg3);
 }
 
-void test__std__equal__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::equal(arg1, x, arg3);
+void test__std__equal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::equal(arg1, x, arg3);
 }
 
-void test__std__equal__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::equal(arg1, arg2, x);
+void test__std__equal__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::equal(arg1, arg2, x);
 }
 
-void test__std__is_permutation__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::is_permutation(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__is_permutation__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::is_permutation(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__is_permutation__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::is_permutation(arg1, arg2, arg3);
+void test__std__is_permutation__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::is_permutation(arg1, arg2, arg3);
 }
 
-void test__std__is_permutation__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::is_permutation(x, arg2, arg3);
+void test__std__is_permutation__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::is_permutation(x, arg2, arg3);
 }
 
-void test__std__is_permutation__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::is_permutation(arg1, x, arg3);
+void test__std__is_permutation__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::is_permutation(arg1, x, arg3);
 }
 
-void test__std__is_permutation__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::is_permutation(arg1, arg2, x);
+void test__std__is_permutation__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::is_permutation(arg1, arg2, x);
 }
 
-void test__std__mismatch__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = std::mismatch(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__std__mismatch__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = std::mismatch(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__std__mismatch__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    std::mismatch(arg1, arg2, arg3);
+void test__std__mismatch__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::mismatch(arg1, arg2, arg3);
 }
 
-void test__std__mismatch__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::mismatch(x, arg2, arg3);
+void test__std__mismatch__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::mismatch(x, arg2, arg3);
 }
 
-void test__std__mismatch__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::mismatch(arg1, x, arg3);
+void test__std__mismatch__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::mismatch(arg1, x, arg3);
 }
 
-void test__std__mismatch__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = std::mismatch(arg1, arg2, x);
+void test__std__mismatch__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::mismatch(arg1, arg2, x);
 }
 
-void test__offsetof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = offsetof(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__offsetof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = offsetof(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__offsetof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    offsetof(arg1, arg2);
+void test__offsetof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  offsetof(arg1, arg2);
 }
 
-void test__offsetof__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = offsetof(p, arg2);
-    // cppcheck-suppress memleak
+void test__offsetof__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = offsetof(p, arg2);
+  // cppcheck-suppress memleak
 }
 
diff --git a/test/cfg/generated-cfg-tests-windows.cpp b/test/cfg/generated-cfg-tests-windows.cpp
index a30d34a16..c78396724 100644
--- a/test/cfg/generated-cfg-tests-windows.cpp
+++ b/test/cfg/generated-cfg-tests-windows.cpp
@@ -8,18125 +8,14090 @@
 // => 'unmatched suppression' warnings are false negatives.
 //
 
-void test__RtlCompareMemory__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = RtlCompareMemory(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RtlCompareMemory__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = RtlCompareMemory(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__RtlCompareMemory__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    RtlCompareMemory(arg1, arg2, arg3);
+void test__RtlCompareMemory__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  RtlCompareMemory(arg1, arg2, arg3);
 }
 
-void test__RtlCompareMemory__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = RtlCompareMemory(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__RtlCompareMemory__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = RtlCompareMemory(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__RtlCompareMemory__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = RtlCompareMemory(NULL, arg2, arg3);
+void test__RtlCompareMemory__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = RtlCompareMemory(NULL, arg2, arg3);
 }
 
-void test__RtlCompareMemory__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = RtlCompareMemory(x, arg2, arg3);
+void test__RtlCompareMemory__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = RtlCompareMemory(x, arg2, arg3);
 }
 
-void test__RtlCompareMemory__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = RtlCompareMemory(arg1, NULL, arg3);
+void test__RtlCompareMemory__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = RtlCompareMemory(arg1, NULL, arg3);
 }
 
-void test__RtlCompareMemory__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = RtlCompareMemory(arg1, x, arg3);
+void test__RtlCompareMemory__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = RtlCompareMemory(arg1, x, arg3);
 }
 
-void test__RtlCompareMemory__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = RtlCompareMemory(arg1, arg2, !x);
+void test__RtlCompareMemory__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = RtlCompareMemory(arg1, arg2, !x);
 }
 
-void test__RtlCopyBytes__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RtlCopyBytes(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RtlCopyBytes__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RtlCopyBytes(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__RtlCopyBytes__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RtlCopyBytes(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__RtlCopyBytes__leakignore() {
+  char *p = malloc(10); *p=0;
+  RtlCopyBytes(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__RtlCopyBytes__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    RtlCopyBytes(NULL, arg2, arg3);
+void test__RtlCopyBytes__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  RtlCopyBytes(NULL, arg2, arg3);
 }
 
-void test__RtlCopyBytes__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    RtlCopyBytes(arg1, NULL, arg3);
+void test__RtlCopyBytes__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  RtlCopyBytes(arg1, NULL, arg3);
 }
 
-void test__RtlCopyBytes__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    RtlCopyBytes(arg1, x, arg3);
+void test__RtlCopyBytes__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  RtlCopyBytes(arg1, x, arg3);
 }
 
-void test__RtlCopyBytes__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    RtlCopyBytes(arg1, arg2, !x);
+void test__RtlCopyBytes__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  RtlCopyBytes(arg1, arg2, !x);
 }
 
-void test__RtlFillBytes__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RtlFillBytes(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RtlFillBytes__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RtlFillBytes(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__RtlFillBytes__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RtlFillBytes(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__RtlFillBytes__leakignore() {
+  char *p = malloc(10); *p=0;
+  RtlFillBytes(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__RtlFillBytes__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    RtlFillBytes(NULL, arg2, arg3);
+void test__RtlFillBytes__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  RtlFillBytes(NULL, arg2, arg3);
 }
 
-void test__RtlFillBytes__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    RtlFillBytes(arg1, !x, arg3);
+void test__RtlFillBytes__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  RtlFillBytes(arg1, !x, arg3);
 }
 
-void test__RtlFillBytes__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RtlFillBytes(arg1, arg2, x);
+void test__RtlFillBytes__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RtlFillBytes(arg1, arg2, x);
 }
 
-void test__RtlSecureZeroMemory__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RtlSecureZeroMemory(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RtlSecureZeroMemory__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RtlSecureZeroMemory(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__RtlSecureZeroMemory__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RtlSecureZeroMemory(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__RtlSecureZeroMemory__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    RtlSecureZeroMemory(NULL, arg2);
+void test__RtlSecureZeroMemory__leakignore() {
+  char *p = malloc(10); *p=0;
+  RtlSecureZeroMemory(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__RtlSecureZeroMemory__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    RtlSecureZeroMemory(arg1, !x);
-}
+void test__RtlSecureZeroMemory__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  RtlSecureZeroMemory(NULL, arg2);
+}
+
+void test__RtlSecureZeroMemory__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  RtlSecureZeroMemory(arg1, !x);
+}
+
+void test__RtlZeroBytes__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RtlZeroBytes(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RtlZeroBytes__leakignore() {
+  char *p = malloc(10); *p=0;
+  RtlZeroBytes(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__RtlZeroBytes__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  RtlZeroBytes(NULL, arg2);
+}
+
+void test__RtlZeroBytes__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  RtlZeroBytes(arg1, !x);
+}
+
+void test__KeBugCheck__noreturn() {
+  int x = 1;
+  if (cond) { x=100; KeBugCheck(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__KeBugCheckEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; KeBugCheckEx(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CString__Format__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CString::Format(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CString__Format__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CString::Format(x);
+}
+
+void test__CString__AppendFormat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CString::AppendFormat(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CString__AppendFormat__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CString::AppendFormat(x);
+}
+
+void test__printf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; printf_s(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__printf_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  printf_s(p);
+  // cppcheck-suppress memleak
+}
+
+void test__printf_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  printf_s(NULL);
+}
+
+void test__printf_s__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  printf_s(x);
+}
+
+void test__wprintf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wprintf_s(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wprintf_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  wprintf_s(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wprintf_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wprintf_s(NULL);
+}
+
+void test__wprintf_s__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wprintf_s(x);
+}
+
+void test__fprintf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fprintf_s(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fprintf_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  fprintf_s(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fprintf_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fprintf_s(arg1, NULL);
+}
+
+void test__fprintf_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fprintf_s(arg1, x);
+}
+
+void test__fwprintf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fwprintf_s(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fwprintf_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  fwprintf_s(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fwprintf_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fwprintf_s(arg1, NULL);
+}
+
+void test__fwprintf_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fwprintf_s(arg1, x);
+}
+
+void test___snprintf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _snprintf_s(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___snprintf_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  _snprintf_s(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___snprintf_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _snprintf_s(arg1, arg2, arg3, NULL);
+}
+
+void test___snprintf_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _snprintf_s(arg1, arg2, arg3, x);
+}
+
+void test___snwprintf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _snwprintf_s(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___snwprintf_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  _snwprintf_s(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___snwprintf_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _snwprintf_s(arg1, arg2, arg3, NULL);
+}
+
+void test___snwprintf_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _snwprintf_s(arg1, arg2, arg3, x);
+}
+
+void test__DbgPrint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; DbgPrint(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__DbgPrint__leakignore() {
+  char *p = malloc(10); *p=0;
+  DbgPrint(p);
+  // cppcheck-suppress memleak
+}
+
+void test__DbgPrint__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DbgPrint(NULL);
+}
+
+void test__DbgPrint__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DbgPrint(x);
+}
+
+void test__DbgPrintEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; DbgPrintEx(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__DbgPrintEx__leakignore() {
+  char *p = malloc(10); *p=0;
+  DbgPrintEx(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__DbgPrintEx__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  DbgPrintEx(arg1, arg2, NULL);
+}
+
+void test__DbgPrintEx__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DbgPrintEx(arg1, arg2, x);
+}
+
+void test__vDbgPrintEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vDbgPrintEx(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vDbgPrintEx__leakignore() {
+  char *p = malloc(10); *p=0;
+  vDbgPrintEx(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__vDbgPrintEx__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  vDbgPrintEx(arg1, arg2, NULL);
+}
+
+void test__vDbgPrintEx__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vDbgPrintEx(arg1, arg2, x);
+}
+
+void test__vDbgPrintExWithPrefix__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vDbgPrintExWithPrefix(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vDbgPrintExWithPrefix__leakignore() {
+  char *p = malloc(10); *p=0;
+  vDbgPrintExWithPrefix(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__vDbgPrintExWithPrefix__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  vDbgPrintExWithPrefix(arg1, arg2, arg3, NULL);
+}
+
+void test__vDbgPrintExWithPrefix__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vDbgPrintExWithPrefix(arg1, arg2, arg3, x);
+}
+
+void test__scanf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; scanf_s(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__scanf_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  scanf_s(NULL);
+}
+
+void test__scanf_s__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  scanf_s(x);
+}
+
+void test__wscanf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wscanf_s(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wscanf_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wscanf_s(NULL);
+}
+
+void test__wscanf_s__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wscanf_s(x);
+}
+
+void test__sscanf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sscanf_s(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__RtlZeroBytes__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RtlZeroBytes(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__sscanf_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  sscanf_s(arg1, NULL);
 }
 
-void test__RtlZeroBytes__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RtlZeroBytes(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__RtlZeroBytes__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    RtlZeroBytes(NULL, arg2);
+void test__sscanf_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  sscanf_s(arg1, x);
 }
-
-void test__RtlZeroBytes__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    RtlZeroBytes(arg1, !x);
-}
-
-void test__KeBugCheck__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        KeBugCheck();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__KeBugCheckEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        KeBugCheckEx();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__fscanf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fscanf_s(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CString__Format__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CString::Format(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__CString__Format__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CString::Format(x);
-}
-
-void test__CString__AppendFormat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CString::AppendFormat(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__CString__AppendFormat__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CString::AppendFormat(x);
-}
-
-void test__printf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        printf_s(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__printf_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    printf_s(p);
-    // cppcheck-suppress memleak
-}
-
-void test__printf_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    printf_s(NULL);
-}
-
-void test__printf_s__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    printf_s(x);
-}
-
-void test__wprintf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wprintf_s(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wprintf_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wprintf_s(p);
-    // cppcheck-suppress memleak
-}
-
-void test__wprintf_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wprintf_s(NULL);
-}
-
-void test__wprintf_s__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wprintf_s(x);
+void test__fscanf_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fscanf_s(arg1, NULL);
 }
-
-void test__fprintf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fprintf_s(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__fscanf_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fscanf_s(arg1, x);
 }
-
-void test__fprintf_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fprintf_s(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__fprintf_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fprintf_s(arg1, NULL);
+
+void test__fwscanf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; fwscanf_s(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fprintf_s__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fprintf_s(arg1, x);
+void test__fwscanf_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fwscanf_s(arg1, NULL);
 }
 
-void test__fwprintf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fwprintf_s(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__fwscanf_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fwscanf_s(arg1, x);
 }
 
-void test__fwprintf_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    fwprintf_s(p, arg2);
-    // cppcheck-suppress memleak
+void test__swscanf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; swscanf_s(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fwprintf_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fwprintf_s(arg1, NULL);
+void test__swscanf_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  swscanf_s(arg1, NULL);
 }
 
-void test__fwprintf_s__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fwprintf_s(arg1, x);
+void test__swscanf_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  swscanf_s(arg1, x);
 }
 
-void test___snprintf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _snprintf_s(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CloseHandle__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CloseHandle(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___snprintf_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _snprintf_s(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__CloseHandle__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CloseHandle(x);
 }
 
-void test___snprintf_s__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _snprintf_s(arg1, arg2, arg3, NULL);
+void test__OpenFile__noreturn() {
+  int x = 1;
+  if (cond) { x=100; OpenFile(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___snprintf_s__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _snprintf_s(arg1, arg2, arg3, x);
+void test__OpenFile__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenFile(NULL, arg2, arg3);
 }
 
-void test___snwprintf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _snwprintf_s(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__OpenFile__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenFile(x, arg2, arg3);
 }
 
-void test___snwprintf_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _snwprintf_s(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__OpenFile__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenFile(arg1, arg2, x);
 }
 
-void test___snwprintf_s__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _snwprintf_s(arg1, arg2, arg3, NULL);
+void test__BuildCommDCB__noreturn() {
+  int x = 1;
+  if (cond) { x=100; BuildCommDCB(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___snwprintf_s__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _snwprintf_s(arg1, arg2, arg3, x);
+void test__BuildCommDCB__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  BuildCommDCB(x, arg2);
 }
 
-void test__DbgPrint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        DbgPrint(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__BuildCommDCBAndTimeouts__noreturn() {
+  int x = 1;
+  if (cond) { x=100; BuildCommDCBAndTimeouts(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__DbgPrint__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    DbgPrint(p);
-    // cppcheck-suppress memleak
+void test__BuildCommDCBAndTimeouts__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  BuildCommDCBAndTimeouts(x, arg2, arg3);
 }
 
-void test__DbgPrint__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    DbgPrint(NULL);
+void test__WriteFile__noreturn() {
+  int x = 1;
+  if (cond) { x=100; WriteFile(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__DbgPrint__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    DbgPrint(x);
+void test__WriteFile__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WriteFile(x, arg2, arg3, arg4, arg5);
 }
 
-void test__DbgPrintEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        DbgPrintEx(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__WriteFile__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WriteFile(arg1, x, arg3, arg4, arg5);
 }
 
-void test__DbgPrintEx__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    DbgPrintEx(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__WriteFile__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WriteFile(arg1, arg2, x, arg4, arg5);
 }
 
-void test__DbgPrintEx__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    DbgPrintEx(arg1, arg2, NULL);
+void test__ReadFile__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ReadFile(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__DbgPrintEx__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    DbgPrintEx(arg1, arg2, x);
+void test__ReadFile__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ReadFile(x, arg2, arg3, arg4, arg5);
 }
 
-void test__vDbgPrintEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vDbgPrintEx(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ReadFile__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  ReadFile(arg1, NULL, arg3, arg4, arg5);
 }
 
-void test__vDbgPrintEx__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vDbgPrintEx(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__ReadFile__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ReadFile(arg1, arg2, x, arg4, arg5);
 }
 
-void test__vDbgPrintEx__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vDbgPrintEx(arg1, arg2, NULL);
+void test__CreateFile__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateFile(arg1, arg2, arg3, arg4, arg5, arg6, arg7); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__vDbgPrintEx__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    vDbgPrintEx(arg1, arg2, x);
+void test__CreateFile__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateFile(x, arg2, arg3, arg4, arg5, arg6, arg7);
 }
 
-void test__vDbgPrintExWithPrefix__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vDbgPrintExWithPrefix(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateFile__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateFile(arg1, x, arg3, arg4, arg5, arg6, arg7);
 }
 
-void test__vDbgPrintExWithPrefix__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vDbgPrintExWithPrefix(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__CreateFile__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateFile(arg1, arg2, x, arg4, arg5, arg6, arg7);
 }
 
-void test__vDbgPrintExWithPrefix__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vDbgPrintExWithPrefix(arg1, arg2, arg3, NULL);
+void test__CreateFile__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateFile(arg1, arg2, arg3, x, arg5, arg6, arg7);
 }
 
-void test__vDbgPrintExWithPrefix__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    vDbgPrintExWithPrefix(arg1, arg2, arg3, x);
+void test__CreateFile__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateFile(arg1, arg2, arg3, arg4, x, arg6, arg7);
 }
 
-void test__scanf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        scanf_s(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateFile__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateFile(arg1, arg2, arg3, arg4, arg5, x, arg7);
 }
 
-void test__scanf_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    scanf_s(NULL);
+void test__CreateFile__arg7__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateFile(arg1, arg2, arg3, arg4, arg5, arg6, x);
 }
 
-void test__scanf_s__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    scanf_s(x);
+void test__SetCommTimeouts__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetCommTimeouts(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wscanf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wscanf_s(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SetCommTimeouts__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetCommTimeouts(x, arg2);
 }
 
-void test__wscanf_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wscanf_s(NULL);
+void test__SetCommTimeouts__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetCommTimeouts(arg1, x);
 }
 
-void test__wscanf_s__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wscanf_s(x);
+void test__SetCommState__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetCommState(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sscanf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sscanf_s(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SetCommState__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetCommState(x, arg2);
 }
 
-void test__sscanf_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    sscanf_s(arg1, NULL);
+void test__SetCommState__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetCommState(arg1, x);
 }
 
-void test__sscanf_s__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    sscanf_s(arg1, x);
-}
-
-void test__fscanf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fscanf_s(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbstok__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _mbstok(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__fscanf_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fscanf_s(arg1, NULL);
+void test___mbstok__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_mbstok(arg1, arg2) > 10) || (_mbstok(arg1, arg2) < 100)) {}
 }
 
-void test__fscanf_s__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fscanf_s(arg1, x);
+void test___mbstok__leakignore() {
+  char *p = malloc(10); *p=0;
+  _mbstok(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__fwscanf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        fwscanf_s(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbstok__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbstok(x, arg2);
 }
 
-void test__fwscanf_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    fwscanf_s(arg1, NULL);
+void test___mbstok__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbstok(arg1, NULL);
 }
 
-void test__fwscanf_s__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    fwscanf_s(arg1, x);
-}
-
-void test__swscanf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        swscanf_s(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbstok__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbstok(arg1, x);
 }
 
-void test__swscanf_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    swscanf_s(arg1, NULL);
-}
-
-void test__swscanf_s__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    swscanf_s(arg1, x);
-}
-
-void test__CloseHandle__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CloseHandle(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcstok__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tcstok(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CloseHandle__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CloseHandle(x);
+void test___tcstok__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_tcstok(arg1, arg2) > 10) || (_tcstok(arg1, arg2) < 100)) {}
 }
 
-void test__OpenFile__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        OpenFile(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__OpenFile__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    OpenFile(NULL, arg2, arg3);
-}
+void test___tcstok__leakignore() {
+  char *p = malloc(10); *p=0;
+  _tcstok(p, arg2);
+  // cppcheck-suppress memleak
+}
 
-void test__OpenFile__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    OpenFile(x, arg2, arg3);
+void test___tcstok__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcstok(x, arg2);
 }
 
-void test__OpenFile__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenFile(arg1, arg2, x);
+void test___tcstok__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcstok(arg1, NULL);
 }
 
-void test__BuildCommDCB__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        BuildCommDCB(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcstok__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcstok(arg1, x);
 }
 
-void test__BuildCommDCB__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    BuildCommDCB(x, arg2);
+void test___mbstok_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _mbstok_l(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__BuildCommDCBAndTimeouts__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        BuildCommDCBAndTimeouts(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__BuildCommDCBAndTimeouts__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    BuildCommDCBAndTimeouts(x, arg2, arg3);
+void test___mbstok_l__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_mbstok_l(arg1, arg2, arg3) > 10) || (_mbstok_l(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__WriteFile__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        WriteFile(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbstok_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _mbstok_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__WriteFile__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    WriteFile(x, arg2, arg3, arg4, arg5);
+void test___mbstok_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbstok_l(x, arg2, arg3);
 }
 
-void test__WriteFile__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    WriteFile(arg1, x, arg3, arg4, arg5);
+void test___mbstok_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbstok_l(arg1, NULL, arg3);
 }
 
-void test__WriteFile__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    WriteFile(arg1, arg2, x, arg4, arg5);
+void test___mbstok_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbstok_l(arg1, x, arg3);
 }
 
-void test__ReadFile__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ReadFile(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbstok_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbstok_l(arg1, arg2, x);
 }
 
-void test__ReadFile__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ReadFile(x, arg2, arg3, arg4, arg5);
+void test___strtok_s_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _strtok_s_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ReadFile__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ReadFile(arg1, NULL, arg3, arg4, arg5);
+void test___strtok_s_l__pure(int arg1,int arg2,int arg3,int arg4) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_strtok_s_l(arg1, arg2, arg3, arg4) > 10) || (_strtok_s_l(arg1, arg2, arg3, arg4) < 100)) {}
 }
 
-void test__ReadFile__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ReadFile(arg1, arg2, x, arg4, arg5);
+void test___strtok_s_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _strtok_s_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateFile__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateFile(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___strtok_s_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strtok_s_l(x, arg2, arg3, arg4);
 }
 
-void test__CreateFile__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateFile(x, arg2, arg3, arg4, arg5, arg6, arg7);
+void test___strtok_s_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _strtok_s_l(arg1, NULL, arg3, arg4);
 }
 
-void test__CreateFile__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateFile(arg1, x, arg3, arg4, arg5, arg6, arg7);
+void test___strtok_s_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _strtok_s_l(arg1, x, arg3, arg4);
 }
 
-void test__CreateFile__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateFile(arg1, arg2, x, arg4, arg5, arg6, arg7);
+void test___strtok_s_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _strtok_s_l(arg1, arg2, NULL, arg4);
 }
 
-void test__CreateFile__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateFile(arg1, arg2, arg3, x, arg5, arg6, arg7);
+void test___strtok_s_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strtok_s_l(arg1, arg2, arg3, x);
 }
 
-void test__CreateFile__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateFile(arg1, arg2, arg3, arg4, x, arg6, arg7);
+void test___wcstok_s_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wcstok_s_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateFile__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateFile(arg1, arg2, arg3, arg4, arg5, x, arg7);
+void test___wcstok_s_l__pure(int arg1,int arg2,int arg3,int arg4) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_wcstok_s_l(arg1, arg2, arg3, arg4) > 10) || (_wcstok_s_l(arg1, arg2, arg3, arg4) < 100)) {}
 }
 
-void test__CreateFile__arg7__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateFile(arg1, arg2, arg3, arg4, arg5, arg6, x);
+void test___wcstok_s_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _wcstok_s_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__SetCommTimeouts__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetCommTimeouts(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wcstok_s_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcstok_s_l(x, arg2, arg3, arg4);
 }
 
-void test__SetCommTimeouts__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetCommTimeouts(x, arg2);
+void test___wcstok_s_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcstok_s_l(arg1, NULL, arg3, arg4);
 }
 
-void test__SetCommTimeouts__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetCommTimeouts(arg1, x);
+void test___wcstok_s_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcstok_s_l(arg1, x, arg3, arg4);
 }
 
-void test__SetCommState__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetCommState(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wcstok_s_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcstok_s_l(arg1, arg2, NULL, arg4);
 }
 
-void test__SetCommState__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetCommState(x, arg2);
+void test___wcstok_s_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcstok_s_l(arg1, arg2, arg3, x);
 }
 
-void test__SetCommState__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetCommState(arg1, x);
+void test___mbstok_s_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _mbstok_s_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbstok__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _mbstok(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbstok_s_l__pure(int arg1,int arg2,int arg3,int arg4) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_mbstok_s_l(arg1, arg2, arg3, arg4) > 10) || (_mbstok_s_l(arg1, arg2, arg3, arg4) < 100)) {}
 }
 
-void test___mbstok__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_mbstok(arg1, arg2) > 10) || (_mbstok(arg1, arg2) < 100)) {}
+void test___mbstok_s_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _mbstok_s_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test___mbstok__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _mbstok(p, arg2);
-    // cppcheck-suppress memleak
+void test___mbstok_s_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbstok_s_l(x, arg2, arg3, arg4);
 }
 
-void test___mbstok__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _mbstok(x, arg2);
+void test___mbstok_s_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbstok_s_l(arg1, NULL, arg3, arg4);
 }
 
-void test___mbstok__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbstok(arg1, NULL);
+void test___mbstok_s_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbstok_s_l(arg1, x, arg3, arg4);
 }
 
-void test___mbstok__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _mbstok(arg1, x);
+void test___mbstok_s_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbstok_s_l(arg1, arg2, NULL, arg4);
 }
 
-void test___tcstok__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tcstok(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbstok_s_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbstok_s_l(arg1, arg2, arg3, x);
 }
 
-void test___tcstok__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_tcstok(arg1, arg2) > 10) || (_tcstok(arg1, arg2) < 100)) {}
+void test___tcstok_s_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tcstok_s_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcstok__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _tcstok(p, arg2);
-    // cppcheck-suppress memleak
+void test___tcstok_s_l__pure(int arg1,int arg2,int arg3,int arg4) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_tcstok_s_l(arg1, arg2, arg3, arg4) > 10) || (_tcstok_s_l(arg1, arg2, arg3, arg4) < 100)) {}
 }
 
-void test___tcstok__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _tcstok(x, arg2);
+void test___tcstok_s_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _tcstok_s_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test___tcstok__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcstok(arg1, NULL);
+void test___tcstok_s_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcstok_s_l(x, arg2, arg3, arg4);
 }
 
-void test___tcstok__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tcstok(arg1, x);
+void test___tcstok_s_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcstok_s_l(arg1, NULL, arg3, arg4);
 }
 
-void test___mbstok_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _mbstok_l(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcstok_s_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcstok_s_l(arg1, x, arg3, arg4);
 }
 
-void test___mbstok_l__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_mbstok_l(arg1, arg2, arg3) > 10) || (_mbstok_l(arg1, arg2, arg3) < 100)) {}
+void test___tcstok_s_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcstok_s_l(arg1, arg2, NULL, arg4);
 }
 
-void test___mbstok_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _mbstok_l(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___tcstok_s_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcstok_s_l(arg1, arg2, arg3, x);
 }
 
-void test___mbstok_l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _mbstok_l(x, arg2, arg3);
+void test__strtok_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strtok_s(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbstok_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbstok_l(arg1, NULL, arg3);
+void test__strtok_s__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strtok_s(arg1, arg2, arg3) > 10) || (strtok_s(arg1, arg2, arg3) < 100)) {}
 }
 
-void test___mbstok_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _mbstok_l(arg1, x, arg3);
+void test__strtok_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  strtok_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___mbstok_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _mbstok_l(arg1, arg2, x);
+void test__strtok_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtok_s(x, arg2, arg3);
 }
 
-void test___strtok_s_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _strtok_s_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strtok_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strtok_s(arg1, NULL, arg3);
 }
 
-void test___strtok_s_l__pure(int arg1,int arg2,int arg3,int arg4)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_strtok_s_l(arg1, arg2, arg3, arg4) > 10) || (_strtok_s_l(arg1, arg2, arg3, arg4) < 100)) {}
+void test__strtok_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtok_s(arg1, x, arg3);
 }
 
-void test___strtok_s_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _strtok_s_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__strtok_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  strtok_s(arg1, arg2, NULL);
 }
 
-void test___strtok_s_l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _strtok_s_l(x, arg2, arg3, arg4);
+void test__wcstok_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcstok_s(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___strtok_s_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _strtok_s_l(arg1, NULL, arg3, arg4);
+void test__wcstok_s__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wcstok_s(arg1, arg2, arg3) > 10) || (wcstok_s(arg1, arg2, arg3) < 100)) {}
 }
 
-void test___strtok_s_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _strtok_s_l(arg1, x, arg3, arg4);
+void test__wcstok_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcstok_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___strtok_s_l__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _strtok_s_l(arg1, arg2, NULL, arg4);
+void test__wcstok_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcstok_s(x, arg2, arg3);
 }
 
-void test___strtok_s_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _strtok_s_l(arg1, arg2, arg3, x);
+void test__wcstok_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstok_s(arg1, NULL, arg3);
 }
 
-void test___wcstok_s_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wcstok_s_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcstok_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcstok_s(arg1, x, arg3);
 }
 
-void test___wcstok_s_l__pure(int arg1,int arg2,int arg3,int arg4)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_wcstok_s_l(arg1, arg2, arg3, arg4) > 10) || (_wcstok_s_l(arg1, arg2, arg3, arg4) < 100)) {}
+void test__wcstok_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstok_s(arg1, arg2, NULL);
 }
 
-void test___wcstok_s_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _wcstok_s_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___mbstok_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _mbstok_s(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wcstok_s_l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _wcstok_s_l(x, arg2, arg3, arg4);
+void test___mbstok_s__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_mbstok_s(arg1, arg2, arg3) > 10) || (_mbstok_s(arg1, arg2, arg3) < 100)) {}
 }
 
-void test___wcstok_s_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wcstok_s_l(arg1, NULL, arg3, arg4);
+void test___mbstok_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  _mbstok_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___wcstok_s_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wcstok_s_l(arg1, x, arg3, arg4);
+void test___mbstok_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbstok_s(x, arg2, arg3);
 }
 
-void test___wcstok_s_l__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wcstok_s_l(arg1, arg2, NULL, arg4);
+void test___mbstok_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbstok_s(arg1, NULL, arg3);
 }
 
-void test___wcstok_s_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _wcstok_s_l(arg1, arg2, arg3, x);
+void test___mbstok_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbstok_s(arg1, x, arg3);
 }
 
-void test___mbstok_s_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _mbstok_s_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbstok_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbstok_s(arg1, arg2, NULL);
 }
 
-void test___mbstok_s_l__pure(int arg1,int arg2,int arg3,int arg4)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_mbstok_s_l(arg1, arg2, arg3, arg4) > 10) || (_mbstok_s_l(arg1, arg2, arg3, arg4) < 100)) {}
+void test___tcstok_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tcstok_s(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbstok_s_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _mbstok_s_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___tcstok_s__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_tcstok_s(arg1, arg2, arg3) > 10) || (_tcstok_s(arg1, arg2, arg3) < 100)) {}
 }
 
-void test___mbstok_s_l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _mbstok_s_l(x, arg2, arg3, arg4);
+void test___tcstok_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  _tcstok_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___mbstok_s_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbstok_s_l(arg1, NULL, arg3, arg4);
+void test___tcstok_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcstok_s(x, arg2, arg3);
 }
 
-void test___mbstok_s_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _mbstok_s_l(arg1, x, arg3, arg4);
+void test___tcstok_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcstok_s(arg1, NULL, arg3);
 }
 
-void test___mbstok_s_l__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbstok_s_l(arg1, arg2, NULL, arg4);
+void test___tcstok_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcstok_s(arg1, x, arg3);
 }
 
-void test___mbstok_s_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _mbstok_s_l(arg1, arg2, arg3, x);
+void test___tcstok_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcstok_s(arg1, arg2, NULL);
 }
 
-void test___tcstok_s_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tcstok_s_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___getcwd__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _getcwd(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcstok_s_l__pure(int arg1,int arg2,int arg3,int arg4)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_tcstok_s_l(arg1, arg2, arg3, arg4) > 10) || (_tcstok_s_l(arg1, arg2, arg3, arg4) < 100)) {}
+void test___getcwd__leakignore() {
+  char *p = malloc(10); *p=0;
+  _getcwd(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___tcstok_s_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _tcstok_s_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___getcwd__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _getcwd(x, arg2);
 }
 
-void test___tcstok_s_l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _tcstok_s_l(x, arg2, arg3, arg4);
+void test___getcwd__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _getcwd(arg1, x);
 }
 
-void test___tcstok_s_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcstok_s_l(arg1, NULL, arg3, arg4);
+void test___wgetcwd__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wgetcwd(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcstok_s_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tcstok_s_l(arg1, x, arg3, arg4);
+void test___wgetcwd__leakignore() {
+  char *p = malloc(10); *p=0;
+  _wgetcwd(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___tcstok_s_l__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcstok_s_l(arg1, arg2, NULL, arg4);
+void test___wgetcwd__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wgetcwd(x, arg2);
 }
 
-void test___tcstok_s_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _tcstok_s_l(arg1, arg2, arg3, x);
+void test___wgetcwd__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wgetcwd(arg1, x);
 }
 
-void test__strtok_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strtok_s(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SHGetFolderPath__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SHGetFolderPath(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strtok_s__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((strtok_s(arg1, arg2, arg3) > 10) || (strtok_s(arg1, arg2, arg3) < 100)) {}
+void test__SHGetFolderPath__leakignore() {
+  char *p = malloc(10); *p=0;
+  SHGetFolderPath(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test__strtok_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strtok_s(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__SHGetFolderPath__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPath(x, arg2, arg3, arg4, arg5);
 }
 
-void test__strtok_s__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strtok_s(x, arg2, arg3);
+void test__SHGetFolderPath__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPath(arg1, x, arg3, arg4, arg5);
 }
 
-void test__strtok_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strtok_s(arg1, NULL, arg3);
+void test__SHGetFolderPath__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPath(arg1, arg2, x, arg4, arg5);
 }
 
-void test__strtok_s__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strtok_s(arg1, x, arg3);
+void test__SHGetFolderPath__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPath(arg1, arg2, arg3, x, arg5);
 }
 
-void test__strtok_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strtok_s(arg1, arg2, NULL);
+void test__SHGetFolderPath__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  SHGetFolderPath(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test__wcstok_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcstok_s(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SHGetFolderPathA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SHGetFolderPathA(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcstok_s__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((wcstok_s(arg1, arg2, arg3) > 10) || (wcstok_s(arg1, arg2, arg3) < 100)) {}
+void test__SHGetFolderPathA__leakignore() {
+  char *p = malloc(10); *p=0;
+  SHGetFolderPathA(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test__wcstok_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcstok_s(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__SHGetFolderPathA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathA(x, arg2, arg3, arg4, arg5);
 }
 
-void test__wcstok_s__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wcstok_s(x, arg2, arg3);
+void test__SHGetFolderPathA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathA(arg1, x, arg3, arg4, arg5);
 }
 
-void test__wcstok_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcstok_s(arg1, NULL, arg3);
+void test__SHGetFolderPathA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathA(arg1, arg2, x, arg4, arg5);
 }
 
-void test__wcstok_s__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcstok_s(arg1, x, arg3);
+void test__SHGetFolderPathA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathA(arg1, arg2, arg3, x, arg5);
 }
 
-void test__wcstok_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcstok_s(arg1, arg2, NULL);
+void test__SHGetFolderPathA__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  SHGetFolderPathA(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test___mbstok_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _mbstok_s(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SHGetFolderPathW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SHGetFolderPathW(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbstok_s__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_mbstok_s(arg1, arg2, arg3) > 10) || (_mbstok_s(arg1, arg2, arg3) < 100)) {}
+void test__SHGetFolderPathW__leakignore() {
+  char *p = malloc(10); *p=0;
+  SHGetFolderPathW(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test___mbstok_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _mbstok_s(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__SHGetFolderPathW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathW(x, arg2, arg3, arg4, arg5);
 }
 
-void test___mbstok_s__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _mbstok_s(x, arg2, arg3);
+void test__SHGetFolderPathW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathW(arg1, x, arg3, arg4, arg5);
 }
 
-void test___mbstok_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbstok_s(arg1, NULL, arg3);
+void test__SHGetFolderPathW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathW(arg1, arg2, x, arg4, arg5);
 }
 
-void test___mbstok_s__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _mbstok_s(arg1, x, arg3);
+void test__SHGetFolderPathW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathW(arg1, arg2, arg3, x, arg5);
 }
 
-void test___mbstok_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbstok_s(arg1, arg2, NULL);
+void test__SHGetFolderPathW__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  SHGetFolderPathW(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test___tcstok_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tcstok_s(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RegQueryValueEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RegQueryValueEx(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcstok_s__pure(int arg1,int arg2,int arg3)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_tcstok_s(arg1, arg2, arg3) > 10) || (_tcstok_s(arg1, arg2, arg3) < 100)) {}
+void test__RegQueryValueEx__leakignore() {
+  char *p = malloc(10); *p=0;
+  RegQueryValueEx(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
 }
 
-void test___tcstok_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _tcstok_s(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__RegQueryValueEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueEx(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test___tcstok_s__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _tcstok_s(x, arg2, arg3);
+void test__RegQueryValueEx__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueEx(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test___tcstok_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcstok_s(arg1, NULL, arg3);
+void test__RegQueryValueEx__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueEx(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test___tcstok_s__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tcstok_s(arg1, x, arg3);
+void test__RegQueryValueExA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RegQueryValueExA(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcstok_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcstok_s(arg1, arg2, NULL);
+void test__RegQueryValueExA__leakignore() {
+  char *p = malloc(10); *p=0;
+  RegQueryValueExA(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
 }
 
-void test___getcwd__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _getcwd(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RegQueryValueExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueExA(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test___getcwd__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _getcwd(p, arg2);
-    // cppcheck-suppress memleak
+void test__RegQueryValueExA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueExA(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test___getcwd__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _getcwd(x, arg2);
+void test__RegQueryValueExA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueExA(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test___getcwd__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _getcwd(arg1, x);
+void test__RegQueryValueExW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RegQueryValueExW(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wgetcwd__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wgetcwd(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RegQueryValueExW__leakignore() {
+  char *p = malloc(10); *p=0;
+  RegQueryValueExW(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
 }
 
-void test___wgetcwd__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _wgetcwd(p, arg2);
-    // cppcheck-suppress memleak
+void test__RegQueryValueExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueExW(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test___wgetcwd__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _wgetcwd(x, arg2);
+void test__RegQueryValueExW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueExW(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test___wgetcwd__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _wgetcwd(arg1, x);
+void test__RegQueryValueExW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueExW(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__SHGetFolderPath__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SHGetFolderPath(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RegCloseKey__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RegCloseKey(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SHGetFolderPath__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SHGetFolderPath(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test__RegCloseKey__leakignore() {
+  char *p = malloc(10); *p=0;
+  RegCloseKey(p);
+  // cppcheck-suppress memleak
 }
 
-void test__SHGetFolderPath__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SHGetFolderPath(x, arg2, arg3, arg4, arg5);
+void test__RegCloseKey__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegCloseKey(x);
 }
 
-void test__SHGetFolderPath__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SHGetFolderPath(arg1, x, arg3, arg4, arg5);
+void test___stricmp_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _stricmp_l(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SHGetFolderPath__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SHGetFolderPath(arg1, arg2, x, arg4, arg5);
+void test___stricmp_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _stricmp_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__SHGetFolderPath__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SHGetFolderPath(arg1, arg2, arg3, x, arg5);
+void test___stricmp_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stricmp_l(NULL, arg2, arg3);
 }
 
-void test__SHGetFolderPath__arg5__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SHGetFolderPath(arg1, arg2, arg3, arg4, NULL);
+void test___stricmp_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stricmp_l(x, arg2, arg3);
 }
 
-void test__SHGetFolderPathA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SHGetFolderPathA(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___stricmp_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stricmp_l(arg1, NULL, arg3);
 }
 
-void test__SHGetFolderPathA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SHGetFolderPathA(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test___stricmp_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stricmp_l(arg1, x, arg3);
 }
 
-void test__SHGetFolderPathA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SHGetFolderPathA(x, arg2, arg3, arg4, arg5);
+void test___stricmp_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _stricmp_l(arg1, arg2, x);
 }
 
-void test__SHGetFolderPathA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SHGetFolderPathA(arg1, x, arg3, arg4, arg5);
+void test___wcsicmp_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wcsicmp_l(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SHGetFolderPathA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SHGetFolderPathA(arg1, arg2, x, arg4, arg5);
+void test___wcsicmp_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _wcsicmp_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__SHGetFolderPathA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SHGetFolderPathA(arg1, arg2, arg3, x, arg5);
+void test___wcsicmp_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsicmp_l(NULL, arg2, arg3);
 }
 
-void test__SHGetFolderPathA__arg5__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SHGetFolderPathA(arg1, arg2, arg3, arg4, NULL);
+void test___wcsicmp_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsicmp_l(x, arg2, arg3);
 }
 
-void test__SHGetFolderPathW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SHGetFolderPathW(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wcsicmp_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsicmp_l(arg1, NULL, arg3);
 }
 
-void test__SHGetFolderPathW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SHGetFolderPathW(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test___wcsicmp_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsicmp_l(arg1, x, arg3);
 }
 
-void test__SHGetFolderPathW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SHGetFolderPathW(x, arg2, arg3, arg4, arg5);
+void test___wcsicmp_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsicmp_l(arg1, arg2, x);
 }
 
-void test__SHGetFolderPathW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SHGetFolderPathW(arg1, x, arg3, arg4, arg5);
+void test___mbsicmp_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _mbsicmp_l(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SHGetFolderPathW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SHGetFolderPathW(arg1, arg2, x, arg4, arg5);
+void test___mbsicmp_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _mbsicmp_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__SHGetFolderPathW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SHGetFolderPathW(arg1, arg2, arg3, x, arg5);
+void test___mbsicmp_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsicmp_l(NULL, arg2, arg3);
 }
 
-void test__SHGetFolderPathW__arg5__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SHGetFolderPathW(arg1, arg2, arg3, arg4, NULL);
+void test___mbsicmp_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsicmp_l(x, arg2, arg3);
 }
 
-void test__RegQueryValueEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RegQueryValueEx(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbsicmp_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsicmp_l(arg1, NULL, arg3);
 }
 
-void test__RegQueryValueEx__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RegQueryValueEx(p, arg2, arg3, arg4, arg5, arg6);
-    // cppcheck-suppress memleak
+void test___mbsicmp_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsicmp_l(arg1, x, arg3);
 }
 
-void test__RegQueryValueEx__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegQueryValueEx(x, arg2, arg3, arg4, arg5, arg6);
+void test___mbsicmp_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbsicmp_l(arg1, arg2, x);
 }
 
-void test__RegQueryValueEx__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegQueryValueEx(arg1, arg2, x, arg4, arg5, arg6);
+void test__stricmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; stricmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__RegQueryValueEx__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegQueryValueEx(arg1, arg2, arg3, x, arg5, arg6);
+void test__stricmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  stricmp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__RegQueryValueExA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RegQueryValueExA(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__stricmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  stricmp(NULL, arg2);
 }
 
-void test__RegQueryValueExA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RegQueryValueExA(p, arg2, arg3, arg4, arg5, arg6);
-    // cppcheck-suppress memleak
+void test__stricmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  stricmp(x, arg2);
 }
 
-void test__RegQueryValueExA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegQueryValueExA(x, arg2, arg3, arg4, arg5, arg6);
+void test__stricmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  stricmp(arg1, NULL);
 }
 
-void test__RegQueryValueExA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegQueryValueExA(arg1, arg2, x, arg4, arg5, arg6);
+void test__stricmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  stricmp(arg1, x);
 }
 
-void test__RegQueryValueExA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegQueryValueExA(arg1, arg2, arg3, x, arg5, arg6);
+void test___stricmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _stricmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__RegQueryValueExW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RegQueryValueExW(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___stricmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  _stricmp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__RegQueryValueExW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RegQueryValueExW(p, arg2, arg3, arg4, arg5, arg6);
-    // cppcheck-suppress memleak
+void test___stricmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stricmp(NULL, arg2);
 }
 
-void test__RegQueryValueExW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegQueryValueExW(x, arg2, arg3, arg4, arg5, arg6);
+void test___stricmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stricmp(x, arg2);
 }
 
-void test__RegQueryValueExW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegQueryValueExW(arg1, arg2, x, arg4, arg5, arg6);
+void test___stricmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stricmp(arg1, NULL);
 }
 
-void test__RegQueryValueExW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegQueryValueExW(arg1, arg2, arg3, x, arg5, arg6);
+void test___stricmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stricmp(arg1, x);
 }
 
-void test__RegCloseKey__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RegCloseKey(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsicmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcsicmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__RegCloseKey__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RegCloseKey(p);
-    // cppcheck-suppress memleak
+void test__wcsicmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcsicmp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__RegCloseKey__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegCloseKey(x);
+void test__wcsicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsicmp(NULL, arg2);
 }
 
-void test___stricmp_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _stricmp_l(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsicmp(x, arg2);
 }
 
-void test___stricmp_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _stricmp_l(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__wcsicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsicmp(arg1, NULL);
 }
 
-void test___stricmp_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stricmp_l(NULL, arg2, arg3);
+void test__wcsicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsicmp(arg1, x);
 }
 
-void test___stricmp_l__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _stricmp_l(x, arg2, arg3);
+void test___wcsicmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wcsicmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___stricmp_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stricmp_l(arg1, NULL, arg3);
+void test___wcsicmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  _wcsicmp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___stricmp_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _stricmp_l(arg1, x, arg3);
+void test___wcsicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsicmp(NULL, arg2);
 }
 
-void test___stricmp_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _stricmp_l(arg1, arg2, x);
+void test___wcsicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsicmp(x, arg2);
 }
 
-void test___wcsicmp_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wcsicmp_l(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wcsicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsicmp(arg1, NULL);
 }
 
-void test___wcsicmp_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _wcsicmp_l(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___wcsicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsicmp(arg1, x);
 }
 
-void test___wcsicmp_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wcsicmp_l(NULL, arg2, arg3);
+void test___mbsicmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _mbsicmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wcsicmp_l__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wcsicmp_l(x, arg2, arg3);
+void test___mbsicmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  _mbsicmp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___wcsicmp_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wcsicmp_l(arg1, NULL, arg3);
+void test___mbsicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsicmp(NULL, arg2);
 }
 
-void test___wcsicmp_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wcsicmp_l(arg1, x, arg3);
+void test___mbsicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsicmp(x, arg2);
 }
 
-void test___wcsicmp_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _wcsicmp_l(arg1, arg2, x);
+void test___mbsicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsicmp(arg1, NULL);
 }
 
-void test___mbsicmp_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _mbsicmp_l(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbsicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsicmp(arg1, x);
 }
 
-void test___mbsicmp_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _mbsicmp_l(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___tcsicmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tcsicmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsicmp_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbsicmp_l(NULL, arg2, arg3);
+void test___tcsicmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  _tcsicmp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___mbsicmp_l__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _mbsicmp_l(x, arg2, arg3);
+void test___tcsicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsicmp(NULL, arg2);
 }
 
-void test___mbsicmp_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbsicmp_l(arg1, NULL, arg3);
+void test___tcsicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsicmp(x, arg2);
 }
 
-void test___mbsicmp_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _mbsicmp_l(arg1, x, arg3);
+void test___tcsicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsicmp(arg1, NULL);
 }
 
-void test___mbsicmp_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _mbsicmp_l(arg1, arg2, x);
+void test___tcsicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsicmp(arg1, x);
 }
 
-void test__stricmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        stricmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetFileAttributes__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetFileAttributes(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stricmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    stricmp(p, arg2);
-    // cppcheck-suppress memleak
+void test__GetFileAttributes__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetFileAttributes(p);
+  // cppcheck-suppress memleak
 }
 
-void test__stricmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    stricmp(NULL, arg2);
+void test__GetFileAttributes__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetFileAttributes(x);
 }
 
-void test__stricmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    stricmp(x, arg2);
+void test__GetFileAttributesA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetFileAttributesA(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__stricmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    stricmp(arg1, NULL);
+void test__GetFileAttributesA__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetFileAttributesA(p);
+  // cppcheck-suppress memleak
 }
 
-void test__stricmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    stricmp(arg1, x);
+void test__GetFileAttributesA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetFileAttributesA(x);
 }
 
-void test___stricmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _stricmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetFileAttributesW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetFileAttributesW(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___stricmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _stricmp(p, arg2);
-    // cppcheck-suppress memleak
+void test__GetFileAttributesW__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetFileAttributesW(p);
+  // cppcheck-suppress memleak
 }
 
-void test___stricmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stricmp(NULL, arg2);
+void test__GetFileAttributesW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetFileAttributesW(x);
 }
 
-void test___stricmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _stricmp(x, arg2);
+void test__RegOpenKeyEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RegOpenKeyEx(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___stricmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stricmp(arg1, NULL);
+void test__RegOpenKeyEx__leakignore() {
+  char *p = malloc(10); *p=0;
+  RegOpenKeyEx(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test___stricmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _stricmp(arg1, x);
+void test__RegOpenKeyEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyEx(x, arg2, arg3, arg4, arg5);
 }
 
-void test__wcsicmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcsicmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RegOpenKeyEx__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyEx(arg1, arg2, x, arg4, arg5);
 }
 
-void test__wcsicmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcsicmp(p, arg2);
-    // cppcheck-suppress memleak
+void test__RegOpenKeyEx__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyEx(arg1, arg2, arg3, x, arg5);
 }
 
-void test__wcsicmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcsicmp(NULL, arg2);
+void test__RegOpenKeyExA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RegOpenKeyExA(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsicmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcsicmp(x, arg2);
+void test__RegOpenKeyExA__leakignore() {
+  char *p = malloc(10); *p=0;
+  RegOpenKeyExA(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test__wcsicmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcsicmp(arg1, NULL);
+void test__RegOpenKeyExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyExA(x, arg2, arg3, arg4, arg5);
 }
 
-void test__wcsicmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcsicmp(arg1, x);
+void test__RegOpenKeyExA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyExA(arg1, arg2, x, arg4, arg5);
 }
 
-void test___wcsicmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wcsicmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RegOpenKeyExA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyExA(arg1, arg2, arg3, x, arg5);
 }
 
-void test___wcsicmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _wcsicmp(p, arg2);
-    // cppcheck-suppress memleak
+void test__RegOpenKeyExW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RegOpenKeyExW(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wcsicmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wcsicmp(NULL, arg2);
+void test__RegOpenKeyExW__leakignore() {
+  char *p = malloc(10); *p=0;
+  RegOpenKeyExW(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test___wcsicmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wcsicmp(x, arg2);
+void test__RegOpenKeyExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyExW(x, arg2, arg3, arg4, arg5);
 }
 
-void test___wcsicmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wcsicmp(arg1, NULL);
+void test__RegOpenKeyExW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyExW(arg1, arg2, x, arg4, arg5);
 }
 
-void test___wcsicmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wcsicmp(arg1, x);
+void test__RegOpenKeyExW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyExW(arg1, arg2, arg3, x, arg5);
 }
 
-void test___mbsicmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _mbsicmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wsprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wsprintf(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsicmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _mbsicmp(p, arg2);
-    // cppcheck-suppress memleak
+void test__wsprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  wsprintf(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___mbsicmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbsicmp(NULL, arg2);
+void test__wsprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wsprintf(x, arg2);
 }
 
-void test___mbsicmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _mbsicmp(x, arg2);
+void test__wsprintf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wsprintf(arg1, NULL);
 }
 
-void test___mbsicmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbsicmp(arg1, NULL);
+void test__wsprintf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wsprintf(arg1, x);
 }
 
-void test___mbsicmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _mbsicmp(arg1, x);
+void test__wsprintfA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wsprintfA(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcsicmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tcsicmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wsprintfA__leakignore() {
+  char *p = malloc(10); *p=0;
+  wsprintfA(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___tcsicmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _tcsicmp(p, arg2);
-    // cppcheck-suppress memleak
+void test__wsprintfA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wsprintfA(x, arg2);
 }
 
-void test___tcsicmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcsicmp(NULL, arg2);
+void test__wsprintfA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wsprintfA(arg1, NULL);
 }
 
-void test___tcsicmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tcsicmp(x, arg2);
+void test__wsprintfA__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wsprintfA(arg1, x);
 }
 
-void test___tcsicmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcsicmp(arg1, NULL);
+void test__wsprintfW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wsprintfW(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcsicmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tcsicmp(arg1, x);
+void test__wsprintfW__leakignore() {
+  char *p = malloc(10); *p=0;
+  wsprintfW(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__GetFileAttributes__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetFileAttributes(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wsprintfW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wsprintfW(x, arg2);
 }
 
-void test__GetFileAttributes__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetFileAttributes(p);
-    // cppcheck-suppress memleak
+void test__wsprintfW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wsprintfW(arg1, NULL);
 }
 
-void test__GetFileAttributes__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetFileAttributes(x);
+void test__wsprintfW__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wsprintfW(arg1, x);
 }
 
-void test__GetFileAttributesA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetFileAttributesA(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__sprintf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sprintf_s(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__GetFileAttributesA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetFileAttributesA(p);
-    // cppcheck-suppress memleak
+void test__sprintf_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  sprintf_s();
+  // cppcheck-suppress memleak
 }
 
-void test__GetFileAttributesA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetFileAttributesA(x);
+void test__swprintf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; swprintf_s(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetFileAttributesW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetFileAttributesW(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__swprintf_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  swprintf_s();
+  // cppcheck-suppress memleak
 }
 
-void test__GetFileAttributesW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetFileAttributesW(p);
-    // cppcheck-suppress memleak
+void test___sprintf_s_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _sprintf_s_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetFileAttributesW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetFileAttributesW(x);
+void test___sprintf_s_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _sprintf_s_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__RegOpenKeyEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RegOpenKeyEx(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__RegOpenKeyEx__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RegOpenKeyEx(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
-}
-
-void test__RegOpenKeyEx__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegOpenKeyEx(x, arg2, arg3, arg4, arg5);
-}
-
-void test__RegOpenKeyEx__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegOpenKeyEx(arg1, arg2, x, arg4, arg5);
+void test___sprintf_s_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _sprintf_s_l(arg1, x, arg3, arg4);
 }
-
-void test__RegOpenKeyEx__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegOpenKeyEx(arg1, arg2, arg3, x, arg5);
+
+void test___sprintf_s_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _sprintf_s_l(arg1, arg2, NULL, arg4);
 }
 
-void test__RegOpenKeyExA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RegOpenKeyExA(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__RegOpenKeyExA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RegOpenKeyExA(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test___sprintf_s_l__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _sprintf_s_l(arg1, arg2, x, arg4);
 }
 
-void test__RegOpenKeyExA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegOpenKeyExA(x, arg2, arg3, arg4, arg5);
+void test___sprintf_s_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _sprintf_s_l(arg1, arg2, arg3, x);
 }
 
-void test__RegOpenKeyExA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegOpenKeyExA(arg1, arg2, x, arg4, arg5);
+void test___swprintf_s_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _swprintf_s_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__RegOpenKeyExA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegOpenKeyExA(arg1, arg2, arg3, x, arg5);
+void test___swprintf_s_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _swprintf_s_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__RegOpenKeyExW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RegOpenKeyExW(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___swprintf_s_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _swprintf_s_l(arg1, x, arg3, arg4);
 }
 
-void test__RegOpenKeyExW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RegOpenKeyExW(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test___swprintf_s_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _swprintf_s_l(arg1, arg2, NULL, arg4);
 }
 
-void test__RegOpenKeyExW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegOpenKeyExW(x, arg2, arg3, arg4, arg5);
+void test___swprintf_s_l__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _swprintf_s_l(arg1, arg2, x, arg4);
 }
 
-void test__RegOpenKeyExW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegOpenKeyExW(arg1, arg2, x, arg4, arg5);
+void test___swprintf_s_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _swprintf_s_l(arg1, arg2, arg3, x);
 }
 
-void test__RegOpenKeyExW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegOpenKeyExW(arg1, arg2, arg3, x, arg5);
+void test__RegEnumKeyEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RegEnumKeyEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wsprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wsprintf(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RegEnumKeyEx__leakignore() {
+  char *p = malloc(10); *p=0;
+  RegEnumKeyEx(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+  // cppcheck-suppress memleak
 }
 
-void test__wsprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wsprintf(p, arg2);
-    // cppcheck-suppress memleak
+void test__RegEnumKeyEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegEnumKeyEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
 }
 
-void test__wsprintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wsprintf(x, arg2);
+void test__RegEnumKeyEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegEnumKeyEx(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
 }
 
-void test__wsprintf__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wsprintf(arg1, NULL);
+void test__RegEnumKeyExA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RegEnumKeyExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wsprintf__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wsprintf(arg1, x);
+void test__RegEnumKeyExA__leakignore() {
+  char *p = malloc(10); *p=0;
+  RegEnumKeyExA(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+  // cppcheck-suppress memleak
 }
 
-void test__wsprintfA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wsprintfA(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RegEnumKeyExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegEnumKeyExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
 }
 
-void test__wsprintfA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wsprintfA(p, arg2);
-    // cppcheck-suppress memleak
+void test__RegEnumKeyExA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegEnumKeyExA(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
 }
 
-void test__wsprintfA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wsprintfA(x, arg2);
-}
-
-void test__wsprintfA__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wsprintfA(arg1, NULL);
+void test__RegEnumKeyExW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RegEnumKeyExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__wsprintfA__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wsprintfA(arg1, x);
+
+void test__RegEnumKeyExW__leakignore() {
+  char *p = malloc(10); *p=0;
+  RegEnumKeyExW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+  // cppcheck-suppress memleak
 }
 
-void test__wsprintfW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wsprintfW(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RegEnumKeyExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegEnumKeyExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
 }
 
-void test__wsprintfW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wsprintfW(p, arg2);
-    // cppcheck-suppress memleak
+void test__RegEnumKeyExW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegEnumKeyExW(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
 }
 
-void test__wsprintfW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wsprintfW(x, arg2);
+void test__CreateFont__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateFont(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wsprintfW__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wsprintfW(arg1, NULL);
+void test__CaptureStackBackTrace__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CaptureStackBackTrace(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wsprintfW__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wsprintfW(arg1, x);
+void test__CaptureStackBackTrace__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CaptureStackBackTrace(x, arg2, arg3, arg4);
 }
 
-void test__sprintf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sprintf_s();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CaptureStackBackTrace__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CaptureStackBackTrace(arg1, x, arg3, arg4);
 }
 
-void test__sprintf_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sprintf_s();
-    // cppcheck-suppress memleak
+void test___vsnprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _vsnprintf(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__swprintf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        swprintf_s();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___vsnprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  _vsnprintf(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__swprintf_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    swprintf_s();
-    // cppcheck-suppress memleak
+void test___vsnprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf(x, arg2, arg3, arg4);
 }
 
-void test___sprintf_s_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _sprintf_s_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___vsnprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf(arg1, x, arg3, arg4);
 }
 
-void test___sprintf_s_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _sprintf_s_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___vsnprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnprintf(arg1, arg2, NULL, arg4);
 }
 
-void test___sprintf_s_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _sprintf_s_l(arg1, x, arg3, arg4);
+void test___vsnprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vsnprintf(arg1, arg2, x, arg4);
 }
 
-void test___sprintf_s_l__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _sprintf_s_l(arg1, arg2, NULL, arg4);
+void test___vsnwprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _vsnwprintf(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___sprintf_s_l__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _sprintf_s_l(arg1, arg2, x, arg4);
+void test___vsnwprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  _vsnwprintf(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test___sprintf_s_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _sprintf_s_l(arg1, arg2, arg3, x);
+void test___vsnwprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf(x, arg2, arg3, arg4);
 }
 
-void test___swprintf_s_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _swprintf_s_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test___swprintf_s_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _swprintf_s_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
-}
-
-void test___swprintf_s_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _swprintf_s_l(arg1, x, arg3, arg4);
+void test___vsnwprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf(arg1, x, arg3, arg4);
 }
 
-void test___swprintf_s_l__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _swprintf_s_l(arg1, arg2, NULL, arg4);
+void test___vsnwprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnwprintf(arg1, arg2, NULL, arg4);
 }
 
-void test___swprintf_s_l__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _swprintf_s_l(arg1, arg2, x, arg4);
+void test___vsnwprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vsnwprintf(arg1, arg2, x, arg4);
 }
 
-void test___swprintf_s_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _swprintf_s_l(arg1, arg2, arg3, x);
+void test___vsnprintf_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _vsnprintf_l(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__RegEnumKeyEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RegEnumKeyEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___vsnprintf_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _vsnprintf_l(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test__RegEnumKeyEx__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RegEnumKeyEx(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-    // cppcheck-suppress memleak
+void test___vsnprintf_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_l(x, arg2, arg3, arg4, arg5);
 }
-
-void test__RegEnumKeyEx__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegEnumKeyEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+
+void test___vsnprintf_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_l(arg1, x, arg3, arg4, arg5);
 }
 
-void test__RegEnumKeyEx__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegEnumKeyEx(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
+void test___vsnprintf_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnprintf_l(arg1, arg2, NULL, arg4, arg5);
 }
 
-void test__RegEnumKeyExA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RegEnumKeyExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__RegEnumKeyExA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RegEnumKeyExA(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-    // cppcheck-suppress memleak
-}
-
-void test__RegEnumKeyExA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegEnumKeyExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-}
-
-void test__RegEnumKeyExA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegEnumKeyExA(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
-}
-
-void test__RegEnumKeyExW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RegEnumKeyExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___vsnprintf_l__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vsnprintf_l(arg1, arg2, x, arg4, arg5);
 }
 
-void test__RegEnumKeyExW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RegEnumKeyExW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-    // cppcheck-suppress memleak
+void test___vsnprintf_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_l(arg1, arg2, arg3, x, arg5);
 }
 
-void test__RegEnumKeyExW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegEnumKeyExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-}
+void test___vsnwprintf_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _vsnwprintf_l(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__RegEnumKeyExW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RegEnumKeyExW(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
-}
-
-void test__CreateFont__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateFont(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___vsnwprintf_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _vsnwprintf_l(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test__CaptureStackBackTrace__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CaptureStackBackTrace(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___vsnwprintf_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_l(x, arg2, arg3, arg4, arg5);
 }
 
-void test__CaptureStackBackTrace__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CaptureStackBackTrace(x, arg2, arg3, arg4);
+void test___vsnwprintf_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_l(arg1, x, arg3, arg4, arg5);
 }
 
-void test__CaptureStackBackTrace__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CaptureStackBackTrace(arg1, x, arg3, arg4);
-}
-
-void test___vsnprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _vsnprintf(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test___vsnwprintf_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnwprintf_l(arg1, arg2, NULL, arg4, arg5);
+}
 
-void test___vsnprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _vsnprintf(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___vsnwprintf_l__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_l(arg1, arg2, x, arg4, arg5);
 }
 
-void test___vsnprintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnprintf(x, arg2, arg3, arg4);
+void test___vsnwprintf_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_l(arg1, arg2, arg3, x, arg5);
 }
 
-void test___vsnprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnprintf(arg1, x, arg3, arg4);
+void test___vswprintf_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _vswprintf_l(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___vsnprintf__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _vsnprintf(arg1, arg2, NULL, arg4);
+void test___vswprintf_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _vswprintf_l(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test___vsnprintf__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _vsnprintf(arg1, arg2, x, arg4);
+void test___vswprintf_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vswprintf_l(x, arg2, arg3, arg4, arg5);
 }
 
-void test___vsnwprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _vsnwprintf(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___vswprintf_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vswprintf_l(arg1, x, arg3, arg4, arg5);
 }
 
-void test___vsnwprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _vsnwprintf(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___vswprintf_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _vswprintf_l(arg1, arg2, NULL, arg4, arg5);
 }
 
-void test___vsnwprintf__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnwprintf(x, arg2, arg3, arg4);
+void test___vswprintf_l__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vswprintf_l(arg1, arg2, x, arg4, arg5);
 }
 
-void test___vsnwprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnwprintf(arg1, x, arg3, arg4);
+void test___vswprintf_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vswprintf_l(arg1, arg2, arg3, x, arg5);
 }
 
-void test___vsnwprintf__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _vsnwprintf(arg1, arg2, NULL, arg4);
+void test__vsnprintf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; vsnprintf_s(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___vsnwprintf__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _vsnwprintf(arg1, arg2, x, arg4);
+void test__vsnprintf_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  vsnprintf_s(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test___vsnprintf_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _vsnprintf_l(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__vsnprintf_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vsnprintf_s(x, arg2, arg3, arg4, arg5);
 }
 
-void test___vsnprintf_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _vsnprintf_l(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test__vsnprintf_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vsnprintf_s(arg1, x, arg3, arg4, arg5);
 }
 
-void test___vsnprintf_l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnprintf_l(x, arg2, arg3, arg4, arg5);
+void test__vsnprintf_s__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vsnprintf_s(arg1, arg2, x, arg4, arg5);
 }
 
-void test___vsnprintf_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnprintf_l(arg1, x, arg3, arg4, arg5);
+void test__vsnprintf_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  vsnprintf_s(arg1, arg2, arg3, NULL, arg5);
 }
 
-void test___vsnprintf_l__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _vsnprintf_l(arg1, arg2, NULL, arg4, arg5);
+void test__vsnprintf_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vsnprintf_s(arg1, arg2, arg3, x, arg5);
 }
 
-void test___vsnprintf_l__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _vsnprintf_l(arg1, arg2, x, arg4, arg5);
+void test___vsnprintf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _vsnprintf_s(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___vsnprintf_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnprintf_l(arg1, arg2, arg3, x, arg5);
+void test___vsnprintf_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  _vsnprintf_s(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test___vsnwprintf_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _vsnwprintf_l(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___vsnprintf_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_s(x, arg2, arg3, arg4, arg5);
 }
 
-void test___vsnwprintf_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _vsnwprintf_l(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test___vsnprintf_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_s(arg1, x, arg3, arg4, arg5);
 }
 
-void test___vsnwprintf_l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnwprintf_l(x, arg2, arg3, arg4, arg5);
+void test___vsnprintf_s__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_s(arg1, arg2, x, arg4, arg5);
 }
 
-void test___vsnwprintf_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnwprintf_l(arg1, x, arg3, arg4, arg5);
+void test___vsnprintf_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnprintf_s(arg1, arg2, arg3, NULL, arg5);
 }
 
-void test___vsnwprintf_l__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _vsnwprintf_l(arg1, arg2, NULL, arg4, arg5);
+void test___vsnprintf_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vsnprintf_s(arg1, arg2, arg3, x, arg5);
 }
 
-void test___vsnwprintf_l__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _vsnwprintf_l(arg1, arg2, x, arg4, arg5);
+void test___vsnwprintf_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _vsnwprintf_s(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___vsnwprintf_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnwprintf_l(arg1, arg2, arg3, x, arg5);
+void test___vsnwprintf_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  _vsnwprintf_s(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test___vswprintf_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _vswprintf_l(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___vsnwprintf_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s(x, arg2, arg3, arg4, arg5);
 }
 
-void test___vswprintf_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _vswprintf_l(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test___vsnwprintf_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s(arg1, x, arg3, arg4, arg5);
 }
 
-void test___vswprintf_l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vswprintf_l(x, arg2, arg3, arg4, arg5);
+void test___vsnwprintf_s__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s(arg1, arg2, x, arg4, arg5);
 }
 
-void test___vswprintf_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vswprintf_l(arg1, x, arg3, arg4, arg5);
+void test___vsnwprintf_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnwprintf_s(arg1, arg2, arg3, NULL, arg5);
 }
 
-void test___vswprintf_l__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _vswprintf_l(arg1, arg2, NULL, arg4, arg5);
+void test___vsnwprintf_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s(arg1, arg2, arg3, x, arg5);
 }
 
-void test___vswprintf_l__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _vswprintf_l(arg1, arg2, x, arg4, arg5);
+void test___vsnprintf_s_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _vsnprintf_s_l(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___vswprintf_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vswprintf_l(arg1, arg2, arg3, x, arg5);
+void test___vsnprintf_s_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _vsnprintf_s_l(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
 }
 
-void test__vsnprintf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        vsnprintf_s(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___vsnprintf_s_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_s_l(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__vsnprintf_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    vsnprintf_s(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test___vsnprintf_s_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_s_l(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__vsnprintf_s__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    vsnprintf_s(x, arg2, arg3, arg4, arg5);
+void test___vsnprintf_s_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_s_l(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__vsnprintf_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    vsnprintf_s(arg1, x, arg3, arg4, arg5);
+void test___vsnprintf_s_l__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnprintf_s_l(arg1, arg2, arg3, NULL, arg5, arg6);
 }
 
-void test__vsnprintf_s__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    vsnprintf_s(arg1, arg2, x, arg4, arg5);
+void test___vsnprintf_s_l__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vsnprintf_s_l(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__vsnprintf_s__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    vsnprintf_s(arg1, arg2, arg3, NULL, arg5);
+void test___vsnprintf_s_l__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_s_l(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__vsnprintf_s__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    vsnprintf_s(arg1, arg2, arg3, x, arg5);
+void test___vsnwprintf_s_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _vsnwprintf_s_l(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___vsnprintf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _vsnprintf_s(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___vsnwprintf_s_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _vsnwprintf_s_l(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
 }
 
-void test___vsnprintf_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _vsnprintf_s(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test___vsnwprintf_s_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s_l(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test___vsnprintf_s__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnprintf_s(x, arg2, arg3, arg4, arg5);
+void test___vsnwprintf_s_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s_l(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test___vsnprintf_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnprintf_s(arg1, x, arg3, arg4, arg5);
+void test___vsnwprintf_s_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s_l(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test___vsnprintf_s__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnprintf_s(arg1, arg2, x, arg4, arg5);
+void test___vsnwprintf_s_l__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnwprintf_s_l(arg1, arg2, arg3, NULL, arg5, arg6);
 }
 
-void test___vsnprintf_s__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _vsnprintf_s(arg1, arg2, arg3, NULL, arg5);
+void test___vsnwprintf_s_l__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s_l(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test___vsnprintf_s__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _vsnprintf_s(arg1, arg2, arg3, x, arg5);
+void test___vsnwprintf_s_l__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s_l(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test___vsnwprintf_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _vsnwprintf_s(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___vsprintf_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _vsprintf_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___vsnwprintf_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _vsnwprintf_s(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test___vsprintf_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _vsprintf_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test___vsnwprintf_s__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnwprintf_s(x, arg2, arg3, arg4, arg5);
+void test___vsprintf_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsprintf_l(NULL, arg2, arg3, arg4);
 }
 
-void test___vsnwprintf_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnwprintf_s(arg1, x, arg3, arg4, arg5);
+void test___vsprintf_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsprintf_l(arg1, NULL, arg3, arg4);
 }
 
-void test___vsnwprintf_s__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnwprintf_s(arg1, arg2, x, arg4, arg5);
+void test___vsprintf_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsprintf_l(arg1, arg2, x, arg4);
 }
 
-void test___vsnwprintf_s__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _vsnwprintf_s(arg1, arg2, arg3, NULL, arg5);
+void test____vswprintf_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; __vswprintf_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___vsnwprintf_s__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _vsnwprintf_s(arg1, arg2, arg3, x, arg5);
+void test____vswprintf_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  __vswprintf_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test___vsnprintf_s_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _vsnprintf_s_l(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test____vswprintf_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  __vswprintf_l(NULL, arg2, arg3, arg4);
 }
 
-void test___vsnprintf_s_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _vsnprintf_s_l(p, arg2, arg3, arg4, arg5, arg6);
-    // cppcheck-suppress memleak
+void test____vswprintf_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  __vswprintf_l(arg1, NULL, arg3, arg4);
 }
 
-void test___vsnprintf_s_l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnprintf_s_l(x, arg2, arg3, arg4, arg5, arg6);
+void test____vswprintf_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  __vswprintf_l(arg1, arg2, x, arg4);
 }
 
-void test___vsnprintf_s_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnprintf_s_l(arg1, x, arg3, arg4, arg5, arg6);
+void test___strdup__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _strdup(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___vsnprintf_s_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnprintf_s_l(arg1, arg2, x, arg4, arg5, arg6);
+void test___strdup__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _strdup(NULL);
 }
 
-void test___vsnprintf_s_l__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _vsnprintf_s_l(arg1, arg2, arg3, NULL, arg5, arg6);
+void test___strdup__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _strdup(x);
 }
 
-void test___vsnprintf_s_l__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _vsnprintf_s_l(arg1, arg2, arg3, x, arg5, arg6);
+void test___wcsdup__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wcsdup(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___vsnprintf_s_l__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnprintf_s_l(arg1, arg2, arg3, arg4, x, arg6);
+void test___wcsdup__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsdup(NULL);
 }
 
-void test___vsnwprintf_s_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _vsnwprintf_s_l(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wcsdup__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsdup(x);
 }
 
-void test___vsnwprintf_s_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _vsnwprintf_s_l(p, arg2, arg3, arg4, arg5, arg6);
-    // cppcheck-suppress memleak
+void test___mbsdup__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _mbsdup(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___vsnwprintf_s_l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnwprintf_s_l(x, arg2, arg3, arg4, arg5, arg6);
+void test___mbsdup__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsdup(NULL);
 }
 
-void test___vsnwprintf_s_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnwprintf_s_l(arg1, x, arg3, arg4, arg5, arg6);
+void test___mbsdup__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsdup(x);
 }
 
-void test___vsnwprintf_s_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnwprintf_s_l(arg1, arg2, x, arg4, arg5, arg6);
+void test___tcsdup__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tcsdup(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___vsnwprintf_s_l__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _vsnwprintf_s_l(arg1, arg2, arg3, NULL, arg5, arg6);
+void test___tcsdup__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsdup(NULL);
 }
 
-void test___vsnwprintf_s_l__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _vsnwprintf_s_l(arg1, arg2, arg3, x, arg5, arg6);
+void test___tcsdup__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsdup(x);
 }
 
-void test___vsnwprintf_s_l__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsnwprintf_s_l(arg1, arg2, arg3, arg4, x, arg6);
+void test___strdup_dbg__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _strdup_dbg(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___vsprintf_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _vsprintf_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___strdup_dbg__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _strdup_dbg(NULL, arg2, arg3, arg4);
 }
 
-void test___vsprintf_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _vsprintf_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___strdup_dbg__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _strdup_dbg(x, arg2, arg3, arg4);
 }
 
-void test___vsprintf_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _vsprintf_l(NULL, arg2, arg3, arg4);
+void test___strdup_dbg__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strdup_dbg(arg1, x, arg3, arg4);
 }
 
-void test___vsprintf_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _vsprintf_l(arg1, NULL, arg3, arg4);
+void test___strdup_dbg__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strdup_dbg(arg1, arg2, x, arg4);
 }
 
-void test___vsprintf_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _vsprintf_l(arg1, arg2, x, arg4);
+void test___strdup_dbg__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strdup_dbg(arg1, arg2, arg3, x);
 }
 
-void test____vswprintf_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        __vswprintf_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wcsdup_dbg__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wcsdup_dbg(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test____vswprintf_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    __vswprintf_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___wcsdup_dbg__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsdup_dbg(NULL, arg2, arg3, arg4);
 }
 
-void test____vswprintf_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    __vswprintf_l(NULL, arg2, arg3, arg4);
+void test___wcsdup_dbg__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsdup_dbg(x, arg2, arg3, arg4);
 }
 
-void test____vswprintf_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    __vswprintf_l(arg1, NULL, arg3, arg4);
+void test___wcsdup_dbg__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsdup_dbg(arg1, x, arg3, arg4);
 }
 
-void test____vswprintf_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    __vswprintf_l(arg1, arg2, x, arg4);
+void test___wcsdup_dbg__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsdup_dbg(arg1, arg2, x, arg4);
 }
 
-void test___strdup__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _strdup(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wcsdup_dbg__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsdup_dbg(arg1, arg2, arg3, x);
 }
 
-void test___strdup__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _strdup(NULL);
+void test___tcsdup_dbg__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tcsdup_dbg(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___strdup__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _strdup(x);
+void test___tcsdup_dbg__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsdup_dbg(NULL, arg2, arg3, arg4);
 }
 
-void test___wcsdup__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wcsdup(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcsdup_dbg__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsdup_dbg(x, arg2, arg3, arg4);
 }
 
-void test___wcsdup__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wcsdup(NULL);
+void test___tcsdup_dbg__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcsdup_dbg(arg1, x, arg3, arg4);
 }
 
-void test___wcsdup__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wcsdup(x);
+void test___tcsdup_dbg__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcsdup_dbg(arg1, arg2, x, arg4);
 }
 
-void test___mbsdup__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _mbsdup(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcsdup_dbg__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcsdup_dbg(arg1, arg2, arg3, x);
 }
 
-void test___mbsdup__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbsdup(NULL);
+void test___mbscmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mbscmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsdup__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _mbsdup(x);
+void test___mbscmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbscmp(arg1, arg2);
 }
 
-void test___tcsdup__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tcsdup(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbscmp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_mbscmp(arg1, arg2) > 10) || (_mbscmp(arg1, arg2) < 100)) {}
 }
 
-void test___tcsdup__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcsdup(NULL);
+void test___mbscmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mbscmp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___tcsdup__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tcsdup(x);
+void test___mbscmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbscmp(NULL, arg2);
 }
 
-void test___strdup_dbg__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _strdup_dbg(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbscmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbscmp(x, arg2);
 }
 
-void test___strdup_dbg__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _strdup_dbg(NULL, arg2, arg3, arg4);
+void test___mbscmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbscmp(arg1, NULL);
 }
 
-void test___strdup_dbg__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _strdup_dbg(x, arg2, arg3, arg4);
+void test___mbscmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbscmp(arg1, x);
 }
 
-void test___strdup_dbg__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _strdup_dbg(arg1, x, arg3, arg4);
+void test___tcscmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _tcscmp(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___strdup_dbg__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _strdup_dbg(arg1, arg2, x, arg4);
+void test___tcscmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcscmp(arg1, arg2);
 }
 
-void test___strdup_dbg__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _strdup_dbg(arg1, arg2, arg3, x);
+void test___tcscmp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_tcscmp(arg1, arg2) > 10) || (_tcscmp(arg1, arg2) < 100)) {}
 }
 
-void test___wcsdup_dbg__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wcsdup_dbg(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcscmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _tcscmp(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___wcsdup_dbg__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wcsdup_dbg(NULL, arg2, arg3, arg4);
+void test___tcscmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcscmp(NULL, arg2);
 }
 
-void test___wcsdup_dbg__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wcsdup_dbg(x, arg2, arg3, arg4);
+void test___tcscmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcscmp(x, arg2);
 }
 
-void test___wcsdup_dbg__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _wcsdup_dbg(arg1, x, arg3, arg4);
+void test___tcscmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcscmp(arg1, NULL);
 }
 
-void test___wcsdup_dbg__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _wcsdup_dbg(arg1, arg2, x, arg4);
+void test___tcscmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcscmp(arg1, x);
 }
 
-void test___wcsdup_dbg__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _wcsdup_dbg(arg1, arg2, arg3, x);
+void test___snprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _snprintf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcsdup_dbg__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tcsdup_dbg(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___snprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  _snprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___tcsdup_dbg__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcsdup_dbg(NULL, arg2, arg3, arg4);
+void test___snprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _snprintf(arg1, x, arg3);
 }
 
-void test___tcsdup_dbg__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tcsdup_dbg(x, arg2, arg3, arg4);
+void test___snprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _snprintf(arg1, arg2, NULL);
 }
 
-void test___tcsdup_dbg__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _tcsdup_dbg(arg1, x, arg3, arg4);
+void test___snprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _snprintf(arg1, arg2, x);
 }
 
-void test___tcsdup_dbg__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _tcsdup_dbg(arg1, arg2, x, arg4);
+void test___snwprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _snwprintf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcsdup_dbg__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _tcsdup_dbg(arg1, arg2, arg3, x);
+void test___snwprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  _snwprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___mbscmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mbscmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___snwprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _snwprintf(arg1, x, arg3);
 }
 
-void test___mbscmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mbscmp(arg1, arg2);
+void test___snwprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _snwprintf(arg1, arg2, NULL);
 }
 
-void test___mbscmp__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_mbscmp(arg1, arg2) > 10) || (_mbscmp(arg1, arg2) < 100)) {}
+void test___snwprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _snwprintf(arg1, arg2, x);
 }
 
-void test___mbscmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mbscmp(p, arg2);
-    // cppcheck-suppress memleak
+void test___sntprintf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _sntprintf(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbscmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbscmp(NULL, arg2);
+void test___sntprintf__leakignore() {
+  char *p = malloc(10); *p=0;
+  _sntprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___mbscmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbscmp(x, arg2);
+void test___sntprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _sntprintf(arg1, x, arg3);
 }
 
-void test___mbscmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbscmp(arg1, NULL);
+void test___sntprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _sntprintf(arg1, arg2, NULL);
 }
 
-void test___mbscmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbscmp(arg1, x);
+void test___sntprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _sntprintf(arg1, arg2, x);
 }
 
-void test___tcscmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _tcscmp(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strcpy_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strcpy_s(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcscmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _tcscmp(arg1, arg2);
+void test__strcpy_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  strcpy_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___tcscmp__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_tcscmp(arg1, arg2) > 10) || (_tcscmp(arg1, arg2) < 100)) {}
+void test__strcpy_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strcpy_s(NULL, arg2, arg3);
 }
 
-void test___tcscmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _tcscmp(p, arg2);
-    // cppcheck-suppress memleak
+void test__strcpy_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strcpy_s(arg1, x, arg3);
 }
 
-void test___tcscmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tcscmp(NULL, arg2);
+void test__strcpy_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  strcpy_s(arg1, arg2, NULL);
 }
 
-void test___tcscmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tcscmp(x, arg2);
+void test__strcpy_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strcpy_s(arg1, arg2, x);
 }
 
-void test___tcscmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tcscmp(arg1, NULL);
+void test__wcscpy_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wcscpy_s(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcscmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tcscmp(arg1, x);
+void test__wcscpy_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  wcscpy_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___snprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _snprintf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcscpy_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcscpy_s(NULL, arg2, arg3);
 }
 
-void test___snprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _snprintf(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__wcscpy_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcscpy_s(arg1, x, arg3);
 }
 
-void test___snprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _snprintf(arg1, x, arg3);
+void test__wcscpy_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  wcscpy_s(arg1, arg2, NULL);
 }
 
-void test___snprintf__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _snprintf(arg1, arg2, NULL);
+void test__wcscpy_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcscpy_s(arg1, arg2, x);
 }
 
-void test___snprintf__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _snprintf(arg1, arg2, x);
+void test___mbscpy_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _mbscpy_s(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___snwprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _snwprintf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbscpy_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  _mbscpy_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___snwprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _snwprintf(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___mbscpy_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbscpy_s(NULL, arg2, arg3);
 }
 
-void test___snwprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _snwprintf(arg1, x, arg3);
+void test___mbscpy_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbscpy_s(arg1, x, arg3);
 }
 
-void test___snwprintf__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _snwprintf(arg1, arg2, NULL);
+void test___mbscpy_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbscpy_s(arg1, arg2, NULL);
 }
 
-void test___snwprintf__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _snwprintf(arg1, arg2, x);
+void test___mbscpy_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbscpy_s(arg1, arg2, x);
 }
 
-void test___sntprintf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _sntprintf(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcscpy_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tcscpy_s(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___sntprintf__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _sntprintf(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___tcscpy_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  _tcscpy_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___sntprintf__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _sntprintf(arg1, x, arg3);
+void test___tcscpy_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcscpy_s(NULL, arg2, arg3);
 }
 
-void test___sntprintf__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _sntprintf(arg1, arg2, NULL);
+void test___tcscpy_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcscpy_s(arg1, x, arg3);
 }
 
-void test___sntprintf__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _sntprintf(arg1, arg2, x);
+void test___tcscpy_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcscpy_s(arg1, arg2, NULL);
 }
 
-void test__strcpy_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strcpy_s(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcscpy_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcscpy_s(arg1, arg2, x);
 }
 
-void test__strcpy_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    strcpy_s(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___CrtSetDbgFlag__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _CrtSetDbgFlag(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strcpy_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strcpy_s(NULL, arg2, arg3);
+void test___CrtSetDbgFlag__leakignore() {
+  char *p = malloc(10); *p=0;
+  _CrtSetDbgFlag(p);
+  // cppcheck-suppress memleak
 }
 
-void test__strcpy_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    strcpy_s(arg1, x, arg3);
+void test___CrtSetDbgFlag__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _CrtSetDbgFlag(x);
 }
 
-void test__strcpy_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strcpy_s(arg1, arg2, NULL);
+void test___stat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _stat(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strcpy_s__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strcpy_s(arg1, arg2, x);
+void test___stat__leakignore() {
+  char *p = malloc(10); *p=0;
+  _stat(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__wcscpy_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wcscpy_s(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___stat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat(NULL, arg2);
 }
 
-void test__wcscpy_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wcscpy_s(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___stat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stat(x, arg2);
 }
 
-void test__wcscpy_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcscpy_s(NULL, arg2, arg3);
+void test___stat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat(arg1, NULL);
 }
 
-void test__wcscpy_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wcscpy_s(arg1, x, arg3);
+void test___tstat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tstat(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcscpy_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wcscpy_s(arg1, arg2, NULL);
+void test___tstat__leakignore() {
+  char *p = malloc(10); *p=0;
+  _tstat(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__wcscpy_s__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wcscpy_s(arg1, arg2, x);
+void test___tstat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat(NULL, arg2);
 }
 
-void test___mbscpy_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _mbscpy_s(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tstat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tstat(x, arg2);
 }
 
-void test___mbscpy_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _mbscpy_s(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___tstat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat(arg1, NULL);
 }
 
-void test___mbscpy_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbscpy_s(NULL, arg2, arg3);
+void test___stat32__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _stat32(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbscpy_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _mbscpy_s(arg1, x, arg3);
+void test___stat32__leakignore() {
+  char *p = malloc(10); *p=0;
+  _stat32(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___mbscpy_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbscpy_s(arg1, arg2, NULL);
+void test___stat32__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat32(NULL, arg2);
 }
 
-void test___mbscpy_s__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _mbscpy_s(arg1, arg2, x);
+void test___stat32__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stat32(x, arg2);
 }
 
-void test___tcscpy_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tcscpy_s(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___stat32__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat32(arg1, NULL);
 }
 
-void test___tcscpy_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _tcscpy_s(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___stat64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _stat64(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcscpy_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcscpy_s(NULL, arg2, arg3);
+void test___stat64__leakignore() {
+  char *p = malloc(10); *p=0;
+  _stat64(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___tcscpy_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _tcscpy_s(arg1, x, arg3);
+void test___stat64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat64(NULL, arg2);
 }
 
-void test___tcscpy_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcscpy_s(arg1, arg2, NULL);
+void test___stat64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stat64(x, arg2);
 }
 
-void test___tcscpy_s__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tcscpy_s(arg1, arg2, x);
+void test___stat64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat64(arg1, NULL);
 }
 
-void test___CrtSetDbgFlag__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _CrtSetDbgFlag(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tstat64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tstat64(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___CrtSetDbgFlag__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _CrtSetDbgFlag(p);
-    // cppcheck-suppress memleak
+void test___tstat64__leakignore() {
+  char *p = malloc(10); *p=0;
+  _tstat64(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___CrtSetDbgFlag__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _CrtSetDbgFlag(x);
+void test___tstat64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat64(NULL, arg2);
 }
 
-void test___stat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _stat(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tstat64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tstat64(x, arg2);
 }
 
-void test___stat__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _stat(p, arg2);
-    // cppcheck-suppress memleak
+void test___tstat64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat64(arg1, NULL);
 }
 
-void test___stat__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stat(NULL, arg2);
+void test___stati64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _stati64(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___stat__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _stat(x, arg2);
+void test___stati64__leakignore() {
+  char *p = malloc(10); *p=0;
+  _stati64(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___stat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stat(arg1, NULL);
+void test___stati64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stati64(NULL, arg2);
 }
 
-void test___tstat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tstat(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___stati64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stati64(x, arg2);
 }
 
-void test___tstat__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _tstat(p, arg2);
-    // cppcheck-suppress memleak
+void test___stati64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stati64(arg1, NULL);
 }
 
-void test___tstat__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tstat(NULL, arg2);
+void test___tstati64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tstati64(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tstat__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tstat(x, arg2);
+void test___tstati64__leakignore() {
+  char *p = malloc(10); *p=0;
+  _tstati64(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___tstat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tstat(arg1, NULL);
+void test___tstati64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstati64(NULL, arg2);
 }
 
-void test___stat32__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _stat32(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tstati64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tstati64(x, arg2);
 }
 
-void test___stat32__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _stat32(p, arg2);
-    // cppcheck-suppress memleak
+void test___tstati64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstati64(arg1, NULL);
 }
 
-void test___stat32__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stat32(NULL, arg2);
+void test___stat32i64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _stat32i64(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___stat32__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _stat32(x, arg2);
+void test___stat32i64__leakignore() {
+  char *p = malloc(10); *p=0;
+  _stat32i64(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___stat32__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stat32(arg1, NULL);
+void test___stat32i64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat32i64(NULL, arg2);
 }
 
-void test___stat64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _stat64(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___stat32i64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stat32i64(x, arg2);
 }
 
-void test___stat64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _stat64(p, arg2);
-    // cppcheck-suppress memleak
+void test___stat32i64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat32i64(arg1, NULL);
 }
 
-void test___stat64__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stat64(NULL, arg2);
+void test___tstat32i64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tstat32i64(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___stat64__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _stat64(x, arg2);
+void test___tstat32i64__leakignore() {
+  char *p = malloc(10); *p=0;
+  _tstat32i64(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___stat64__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stat64(arg1, NULL);
+void test___tstat32i64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat32i64(NULL, arg2);
 }
 
-void test___tstat64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tstat64(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tstat32i64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tstat32i64(x, arg2);
 }
 
-void test___tstat64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _tstat64(p, arg2);
-    // cppcheck-suppress memleak
+void test___tstat32i64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat32i64(arg1, NULL);
 }
 
-void test___tstat64__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tstat64(NULL, arg2);
+void test___stat64i32__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _stat64i32(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tstat64__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tstat64(x, arg2);
+void test___stat64i32__leakignore() {
+  char *p = malloc(10); *p=0;
+  _stat64i32(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___tstat64__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tstat64(arg1, NULL);
+void test___stat64i32__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat64i32(NULL, arg2);
 }
 
-void test___stati64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _stati64(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___stat64i32__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stat64i32(x, arg2);
 }
 
-void test___stati64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _stati64(p, arg2);
-    // cppcheck-suppress memleak
+void test___stat64i32__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat64i32(arg1, NULL);
 }
 
-void test___stati64__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stati64(NULL, arg2);
+void test___tstat64i32__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tstat64i32(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___stati64__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _stati64(x, arg2);
+void test___tstat64i32__leakignore() {
+  char *p = malloc(10); *p=0;
+  _tstat64i32(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___stati64__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stati64(arg1, NULL);
+void test___tstat64i32__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat64i32(NULL, arg2);
 }
 
-void test___tstati64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tstati64(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tstat64i32__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tstat64i32(x, arg2);
 }
 
-void test___tstati64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _tstati64(p, arg2);
-    // cppcheck-suppress memleak
+void test___tstat64i32__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat64i32(arg1, NULL);
 }
 
-void test___tstati64__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tstati64(NULL, arg2);
+void test___wstat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wstat(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tstati64__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tstati64(x, arg2);
+void test___wstat__leakignore() {
+  char *p = malloc(10); *p=0;
+  _wstat(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___tstati64__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tstati64(arg1, NULL);
+void test___wstat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat(NULL, arg2);
 }
 
-void test___stat32i64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _stat32i64(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wstat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wstat(x, arg2);
 }
 
-void test___stat32i64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _stat32i64(p, arg2);
-    // cppcheck-suppress memleak
+void test___wstat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat(arg1, NULL);
 }
 
-void test___stat32i64__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stat32i64(NULL, arg2);
+void test___wstat32__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wstat32(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___stat32i64__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _stat32i64(x, arg2);
+void test___wstat32__leakignore() {
+  char *p = malloc(10); *p=0;
+  _wstat32(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___stat32i64__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stat32i64(arg1, NULL);
+void test___wstat32__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat32(NULL, arg2);
 }
 
-void test___tstat32i64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tstat32i64(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wstat32__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wstat32(x, arg2);
 }
 
-void test___tstat32i64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _tstat32i64(p, arg2);
-    // cppcheck-suppress memleak
+void test___wstat32__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat32(arg1, NULL);
 }
 
-void test___tstat32i64__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tstat32i64(NULL, arg2);
+void test___wstat64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wstat64(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tstat32i64__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tstat32i64(x, arg2);
+void test___wstat64__leakignore() {
+  char *p = malloc(10); *p=0;
+  _wstat64(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___tstat32i64__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tstat32i64(arg1, NULL);
+void test___wstat64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat64(NULL, arg2);
 }
 
-void test___stat64i32__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _stat64i32(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wstat64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wstat64(x, arg2);
 }
 
-void test___stat64i32__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _stat64i32(p, arg2);
-    // cppcheck-suppress memleak
+void test___wstat64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat64(arg1, NULL);
 }
 
-void test___stat64i32__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stat64i32(NULL, arg2);
+void test___wstati64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wstati64(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___stat64i32__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _stat64i32(x, arg2);
+void test___wstati64__leakignore() {
+  char *p = malloc(10); *p=0;
+  _wstati64(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___stat64i32__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _stat64i32(arg1, NULL);
+void test___wstati64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstati64(NULL, arg2);
 }
 
-void test___tstat64i32__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tstat64i32(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wstati64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wstati64(x, arg2);
 }
 
-void test___tstat64i32__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _tstat64i32(p, arg2);
-    // cppcheck-suppress memleak
+void test___wstati64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstati64(arg1, NULL);
 }
 
-void test___tstat64i32__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tstat64i32(NULL, arg2);
+void test___wstat32i64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wstat32i64(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tstat64i32__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tstat64i32(x, arg2);
+void test___wstat32i64__leakignore() {
+  char *p = malloc(10); *p=0;
+  _wstat32i64(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___tstat64i32__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tstat64i32(arg1, NULL);
+void test___wstat32i64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat32i64(NULL, arg2);
 }
 
-void test___wstat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wstat(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wstat32i64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wstat32i64(x, arg2);
 }
 
-void test___wstat__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _wstat(p, arg2);
-    // cppcheck-suppress memleak
+void test___wstat32i64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat32i64(arg1, NULL);
 }
 
-void test___wstat__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wstat(NULL, arg2);
+void test___wstat64i32__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wstat64i32(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wstat__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wstat(x, arg2);
+void test___wstat64i32__leakignore() {
+  char *p = malloc(10); *p=0;
+  _wstat64i32(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___wstat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wstat(arg1, NULL);
+void test___wstat64i32__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat64i32(NULL, arg2);
 }
 
-void test___wstat32__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wstat32(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wstat64i32__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wstat64i32(x, arg2);
 }
 
-void test___wstat32__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _wstat32(p, arg2);
-    // cppcheck-suppress memleak
+void test___wstat64i32__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat64i32(arg1, NULL);
 }
 
-void test___wstat32__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wstat32(NULL, arg2);
+void test___fstat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _fstat(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wstat32__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wstat32(x, arg2);
+void test___fstat__leakignore() {
+  char *p = malloc(10); *p=0;
+  _fstat(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___wstat32__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wstat32(arg1, NULL);
+void test___fstat__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fstat(x, arg2);
 }
 
-void test___wstat64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wstat64(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___fstat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _fstat(arg1, NULL);
 }
 
-void test___wstat64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _wstat64(p, arg2);
-    // cppcheck-suppress memleak
+void test___fstat32__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _fstat32(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wstat64__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wstat64(NULL, arg2);
+void test___fstat32__leakignore() {
+  char *p = malloc(10); *p=0;
+  _fstat32(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___wstat64__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wstat64(x, arg2);
+void test___fstat32__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fstat32(x, arg2);
 }
 
-void test___wstat64__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wstat64(arg1, NULL);
+void test___fstat32__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _fstat32(arg1, NULL);
 }
 
-void test___wstati64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wstati64(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___fstat64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _fstat64(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wstati64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _wstati64(p, arg2);
-    // cppcheck-suppress memleak
+void test___fstat64__leakignore() {
+  char *p = malloc(10); *p=0;
+  _fstat64(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___wstati64__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wstati64(NULL, arg2);
+void test___fstat64__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fstat64(x, arg2);
 }
 
-void test___wstati64__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wstati64(x, arg2);
+void test___fstat64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _fstat64(arg1, NULL);
 }
 
-void test___wstati64__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wstati64(arg1, NULL);
+void test___fstati64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _fstati64(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wstat32i64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wstat32i64(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___fstati64__leakignore() {
+  char *p = malloc(10); *p=0;
+  _fstati64(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___wstat32i64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _wstat32i64(p, arg2);
-    // cppcheck-suppress memleak
+void test___fstati64__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fstati64(x, arg2);
 }
 
-void test___wstat32i64__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wstat32i64(NULL, arg2);
+void test___fstati64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _fstati64(arg1, NULL);
 }
 
-void test___wstat32i64__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wstat32i64(x, arg2);
+void test___fstat32i64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _fstat32i64(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wstat32i64__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wstat32i64(arg1, NULL);
+void test___fstat32i64__leakignore() {
+  char *p = malloc(10); *p=0;
+  _fstat32i64(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___wstat64i32__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wstat64i32(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___fstat32i64__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fstat32i64(x, arg2);
 }
 
-void test___wstat64i32__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _wstat64i32(p, arg2);
-    // cppcheck-suppress memleak
+void test___fstat32i64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _fstat32i64(arg1, NULL);
 }
 
-void test___wstat64i32__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wstat64i32(NULL, arg2);
+void test___fstat64i32__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _fstat64i32(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wstat64i32__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wstat64i32(x, arg2);
+void test___fstat64i32__leakignore() {
+  char *p = malloc(10); *p=0;
+  _fstat64i32(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___wstat64i32__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wstat64i32(arg1, NULL);
+void test___fstat64i32__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fstat64i32(x, arg2);
 }
 
-void test___fstat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _fstat(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___fstat64i32__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _fstat64i32(arg1, NULL);
 }
 
-void test___fstat__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _fstat(p, arg2);
-    // cppcheck-suppress memleak
+void test___fseeki64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _fseeki64(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___fstat__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _fstat(x, arg2);
+void test___fseeki64__leakignore() {
+  char *p = malloc(10); *p=0;
+  _fseeki64(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___fstat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _fstat(arg1, NULL);
+void test___fseeki64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _fseeki64(NULL, arg2, arg3);
 }
 
-void test___fstat32__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _fstat32(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___fseeki64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _fseeki64(x, arg2, arg3);
 }
 
-void test___fstat32__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _fstat32(p, arg2);
-    // cppcheck-suppress memleak
+void test___fseeki64__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fseeki64(arg1, x, arg3);
 }
 
-void test___fstat32__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _fstat32(x, arg2);
+void test___fseeki64__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fseeki64(arg1, arg2, x);
 }
 
-void test___fstat32__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _fstat32(arg1, NULL);
+void test___ftelli64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _ftelli64(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___fstat64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _fstat64(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___ftelli64__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _ftelli64(arg1);
 }
 
-void test___fstat64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _fstat64(p, arg2);
-    // cppcheck-suppress memleak
+void test___ftelli64__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _ftelli64(p);
+  // cppcheck-suppress memleak
 }
 
-void test___fstat64__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _fstat64(x, arg2);
+void test___ftelli64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _ftelli64(NULL);
 }
 
-void test___fstat64__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _fstat64(arg1, NULL);
+void test___ftelli64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _ftelli64(x);
 }
 
-void test___fstati64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _fstati64(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___ftell_nolock__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _ftell_nolock(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___fstati64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _fstati64(p, arg2);
-    // cppcheck-suppress memleak
+void test___ftell_nolock__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _ftell_nolock(arg1);
 }
 
-void test___fstati64__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _fstati64(x, arg2);
+void test___ftell_nolock__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _ftell_nolock(p);
+  // cppcheck-suppress memleak
 }
 
-void test___fstati64__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _fstati64(arg1, NULL);
+void test___ftell_nolock__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _ftell_nolock(NULL);
 }
 
-void test___fstat32i64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _fstat32i64(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___ftell_nolock__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _ftell_nolock(x);
 }
 
-void test___fstat32i64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _fstat32i64(p, arg2);
-    // cppcheck-suppress memleak
+void test___ftelli64_nolock__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _ftelli64_nolock(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___fstat32i64__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _fstat32i64(x, arg2);
+void test___ftelli64_nolock__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _ftelli64_nolock(arg1);
 }
 
-void test___fstat32i64__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _fstat32i64(arg1, NULL);
+void test___ftelli64_nolock__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _ftelli64_nolock(p);
+  // cppcheck-suppress memleak
 }
 
-void test___fstat64i32__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _fstat64i32(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___ftelli64_nolock__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _ftelli64_nolock(NULL);
 }
 
-void test___fstat64i32__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _fstat64i32(p, arg2);
-    // cppcheck-suppress memleak
+void test___ftelli64_nolock__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _ftelli64_nolock(x);
 }
 
-void test___fstat64i32__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _fstat64i32(x, arg2);
+void test___wfopen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _wfopen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___fstat64i32__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _fstat64i32(arg1, NULL);
+void test___wfopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _wfopen(arg1, arg2);
 }
 
-void test___fseeki64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _fseeki64(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wfopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wfopen(NULL, arg2);
 }
 
-void test___fseeki64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _fseeki64(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___wfopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wfopen(x, arg2);
 }
 
-void test___fseeki64__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _fseeki64(NULL, arg2, arg3);
+void test___wfopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wfopen(arg1, NULL);
 }
 
-void test___fseeki64__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _fseeki64(x, arg2, arg3);
+void test___wfopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wfopen(arg1, x);
 }
 
-void test___fseeki64__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _fseeki64(arg1, x, arg3);
+void test___tfopen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _tfopen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___fseeki64__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _fseeki64(arg1, arg2, x);
+void test___tfopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tfopen(arg1, arg2);
 }
 
-void test___ftelli64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _ftelli64(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tfopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tfopen(NULL, arg2);
 }
 
-void test___ftelli64__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _ftelli64(arg1);
+void test___tfopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tfopen(x, arg2);
 }
 
-void test___ftelli64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _ftelli64(p);
-    // cppcheck-suppress memleak
+void test___tfopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tfopen(arg1, NULL);
 }
 
-void test___ftelli64__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _ftelli64(NULL);
+void test___tfopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tfopen(arg1, x);
 }
 
-void test___ftelli64__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _ftelli64(x);
+void test__strnlen_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = strnlen_s(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___ftell_nolock__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _ftell_nolock(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strnlen_s__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strnlen_s(arg1, arg2);
 }
 
-void test___ftell_nolock__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _ftell_nolock(arg1);
+void test__strnlen_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = strnlen_s(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___ftell_nolock__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _ftell_nolock(p);
-    // cppcheck-suppress memleak
+void test__strnlen_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strnlen_s(NULL, arg2);
 }
 
-void test___ftell_nolock__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _ftell_nolock(NULL);
+void test__strnlen_s__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strnlen_s(x, arg2);
 }
 
-void test___ftell_nolock__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _ftell_nolock(x);
+void test__strnlen_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strnlen_s(arg1, x);
 }
 
-void test___ftelli64_nolock__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _ftelli64_nolock(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsnlen_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wcsnlen_s(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___ftelli64_nolock__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _ftelli64_nolock(arg1);
+void test__wcsnlen_s__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcsnlen_s(arg1, arg2);
 }
 
-void test___ftelli64_nolock__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _ftelli64_nolock(p);
-    // cppcheck-suppress memleak
+void test__wcsnlen_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wcsnlen_s(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___ftelli64_nolock__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _ftelli64_nolock(NULL);
+void test__wcsnlen_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsnlen_s(NULL, arg2);
 }
 
-void test___ftelli64_nolock__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _ftelli64_nolock(x);
+void test__wcsnlen_s__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsnlen_s(x, arg2);
 }
 
-void test___wfopen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _wfopen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wcsnlen_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcsnlen_s(arg1, x);
 }
 
-void test___wfopen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _wfopen(arg1, arg2);
+void test___mbsnlen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mbsnlen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wfopen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _wfopen(NULL, arg2);
+void test___mbsnlen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsnlen(arg1, arg2);
 }
 
-void test___wfopen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _wfopen(x, arg2);
+void test___mbsnlen__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mbsnlen(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___wfopen__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _wfopen(arg1, NULL);
+void test___mbsnlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsnlen(NULL, arg2);
 }
 
-void test___wfopen__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _wfopen(arg1, x);
+void test___mbsnlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsnlen(x, arg2);
 }
 
-void test___tfopen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _tfopen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbsnlen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsnlen(arg1, x);
 }
 
-void test___tfopen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _tfopen(arg1, arg2);
+void test___mbstrnlen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mbstrnlen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tfopen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tfopen(NULL, arg2);
+void test___mbstrnlen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbstrnlen(arg1, arg2);
 }
 
-void test___tfopen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tfopen(x, arg2);
+void test___mbstrnlen__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mbstrnlen(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___tfopen__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tfopen(arg1, NULL);
+void test___mbstrnlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbstrnlen(NULL, arg2);
 }
 
-void test___tfopen__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tfopen(arg1, x);
+void test___mbstrnlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbstrnlen(x, arg2);
 }
 
-void test__strnlen_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = strnlen_s(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbstrnlen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbstrnlen(arg1, x);
 }
 
-void test__strnlen_s__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    strnlen_s(arg1, arg2);
+void test___mbsnlen_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mbsnlen_l(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__strnlen_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = strnlen_s(p, arg2);
-    // cppcheck-suppress memleak
+void test___mbsnlen_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsnlen_l(arg1, arg2, arg3);
 }
 
-void test__strnlen_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = strnlen_s(NULL, arg2);
+void test___mbsnlen_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mbsnlen_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__strnlen_s__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = strnlen_s(x, arg2);
+void test___mbsnlen_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsnlen_l(NULL, arg2, arg3);
 }
 
-void test__strnlen_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = strnlen_s(arg1, x);
+void test___mbsnlen_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsnlen_l(x, arg2, arg3);
 }
 
-void test__wcsnlen_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wcsnlen_s(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbsnlen_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsnlen_l(arg1, x, arg3);
 }
 
-void test__wcsnlen_s__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wcsnlen_s(arg1, arg2);
+void test___mbsnlen_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsnlen_l(arg1, arg2, x);
 }
 
-void test__wcsnlen_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wcsnlen_s(p, arg2);
-    // cppcheck-suppress memleak
+void test___mbstrnlen_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mbstrnlen_l(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wcsnlen_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = wcsnlen_s(NULL, arg2);
+void test___mbstrnlen_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbstrnlen_l(arg1, arg2, arg3);
 }
 
-void test__wcsnlen_s__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = wcsnlen_s(x, arg2);
+void test___mbstrnlen_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mbstrnlen_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__wcsnlen_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wcsnlen_s(arg1, x);
+void test___mbstrnlen_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbstrnlen_l(NULL, arg2, arg3);
 }
 
-void test___mbsnlen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mbsnlen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbstrnlen_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbstrnlen_l(x, arg2, arg3);
 }
 
-void test___mbsnlen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mbsnlen(arg1, arg2);
+void test___mbstrnlen_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbstrnlen_l(arg1, x, arg3);
 }
 
-void test___mbsnlen__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mbsnlen(p, arg2);
-    // cppcheck-suppress memleak
+void test___mbstrnlen_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbstrnlen_l(arg1, arg2, x);
 }
 
-void test___mbsnlen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbsnlen(NULL, arg2);
+void test__WideCharToMultiByte__noreturn() {
+  int x = 1;
+  if (cond) { x=100; WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsnlen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbsnlen(x, arg2);
+void test__WideCharToMultiByte__leakignore() {
+  char *p = malloc(10); *p=0;
+  WideCharToMultiByte(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+  // cppcheck-suppress memleak
 }
 
-void test___mbsnlen__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _mbsnlen(arg1, x);
+void test__WideCharToMultiByte__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WideCharToMultiByte(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
 }
 
-void test___mbstrnlen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mbstrnlen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__WideCharToMultiByte__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WideCharToMultiByte(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
 }
 
-void test___mbstrnlen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mbstrnlen(arg1, arg2);
+void test__WideCharToMultiByte__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WideCharToMultiByte(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8);
 }
 
-void test___mbstrnlen__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mbstrnlen(p, arg2);
-    // cppcheck-suppress memleak
+void test__WideCharToMultiByte__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WideCharToMultiByte(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8);
 }
 
-void test___mbstrnlen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbstrnlen(NULL, arg2);
+void test__WideCharToMultiByte__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8);
 }
 
-void test___mbstrnlen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbstrnlen(x, arg2);
+void test__WideCharToMultiByte__arg7__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8);
 }
 
-void test___mbstrnlen__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _mbstrnlen(arg1, x);
+void test__PathIsDirectory__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = PathIsDirectory(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsnlen_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mbsnlen_l(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__PathIsDirectory__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  PathIsDirectory(arg1);
 }
 
-void test___mbsnlen_l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mbsnlen_l(arg1, arg2, arg3);
+void test__PathIsDirectory__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = PathIsDirectory(p);
+  // cppcheck-suppress memleak
 }
 
-void test___mbsnlen_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mbsnlen_l(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__PathIsDirectory__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = PathIsDirectory(x);
 }
 
-void test___mbsnlen_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbsnlen_l(NULL, arg2, arg3);
+void test__PathIsDirectoryA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = PathIsDirectoryA(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsnlen_l__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbsnlen_l(x, arg2, arg3);
+void test__PathIsDirectoryA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  PathIsDirectoryA(arg1);
 }
 
-void test___mbsnlen_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _mbsnlen_l(arg1, x, arg3);
+void test__PathIsDirectoryA__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = PathIsDirectoryA(p);
+  // cppcheck-suppress memleak
 }
 
-void test___mbsnlen_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _mbsnlen_l(arg1, arg2, x);
+void test__PathIsDirectoryA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = PathIsDirectoryA(x);
 }
 
-void test___mbstrnlen_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mbstrnlen_l(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__PathIsDirectoryW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = PathIsDirectoryW(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbstrnlen_l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mbstrnlen_l(arg1, arg2, arg3);
+void test__PathIsDirectoryW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  PathIsDirectoryW(arg1);
 }
 
-void test___mbstrnlen_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mbstrnlen_l(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__PathIsDirectoryW__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = PathIsDirectoryW(p);
+  // cppcheck-suppress memleak
 }
 
-void test___mbstrnlen_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbstrnlen_l(NULL, arg2, arg3);
+void test__PathIsDirectoryW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = PathIsDirectoryW(x);
 }
 
-void test___mbstrnlen_l__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbstrnlen_l(x, arg2, arg3);
+void test__SetConsoleTextAttribute__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetConsoleTextAttribute(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbstrnlen_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _mbstrnlen_l(arg1, x, arg3);
+void test__SetConsoleTextAttribute__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetConsoleTextAttribute(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___mbstrnlen_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _mbstrnlen_l(arg1, arg2, x);
+void test__SetConsoleTextAttribute__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetConsoleTextAttribute(x, arg2);
 }
 
-void test__WideCharToMultiByte__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SetConsoleTextAttribute__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetConsoleTextAttribute(arg1, x);
 }
 
-void test__WideCharToMultiByte__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    WideCharToMultiByte(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-    // cppcheck-suppress memleak
+void test___wfopen_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wfopen_s(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__WideCharToMultiByte__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    WideCharToMultiByte(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+void test___wfopen_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wfopen_s(NULL, arg2, arg3);
 }
 
-void test__WideCharToMultiByte__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    WideCharToMultiByte(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
+void test___wfopen_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wfopen_s(arg1, NULL, arg3);
 }
 
-void test__WideCharToMultiByte__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    WideCharToMultiByte(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8);
+void test___wfopen_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wfopen_s(arg1, x, arg3);
 }
 
-void test__WideCharToMultiByte__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    WideCharToMultiByte(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8);
+void test___wfopen_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _wfopen_s(arg1, arg2, NULL);
 }
 
-void test__WideCharToMultiByte__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8);
+void test___wfopen_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wfopen_s(arg1, arg2, x);
 }
 
-void test__WideCharToMultiByte__arg7__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8);
+void test___tfopen_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tfopen_s(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__PathIsDirectory__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = PathIsDirectory(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tfopen_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tfopen_s(NULL, arg2, arg3);
 }
 
-void test__PathIsDirectory__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    PathIsDirectory(arg1);
+void test___tfopen_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tfopen_s(arg1, NULL, arg3);
 }
 
-void test__PathIsDirectory__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = PathIsDirectory(p);
-    // cppcheck-suppress memleak
+void test___tfopen_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tfopen_s(arg1, x, arg3);
 }
 
-void test__PathIsDirectory__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = PathIsDirectory(x);
+void test___tfopen_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _tfopen_s(arg1, arg2, NULL);
 }
 
-void test__PathIsDirectoryA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = PathIsDirectoryA(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tfopen_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tfopen_s(arg1, arg2, x);
 }
 
-void test__PathIsDirectoryA__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    PathIsDirectoryA(arg1);
+void test__DeleteFile__noreturn() {
+  int x = 1;
+  if (cond) { x=100; DeleteFile(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__PathIsDirectoryA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = PathIsDirectoryA(p);
-    // cppcheck-suppress memleak
+void test__DeleteFile__leakignore() {
+  char *p = malloc(10); *p=0;
+  DeleteFile(p);
+  // cppcheck-suppress memleak
 }
 
-void test__PathIsDirectoryA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = PathIsDirectoryA(x);
+void test__DeleteFile__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DeleteFile(x);
 }
 
-void test__PathIsDirectoryW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = PathIsDirectoryW(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__DeleteFileA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; DeleteFileA(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__PathIsDirectoryW__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    PathIsDirectoryW(arg1);
+void test__DeleteFileA__leakignore() {
+  char *p = malloc(10); *p=0;
+  DeleteFileA(p);
+  // cppcheck-suppress memleak
 }
 
-void test__PathIsDirectoryW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = PathIsDirectoryW(p);
-    // cppcheck-suppress memleak
+void test__DeleteFileA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DeleteFileA(x);
 }
 
-void test__PathIsDirectoryW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = PathIsDirectoryW(x);
+void test__DeleteFileW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; DeleteFileW(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SetConsoleTextAttribute__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetConsoleTextAttribute(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__DeleteFileW__leakignore() {
+  char *p = malloc(10); *p=0;
+  DeleteFileW(p);
+  // cppcheck-suppress memleak
 }
 
-void test__SetConsoleTextAttribute__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetConsoleTextAttribute(p, arg2);
-    // cppcheck-suppress memleak
+void test__DeleteFileW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DeleteFileW(x);
 }
 
-void test__SetConsoleTextAttribute__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetConsoleTextAttribute(x, arg2);
+void test__GetStdHandle__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = GetStdHandle(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SetConsoleTextAttribute__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetConsoleTextAttribute(arg1, x);
+void test__GetStdHandle__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetStdHandle(arg1);
 }
 
-void test___wfopen_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wfopen_s(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetStdHandle__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = GetStdHandle(p);
+  // cppcheck-suppress memleak
 }
 
-void test___wfopen_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wfopen_s(NULL, arg2, arg3);
+void test__GetStdHandle__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetStdHandle(x);
 }
 
-void test___wfopen_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wfopen_s(arg1, NULL, arg3);
+void test__SetStdHandle__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetStdHandle(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wfopen_s__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wfopen_s(arg1, x, arg3);
+void test__SetStdHandle__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetStdHandle(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___wfopen_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wfopen_s(arg1, arg2, NULL);
+void test__SetStdHandle__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetStdHandle(x, arg2);
 }
 
-void test___wfopen_s__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wfopen_s(arg1, arg2, x);
+void test__SetStdHandle__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetStdHandle(arg1, x);
 }
 
-void test___tfopen_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tfopen_s(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___access__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _access(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tfopen_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tfopen_s(NULL, arg2, arg3);
+void test___access__leakignore() {
+  char *p = malloc(10); *p=0;
+  _access(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___tfopen_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tfopen_s(arg1, NULL, arg3);
+void test___access__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _access(NULL, arg2);
 }
 
-void test___tfopen_s__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tfopen_s(arg1, x, arg3);
+void test___access__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _access(x, arg2);
 }
 
-void test___tfopen_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tfopen_s(arg1, arg2, NULL);
+void test___access__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _access(arg1, x);
 }
 
-void test___tfopen_s__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tfopen_s(arg1, arg2, x);
+void test___waccess__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _waccess(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__DeleteFile__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        DeleteFile(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___waccess__leakignore() {
+  char *p = malloc(10); *p=0;
+  _waccess(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__DeleteFile__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    DeleteFile(p);
-    // cppcheck-suppress memleak
+void test___waccess__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _waccess(NULL, arg2);
 }
 
-void test__DeleteFile__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    DeleteFile(x);
+void test___waccess__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _waccess(x, arg2);
 }
 
-void test__DeleteFileA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        DeleteFileA(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___waccess__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _waccess(arg1, x);
 }
 
-void test__DeleteFileA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    DeleteFileA(p);
-    // cppcheck-suppress memleak
+void test___taccess__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _taccess(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__DeleteFileA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    DeleteFileA(x);
-}
-
-void test__DeleteFileW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        DeleteFileW(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___taccess__leakignore() {
+  char *p = malloc(10); *p=0;
+  _taccess(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__DeleteFileW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    DeleteFileW(p);
-    // cppcheck-suppress memleak
+void test___taccess__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _taccess(NULL, arg2);
 }
 
-void test__DeleteFileW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    DeleteFileW(x);
+void test___taccess__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _taccess(x, arg2);
 }
 
-void test__GetStdHandle__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = GetStdHandle(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__GetStdHandle__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    GetStdHandle(arg1);
-}
-
-void test__GetStdHandle__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = GetStdHandle(p);
-    // cppcheck-suppress memleak
-}
-
-void test__GetStdHandle__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = GetStdHandle(x);
+void test___taccess__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _taccess(arg1, x);
 }
 
-void test__SetStdHandle__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetStdHandle(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__PeekMessage__noreturn() {
+  int x = 1;
+  if (cond) { x=100; PeekMessage(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__SetStdHandle__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetStdHandle(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__SetStdHandle__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetStdHandle(x, arg2);
+void test__PeekMessage__leakignore() {
+  char *p = malloc(10); *p=0;
+  PeekMessage(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test__SetStdHandle__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetStdHandle(arg1, x);
+void test__PeekMessage__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  PeekMessage(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test___access__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _access(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__PeekMessage__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessage(arg1, x, arg3, arg4, arg5);
 }
 
-void test___access__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _access(p, arg2);
-    // cppcheck-suppress memleak
+void test__PeekMessage__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessage(arg1, arg2, x, arg4, arg5);
 }
 
-void test___access__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _access(NULL, arg2);
+void test__PeekMessage__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessage(arg1, arg2, arg3, x, arg5);
 }
 
-void test___access__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _access(x, arg2);
+void test__PeekMessage__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessage(arg1, arg2, arg3, arg4, x);
 }
 
-void test___access__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _access(arg1, x);
+void test__PeekMessageA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; PeekMessageA(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___waccess__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _waccess(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__PeekMessageA__leakignore() {
+  char *p = malloc(10); *p=0;
+  PeekMessageA(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test___waccess__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _waccess(p, arg2);
-    // cppcheck-suppress memleak
+void test__PeekMessageA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  PeekMessageA(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test___waccess__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _waccess(NULL, arg2);
+void test__PeekMessageA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageA(arg1, x, arg3, arg4, arg5);
 }
 
-void test___waccess__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _waccess(x, arg2);
+void test__PeekMessageA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageA(arg1, arg2, x, arg4, arg5);
 }
 
-void test___waccess__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _waccess(arg1, x);
+void test__PeekMessageA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageA(arg1, arg2, arg3, x, arg5);
 }
 
-void test___taccess__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _taccess(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__PeekMessageA__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageA(arg1, arg2, arg3, arg4, x);
 }
 
-void test___taccess__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _taccess(p, arg2);
-    // cppcheck-suppress memleak
+void test__PeekMessageW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; PeekMessageW(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___taccess__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _taccess(NULL, arg2);
+void test__PeekMessageW__leakignore() {
+  char *p = malloc(10); *p=0;
+  PeekMessageW(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test___taccess__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _taccess(x, arg2);
+void test__PeekMessageW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  PeekMessageW(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test___taccess__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _taccess(arg1, x);
+void test__PeekMessageW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageW(arg1, x, arg3, arg4, arg5);
 }
 
-void test__PeekMessage__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        PeekMessage(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__PeekMessageW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageW(arg1, arg2, x, arg4, arg5);
 }
 
-void test__PeekMessage__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    PeekMessage(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test__PeekMessageW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageW(arg1, arg2, arg3, x, arg5);
 }
 
-void test__PeekMessage__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    PeekMessage(NULL, arg2, arg3, arg4, arg5);
+void test__PeekMessageW__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageW(arg1, arg2, arg3, arg4, x);
 }
 
-void test__PeekMessage__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PeekMessage(arg1, x, arg3, arg4, arg5);
+void test__GetMessage__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetMessage(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__PeekMessage__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PeekMessage(arg1, arg2, x, arg4, arg5);
+void test__GetMessage__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetMessage(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__PeekMessage__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PeekMessage(arg1, arg2, arg3, x, arg5);
+void test__GetMessage__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetMessage(NULL, arg2, arg3, arg4);
 }
 
-void test__PeekMessage__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PeekMessage(arg1, arg2, arg3, arg4, x);
+void test__GetMessage__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessage(arg1, x, arg3, arg4);
 }
 
-void test__PeekMessageA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        PeekMessageA(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetMessage__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessage(arg1, arg2, x, arg4);
 }
 
-void test__PeekMessageA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    PeekMessageA(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test__GetMessage__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessage(arg1, arg2, arg3, x);
 }
 
-void test__PeekMessageA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    PeekMessageA(NULL, arg2, arg3, arg4, arg5);
+void test__GetMessageA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetMessageA(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__PeekMessageA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PeekMessageA(arg1, x, arg3, arg4, arg5);
+void test__GetMessageA__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetMessageA(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__PeekMessageA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PeekMessageA(arg1, arg2, x, arg4, arg5);
+void test__GetMessageA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetMessageA(NULL, arg2, arg3, arg4);
 }
 
-void test__PeekMessageA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PeekMessageA(arg1, arg2, arg3, x, arg5);
+void test__GetMessageA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessageA(arg1, x, arg3, arg4);
 }
 
-void test__PeekMessageA__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PeekMessageA(arg1, arg2, arg3, arg4, x);
+void test__GetMessageA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessageA(arg1, arg2, x, arg4);
 }
 
-void test__PeekMessageW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        PeekMessageW(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetMessageA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessageA(arg1, arg2, arg3, x);
 }
 
-void test__PeekMessageW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    PeekMessageW(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test__GetMessageW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetMessageW(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__PeekMessageW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    PeekMessageW(NULL, arg2, arg3, arg4, arg5);
+void test__GetMessageW__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetMessageW(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__PeekMessageW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PeekMessageW(arg1, x, arg3, arg4, arg5);
+void test__GetMessageW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetMessageW(NULL, arg2, arg3, arg4);
 }
 
-void test__PeekMessageW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PeekMessageW(arg1, arg2, x, arg4, arg5);
+void test__GetMessageW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessageW(arg1, x, arg3, arg4);
 }
 
-void test__PeekMessageW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PeekMessageW(arg1, arg2, arg3, x, arg5);
+void test__GetMessageW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessageW(arg1, arg2, x, arg4);
 }
 
-void test__PeekMessageW__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PeekMessageW(arg1, arg2, arg3, arg4, x);
+void test__GetMessageW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessageW(arg1, arg2, arg3, x);
 }
 
-void test__GetMessage__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetMessage(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__TranslateMessage__noreturn() {
+  int x = 1;
+  if (cond) { x=100; TranslateMessage(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetMessage__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetMessage(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__TranslateMessage__leakignore() {
+  char *p = malloc(10); *p=0;
+  TranslateMessage(p);
+  // cppcheck-suppress memleak
 }
 
-void test__GetMessage__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetMessage(NULL, arg2, arg3, arg4);
+void test__TranslateMessage__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  TranslateMessage(NULL);
 }
 
-void test__GetMessage__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetMessage(arg1, x, arg3, arg4);
+void test__TranslateMessage__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  TranslateMessage(x);
 }
 
-void test__GetMessage__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetMessage(arg1, arg2, x, arg4);
+void test__DispatchMessage__noreturn() {
+  int x = 1;
+  if (cond) { x=100; DispatchMessage(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetMessage__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetMessage(arg1, arg2, arg3, x);
+void test__DispatchMessage__leakignore() {
+  char *p = malloc(10); *p=0;
+  DispatchMessage(p);
+  // cppcheck-suppress memleak
 }
 
-void test__GetMessageA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetMessageA(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__DispatchMessage__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DispatchMessage(NULL);
 }
 
-void test__GetMessageA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetMessageA(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__DispatchMessage__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DispatchMessage(x);
 }
 
-void test__GetMessageA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetMessageA(NULL, arg2, arg3, arg4);
+void test__DispatchMessageA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; DispatchMessageA(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetMessageA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetMessageA(arg1, x, arg3, arg4);
+void test__DispatchMessageA__leakignore() {
+  char *p = malloc(10); *p=0;
+  DispatchMessageA(p);
+  // cppcheck-suppress memleak
 }
 
-void test__GetMessageA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetMessageA(arg1, arg2, x, arg4);
+void test__DispatchMessageA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DispatchMessageA(NULL);
 }
 
-void test__GetMessageA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetMessageA(arg1, arg2, arg3, x);
+void test__DispatchMessageA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DispatchMessageA(x);
 }
 
-void test__GetMessageW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetMessageW(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__DispatchMessageW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; DispatchMessageW(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetMessageW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetMessageW(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__DispatchMessageW__leakignore() {
+  char *p = malloc(10); *p=0;
+  DispatchMessageW(p);
+  // cppcheck-suppress memleak
 }
 
-void test__GetMessageW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetMessageW(NULL, arg2, arg3, arg4);
+void test__DispatchMessageW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DispatchMessageW(NULL);
 }
 
-void test__GetMessageW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetMessageW(arg1, x, arg3, arg4);
+void test__DispatchMessageW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DispatchMessageW(x);
 }
 
-void test__GetMessageW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetMessageW(arg1, arg2, x, arg4);
+void test__SendMessage__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SendMessage(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetMessageW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetMessageW(arg1, arg2, arg3, x);
+void test__SendMessage__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SendMessage(NULL, arg2, arg3, arg4);
 }
 
-void test__TranslateMessage__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        TranslateMessage(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SendMessage__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SendMessage(x, arg2, arg3, arg4);
 }
 
-void test__TranslateMessage__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    TranslateMessage(p);
-    // cppcheck-suppress memleak
+void test__SendMessage__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessage(arg1, x, arg3, arg4);
 }
 
-void test__TranslateMessage__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    TranslateMessage(NULL);
+void test__SendMessage__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessage(arg1, arg2, x, arg4);
 }
 
-void test__TranslateMessage__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    TranslateMessage(x);
+void test__SendMessage__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessage(arg1, arg2, arg3, x);
 }
 
-void test__DispatchMessage__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        DispatchMessage(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SendMessageA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SendMessageA(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__DispatchMessage__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    DispatchMessage(p);
-    // cppcheck-suppress memleak
+void test__SendMessageA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SendMessageA(NULL, arg2, arg3, arg4);
 }
 
-void test__DispatchMessage__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    DispatchMessage(NULL);
+void test__SendMessageA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SendMessageA(x, arg2, arg3, arg4);
 }
 
-void test__DispatchMessage__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    DispatchMessage(x);
+void test__SendMessageA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessageA(arg1, x, arg3, arg4);
 }
 
-void test__DispatchMessageA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        DispatchMessageA(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SendMessageA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessageA(arg1, arg2, x, arg4);
 }
 
-void test__DispatchMessageA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    DispatchMessageA(p);
-    // cppcheck-suppress memleak
+void test__SendMessageA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessageA(arg1, arg2, arg3, x);
 }
 
-void test__DispatchMessageA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    DispatchMessageA(NULL);
+void test__SendMessageW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SendMessageW(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__DispatchMessageA__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    DispatchMessageA(x);
+void test__SendMessageW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SendMessageW(NULL, arg2, arg3, arg4);
 }
 
-void test__DispatchMessageW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        DispatchMessageW(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SendMessageW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SendMessageW(x, arg2, arg3, arg4);
 }
 
-void test__DispatchMessageW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    DispatchMessageW(p);
-    // cppcheck-suppress memleak
+void test__SendMessageW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessageW(arg1, x, arg3, arg4);
 }
 
-void test__DispatchMessageW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    DispatchMessageW(NULL);
+void test__SendMessageW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessageW(arg1, arg2, x, arg4);
 }
 
-void test__DispatchMessageW__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    DispatchMessageW(x);
+void test__SendMessageW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessageW(arg1, arg2, arg3, x);
 }
 
-void test__SendMessage__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SendMessage(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__PostMessage__noreturn() {
+  int x = 1;
+  if (cond) { x=100; PostMessage(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SendMessage__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SendMessage(NULL, arg2, arg3, arg4);
+void test__PostMessage__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  PostMessage(NULL, arg2, arg3, arg4);
 }
 
-void test__SendMessage__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    SendMessage(x, arg2, arg3, arg4);
+void test__PostMessage__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  PostMessage(x, arg2, arg3, arg4);
 }
 
-void test__SendMessage__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SendMessage(arg1, x, arg3, arg4);
+void test__PostMessage__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessage(arg1, x, arg3, arg4);
 }
 
-void test__SendMessage__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SendMessage(arg1, arg2, x, arg4);
+void test__PostMessage__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessage(arg1, arg2, x, arg4);
 }
 
-void test__SendMessage__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SendMessage(arg1, arg2, arg3, x);
+void test__PostMessage__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessage(arg1, arg2, arg3, x);
 }
 
-void test__SendMessageA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SendMessageA(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__PostMessageA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; PostMessageA(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SendMessageA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SendMessageA(NULL, arg2, arg3, arg4);
+void test__PostMessageA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  PostMessageA(NULL, arg2, arg3, arg4);
 }
 
-void test__SendMessageA__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    SendMessageA(x, arg2, arg3, arg4);
+void test__PostMessageA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  PostMessageA(x, arg2, arg3, arg4);
 }
 
-void test__SendMessageA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SendMessageA(arg1, x, arg3, arg4);
+void test__PostMessageA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessageA(arg1, x, arg3, arg4);
 }
 
-void test__SendMessageA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SendMessageA(arg1, arg2, x, arg4);
+void test__PostMessageA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessageA(arg1, arg2, x, arg4);
 }
 
-void test__SendMessageA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SendMessageA(arg1, arg2, arg3, x);
+void test__PostMessageA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessageA(arg1, arg2, arg3, x);
 }
 
-void test__SendMessageW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SendMessageW(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__PostMessageW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; PostMessageW(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SendMessageW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SendMessageW(NULL, arg2, arg3, arg4);
+void test__PostMessageW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  PostMessageW(NULL, arg2, arg3, arg4);
 }
 
-void test__SendMessageW__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    SendMessageW(x, arg2, arg3, arg4);
+void test__PostMessageW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  PostMessageW(x, arg2, arg3, arg4);
 }
 
-void test__SendMessageW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SendMessageW(arg1, x, arg3, arg4);
+void test__PostMessageW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessageW(arg1, x, arg3, arg4);
 }
 
-void test__SendMessageW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SendMessageW(arg1, arg2, x, arg4);
+void test__PostMessageW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessageW(arg1, arg2, x, arg4);
 }
 
-void test__SendMessageW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SendMessageW(arg1, arg2, arg3, x);
+void test__PostMessageW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessageW(arg1, arg2, arg3, x);
 }
 
-void test__PostMessage__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        PostMessage(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__PostQuitMessage__noreturn() {
+  int x = 1;
+  if (cond) { x=100; PostQuitMessage(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__PostMessage__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    PostMessage(NULL, arg2, arg3, arg4);
+void test__PostQuitMessage__leakignore() {
+  char *p = malloc(10); *p=0;
+  PostQuitMessage(p);
+  // cppcheck-suppress memleak
 }
 
-void test__PostMessage__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    PostMessage(x, arg2, arg3, arg4);
+void test__PostQuitMessage__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostQuitMessage(x);
 }
 
-void test__PostMessage__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PostMessage(arg1, x, arg3, arg4);
+void test__DefWindowProc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; DefWindowProc(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__PostMessage__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PostMessage(arg1, arg2, x, arg4);
+void test__DefWindowProc__leakignore() {
+  char *p = malloc(10); *p=0;
+  DefWindowProc(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__PostMessage__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PostMessage(arg1, arg2, arg3, x);
+void test__DefWindowProc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DefWindowProc(NULL, arg2, arg3, arg4);
 }
 
-void test__PostMessageA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        PostMessageA(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__DefWindowProc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DefWindowProc(x, arg2, arg3, arg4);
 }
 
-void test__PostMessageA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    PostMessageA(NULL, arg2, arg3, arg4);
+void test__DefWindowProc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProc(arg1, x, arg3, arg4);
 }
 
-void test__PostMessageA__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    PostMessageA(x, arg2, arg3, arg4);
+void test__DefWindowProc__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProc(arg1, arg2, x, arg4);
 }
 
-void test__PostMessageA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PostMessageA(arg1, x, arg3, arg4);
+void test__DefWindowProc__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProc(arg1, arg2, arg3, x);
 }
 
-void test__PostMessageA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PostMessageA(arg1, arg2, x, arg4);
+void test__DefWindowProcA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; DefWindowProcA(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__PostMessageA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PostMessageA(arg1, arg2, arg3, x);
+void test__DefWindowProcA__leakignore() {
+  char *p = malloc(10); *p=0;
+  DefWindowProcA(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__PostMessageW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        PostMessageW(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__DefWindowProcA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DefWindowProcA(NULL, arg2, arg3, arg4);
 }
 
-void test__PostMessageW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    PostMessageW(NULL, arg2, arg3, arg4);
+void test__DefWindowProcA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DefWindowProcA(x, arg2, arg3, arg4);
 }
 
-void test__PostMessageW__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    PostMessageW(x, arg2, arg3, arg4);
+void test__DefWindowProcA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProcA(arg1, x, arg3, arg4);
 }
 
-void test__PostMessageW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PostMessageW(arg1, x, arg3, arg4);
+void test__DefWindowProcA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProcA(arg1, arg2, x, arg4);
 }
 
-void test__PostMessageW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PostMessageW(arg1, arg2, x, arg4);
+void test__DefWindowProcA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProcA(arg1, arg2, arg3, x);
 }
 
-void test__PostMessageW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PostMessageW(arg1, arg2, arg3, x);
+void test__DefWindowProcW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; DefWindowProcW(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__PostQuitMessage__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        PostQuitMessage(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__DefWindowProcW__leakignore() {
+  char *p = malloc(10); *p=0;
+  DefWindowProcW(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__PostQuitMessage__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    PostQuitMessage(p);
-    // cppcheck-suppress memleak
+void test__DefWindowProcW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DefWindowProcW(NULL, arg2, arg3, arg4);
 }
 
-void test__PostQuitMessage__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    PostQuitMessage(x);
+void test__DefWindowProcW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DefWindowProcW(x, arg2, arg3, arg4);
 }
 
-void test__DefWindowProc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        DefWindowProc(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__DefWindowProcW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProcW(arg1, x, arg3, arg4);
 }
 
-void test__DefWindowProc__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    DefWindowProc(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__DefWindowProcW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProcW(arg1, arg2, x, arg4);
 }
 
-void test__DefWindowProc__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    DefWindowProc(NULL, arg2, arg3, arg4);
+void test__DefWindowProcW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProcW(arg1, arg2, arg3, x);
 }
 
-void test__DefWindowProc__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    DefWindowProc(x, arg2, arg3, arg4);
+void test__GetPrivateProfileInt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = GetPrivateProfileInt(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__DefWindowProc__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    DefWindowProc(arg1, x, arg3, arg4);
+void test__GetPrivateProfileInt__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetPrivateProfileInt(arg1, arg2, arg3, arg4);
 }
 
-void test__DefWindowProc__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    DefWindowProc(arg1, arg2, x, arg4);
+void test__GetPrivateProfileInt__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = GetPrivateProfileInt(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__DefWindowProc__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    DefWindowProc(arg1, arg2, arg3, x);
+void test__GetPrivateProfileInt__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileInt(NULL, arg2, arg3, arg4);
 }
 
-void test__DefWindowProcA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        DefWindowProcA(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileInt__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileInt(x, arg2, arg3, arg4);
 }
 
-void test__DefWindowProcA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    DefWindowProcA(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileInt__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileInt(arg1, NULL, arg3, arg4);
 }
 
-void test__DefWindowProcA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    DefWindowProcA(NULL, arg2, arg3, arg4);
+void test__GetPrivateProfileInt__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileInt(arg1, x, arg3, arg4);
 }
 
-void test__DefWindowProcA__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    DefWindowProcA(x, arg2, arg3, arg4);
+void test__GetPrivateProfileInt__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileInt(arg1, arg2, x, arg4);
 }
 
-void test__DefWindowProcA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    DefWindowProcA(arg1, x, arg3, arg4);
+void test__GetPrivateProfileInt__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileInt(arg1, arg2, arg3, NULL);
 }
 
-void test__DefWindowProcA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    DefWindowProcA(arg1, arg2, x, arg4);
+void test__GetPrivateProfileInt__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileInt(arg1, arg2, arg3, x);
 }
 
-void test__DefWindowProcA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    DefWindowProcA(arg1, arg2, arg3, x);
+void test__GetPrivateProfileIntA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = GetPrivateProfileIntA(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__DefWindowProcW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        DefWindowProcW(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileIntA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetPrivateProfileIntA(arg1, arg2, arg3, arg4);
 }
 
-void test__DefWindowProcW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    DefWindowProcW(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileIntA__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = GetPrivateProfileIntA(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__DefWindowProcW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    DefWindowProcW(NULL, arg2, arg3, arg4);
+void test__GetPrivateProfileIntA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileIntA(NULL, arg2, arg3, arg4);
 }
 
-void test__DefWindowProcW__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    DefWindowProcW(x, arg2, arg3, arg4);
+void test__GetPrivateProfileIntA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntA(x, arg2, arg3, arg4);
 }
 
-void test__DefWindowProcW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    DefWindowProcW(arg1, x, arg3, arg4);
+void test__GetPrivateProfileIntA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileIntA(arg1, NULL, arg3, arg4);
 }
 
-void test__DefWindowProcW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    DefWindowProcW(arg1, arg2, x, arg4);
+void test__GetPrivateProfileIntA__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntA(arg1, x, arg3, arg4);
 }
 
-void test__DefWindowProcW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    DefWindowProcW(arg1, arg2, arg3, x);
+void test__GetPrivateProfileIntA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntA(arg1, arg2, x, arg4);
 }
 
-void test__GetPrivateProfileInt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = GetPrivateProfileInt(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileIntA__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileIntA(arg1, arg2, arg3, NULL);
 }
 
-void test__GetPrivateProfileInt__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    GetPrivateProfileInt(arg1, arg2, arg3, arg4);
+void test__GetPrivateProfileIntA__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntA(arg1, arg2, arg3, x);
 }
 
-void test__GetPrivateProfileInt__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = GetPrivateProfileInt(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileIntW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = GetPrivateProfileIntW(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileInt__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = GetPrivateProfileInt(NULL, arg2, arg3, arg4);
+void test__GetPrivateProfileIntW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetPrivateProfileIntW(arg1, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileInt__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = GetPrivateProfileInt(x, arg2, arg3, arg4);
+void test__GetPrivateProfileIntW__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = GetPrivateProfileIntW(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileInt__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = GetPrivateProfileInt(arg1, NULL, arg3, arg4);
+void test__GetPrivateProfileIntW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileIntW(NULL, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileInt__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = GetPrivateProfileInt(arg1, x, arg3, arg4);
+void test__GetPrivateProfileIntW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntW(x, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileInt__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = GetPrivateProfileInt(arg1, arg2, x, arg4);
+void test__GetPrivateProfileIntW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileIntW(arg1, NULL, arg3, arg4);
 }
 
-void test__GetPrivateProfileInt__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = GetPrivateProfileInt(arg1, arg2, arg3, NULL);
+void test__GetPrivateProfileIntW__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntW(arg1, x, arg3, arg4);
 }
 
-void test__GetPrivateProfileInt__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = GetPrivateProfileInt(arg1, arg2, arg3, x);
+void test__GetPrivateProfileIntW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntW(arg1, arg2, x, arg4);
 }
 
-void test__GetPrivateProfileIntA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = GetPrivateProfileIntA(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileIntW__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileIntW(arg1, arg2, arg3, NULL);
 }
 
-void test__GetPrivateProfileIntA__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    GetPrivateProfileIntA(arg1, arg2, arg3, arg4);
+void test__GetPrivateProfileIntW__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntW(arg1, arg2, arg3, x);
 }
 
-void test__GetPrivateProfileIntA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = GetPrivateProfileIntA(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileSection__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetPrivateProfileSection(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileIntA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = GetPrivateProfileIntA(NULL, arg2, arg3, arg4);
+void test__GetPrivateProfileSection__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetPrivateProfileSection(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileIntA__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = GetPrivateProfileIntA(x, arg2, arg3, arg4);
+void test__GetPrivateProfileSection__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSection(NULL, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileIntA__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = GetPrivateProfileIntA(arg1, NULL, arg3, arg4);
+void test__GetPrivateProfileSection__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSection(x, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileIntA__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = GetPrivateProfileIntA(arg1, x, arg3, arg4);
+void test__GetPrivateProfileSection__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSection(arg1, NULL, arg3, arg4);
 }
 
-void test__GetPrivateProfileIntA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = GetPrivateProfileIntA(arg1, arg2, x, arg4);
+void test__GetPrivateProfileSection__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSection(arg1, arg2, x, arg4);
 }
 
-void test__GetPrivateProfileIntA__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = GetPrivateProfileIntA(arg1, arg2, arg3, NULL);
+void test__GetPrivateProfileSection__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSection(arg1, arg2, arg3, NULL);
 }
 
-void test__GetPrivateProfileIntA__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = GetPrivateProfileIntA(arg1, arg2, arg3, x);
+void test__GetPrivateProfileSection__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSection(arg1, arg2, arg3, x);
 }
 
-void test__GetPrivateProfileIntW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = GetPrivateProfileIntW(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileSectionA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetPrivateProfileSectionA(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileIntW__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    GetPrivateProfileIntW(arg1, arg2, arg3, arg4);
+void test__GetPrivateProfileSectionA__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetPrivateProfileSectionA(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileIntW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = GetPrivateProfileIntW(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileSectionA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionA(NULL, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileIntW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = GetPrivateProfileIntW(NULL, arg2, arg3, arg4);
+void test__GetPrivateProfileSectionA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionA(x, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileIntW__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = GetPrivateProfileIntW(x, arg2, arg3, arg4);
+void test__GetPrivateProfileSectionA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionA(arg1, NULL, arg3, arg4);
 }
 
-void test__GetPrivateProfileIntW__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = GetPrivateProfileIntW(arg1, NULL, arg3, arg4);
+void test__GetPrivateProfileSectionA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionA(arg1, arg2, x, arg4);
 }
 
-void test__GetPrivateProfileIntW__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = GetPrivateProfileIntW(arg1, x, arg3, arg4);
+void test__GetPrivateProfileSectionA__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionA(arg1, arg2, arg3, NULL);
 }
 
-void test__GetPrivateProfileIntW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = GetPrivateProfileIntW(arg1, arg2, x, arg4);
+void test__GetPrivateProfileSectionA__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionA(arg1, arg2, arg3, x);
 }
 
-void test__GetPrivateProfileIntW__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = GetPrivateProfileIntW(arg1, arg2, arg3, NULL);
+void test__GetPrivateProfileSectionW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetPrivateProfileSectionW(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileIntW__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = GetPrivateProfileIntW(arg1, arg2, arg3, x);
+void test__GetPrivateProfileSectionW__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetPrivateProfileSectionW(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileSection__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetPrivateProfileSection(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileSectionW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionW(NULL, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileSection__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetPrivateProfileSection(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileSectionW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionW(x, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileSection__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileSection(NULL, arg2, arg3, arg4);
+void test__GetPrivateProfileSectionW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionW(arg1, NULL, arg3, arg4);
 }
 
-void test__GetPrivateProfileSection__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileSection(x, arg2, arg3, arg4);
+void test__GetPrivateProfileSectionW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionW(arg1, arg2, x, arg4);
 }
 
-void test__GetPrivateProfileSection__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileSection(arg1, NULL, arg3, arg4);
+void test__GetPrivateProfileSectionW__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionW(arg1, arg2, arg3, NULL);
 }
 
-void test__GetPrivateProfileSection__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileSection(arg1, arg2, x, arg4);
+void test__GetPrivateProfileSectionW__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionW(arg1, arg2, arg3, x);
 }
 
-void test__GetPrivateProfileSection__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileSection(arg1, arg2, arg3, NULL);
+void test__GetPrivateProfileSectionNames__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetPrivateProfileSectionNames(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileSection__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileSection(arg1, arg2, arg3, x);
+void test__GetPrivateProfileSectionNames__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetPrivateProfileSectionNames(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileSectionA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetPrivateProfileSectionA(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileSectionNames__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionNames(NULL, arg2, arg3);
 }
 
-void test__GetPrivateProfileSectionA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetPrivateProfileSectionA(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileSectionNames__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionNames(arg1, x, arg3);
 }
 
-void test__GetPrivateProfileSectionA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileSectionA(NULL, arg2, arg3, arg4);
+void test__GetPrivateProfileSectionNames__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionNames(arg1, arg2, NULL);
 }
 
-void test__GetPrivateProfileSectionA__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileSectionA(x, arg2, arg3, arg4);
+void test__GetPrivateProfileSectionNames__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionNames(arg1, arg2, x);
 }
 
-void test__GetPrivateProfileSectionA__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileSectionA(arg1, NULL, arg3, arg4);
+void test__GetPrivateProfileSectionNamesA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetPrivateProfileSectionNamesA(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileSectionA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileSectionA(arg1, arg2, x, arg4);
+void test__GetPrivateProfileSectionNamesA__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetPrivateProfileSectionNamesA(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileSectionA__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileSectionA(arg1, arg2, arg3, NULL);
+void test__GetPrivateProfileSectionNamesA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionNamesA(NULL, arg2, arg3);
 }
 
-void test__GetPrivateProfileSectionA__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileSectionA(arg1, arg2, arg3, x);
+void test__GetPrivateProfileSectionNamesA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionNamesA(arg1, x, arg3);
 }
 
-void test__GetPrivateProfileSectionW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetPrivateProfileSectionW(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileSectionNamesA__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionNamesA(arg1, arg2, NULL);
 }
 
-void test__GetPrivateProfileSectionW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetPrivateProfileSectionW(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileSectionNamesA__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionNamesA(arg1, arg2, x);
 }
 
-void test__GetPrivateProfileSectionW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileSectionW(NULL, arg2, arg3, arg4);
+void test__GetPrivateProfileSectionNamesW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetPrivateProfileSectionNamesW(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileSectionW__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileSectionW(x, arg2, arg3, arg4);
+void test__GetPrivateProfileSectionNamesW__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetPrivateProfileSectionNamesW(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileSectionW__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileSectionW(arg1, NULL, arg3, arg4);
+void test__GetPrivateProfileSectionNamesW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionNamesW(NULL, arg2, arg3);
 }
 
-void test__GetPrivateProfileSectionW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileSectionW(arg1, arg2, x, arg4);
+void test__GetPrivateProfileSectionNamesW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionNamesW(arg1, x, arg3);
 }
 
-void test__GetPrivateProfileSectionW__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileSectionW(arg1, arg2, arg3, NULL);
+void test__GetPrivateProfileSectionNamesW__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionNamesW(arg1, arg2, NULL);
 }
 
-void test__GetPrivateProfileSectionW__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileSectionW(arg1, arg2, arg3, x);
+void test__GetPrivateProfileSectionNamesW__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionNamesW(arg1, arg2, x);
 }
 
-void test__GetPrivateProfileSectionNames__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetPrivateProfileSectionNames(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileString__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileSectionNames__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetPrivateProfileSectionNames(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileString__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetPrivateProfileString(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileSectionNames__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileSectionNames(NULL, arg2, arg3);
+void test__GetPrivateProfileString__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileString(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileSectionNames__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileSectionNames(arg1, x, arg3);
+void test__GetPrivateProfileString__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileString(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileSectionNames__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileSectionNames(arg1, arg2, NULL);
+void test__GetPrivateProfileString__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileString(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileSectionNames__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileSectionNames(arg1, arg2, x);
+void test__GetPrivateProfileString__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileString(arg1, arg2, arg3, NULL, arg5, arg6);
 }
 
-void test__GetPrivateProfileSectionNamesA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetPrivateProfileSectionNamesA(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileString__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileString(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__GetPrivateProfileSectionNamesA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetPrivateProfileSectionNamesA(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileString__arg6__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, NULL);
 }
 
-void test__GetPrivateProfileSectionNamesA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileSectionNamesA(NULL, arg2, arg3);
+void test__GetPrivateProfileString__arg6__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__GetPrivateProfileSectionNamesA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileSectionNamesA(arg1, x, arg3);
+void test__GetPrivateProfileStringA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileSectionNamesA__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileSectionNamesA(arg1, arg2, NULL);
+void test__GetPrivateProfileStringA__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetPrivateProfileStringA(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileSectionNamesA__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileSectionNamesA(arg1, arg2, x);
+void test__GetPrivateProfileStringA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringA(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileSectionNamesW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetPrivateProfileSectionNamesW(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileStringA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringA(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileSectionNamesW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetPrivateProfileSectionNamesW(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileStringA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringA(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileSectionNamesW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileSectionNamesW(NULL, arg2, arg3);
+void test__GetPrivateProfileStringA__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStringA(arg1, arg2, arg3, NULL, arg5, arg6);
 }
 
-void test__GetPrivateProfileSectionNamesW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileSectionNamesW(arg1, x, arg3);
+void test__GetPrivateProfileStringA__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringA(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__GetPrivateProfileSectionNamesW__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileSectionNamesW(arg1, arg2, NULL);
+void test__GetPrivateProfileStringA__arg6__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, NULL);
 }
 
-void test__GetPrivateProfileSectionNamesW__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileSectionNamesW(arg1, arg2, x);
+void test__GetPrivateProfileStringA__arg6__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__GetPrivateProfileString__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileStringW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetPrivateProfileStringW(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileString__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetPrivateProfileString(p, arg2, arg3, arg4, arg5, arg6);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileStringW__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetPrivateProfileStringW(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileString__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileString(x, arg2, arg3, arg4, arg5, arg6);
+void test__GetPrivateProfileStringW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringW(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileString__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileString(arg1, x, arg3, arg4, arg5, arg6);
+void test__GetPrivateProfileStringW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringW(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileString__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileString(arg1, arg2, x, arg4, arg5, arg6);
+void test__GetPrivateProfileStringW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringW(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileString__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileString(arg1, arg2, arg3, NULL, arg5, arg6);
+void test__GetPrivateProfileStringW__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStringW(arg1, arg2, arg3, NULL, arg5, arg6);
 }
 
-void test__GetPrivateProfileString__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileString(arg1, arg2, arg3, arg4, x, arg6);
+void test__GetPrivateProfileStringW__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringW(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__GetPrivateProfileString__arg6__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, NULL);
+void test__GetPrivateProfileStringW__arg6__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStringW(arg1, arg2, arg3, arg4, arg5, NULL);
 }
 
-void test__GetPrivateProfileString__arg6__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, x);
+void test__GetPrivateProfileStringW__arg6__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringW(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__GetPrivateProfileStringA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileStruct__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetPrivateProfileStruct(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileStringA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetPrivateProfileStringA(p, arg2, arg3, arg4, arg5, arg6);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileStruct__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetPrivateProfileStruct(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileStringA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStringA(x, arg2, arg3, arg4, arg5, arg6);
+void test__GetPrivateProfileStruct__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStruct(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test__GetPrivateProfileStringA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStringA(arg1, x, arg3, arg4, arg5, arg6);
+void test__GetPrivateProfileStruct__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStruct(x, arg2, arg3, arg4, arg5);
 }
 
-void test__GetPrivateProfileStringA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStringA(arg1, arg2, x, arg4, arg5, arg6);
+void test__GetPrivateProfileStruct__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStruct(arg1, NULL, arg3, arg4, arg5);
 }
 
-void test__GetPrivateProfileStringA__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStringA(arg1, arg2, arg3, NULL, arg5, arg6);
+void test__GetPrivateProfileStruct__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStruct(arg1, x, arg3, arg4, arg5);
 }
 
-void test__GetPrivateProfileStringA__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStringA(arg1, arg2, arg3, arg4, x, arg6);
+void test__GetPrivateProfileStruct__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStruct(arg1, arg2, NULL, arg4, arg5);
 }
 
-void test__GetPrivateProfileStringA__arg6__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, NULL);
+void test__GetPrivateProfileStruct__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStruct(arg1, arg2, arg3, x, arg5);
 }
 
-void test__GetPrivateProfileStringA__arg6__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, x);
+void test__GetPrivateProfileStruct__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStruct(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test__GetPrivateProfileStringW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetPrivateProfileStringW(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileStruct__arg5__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStruct(arg1, arg2, arg3, arg4, x);
 }
 
-void test__GetPrivateProfileStringW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetPrivateProfileStringW(p, arg2, arg3, arg4, arg5, arg6);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileStructA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetPrivateProfileStructA(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileStringW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStringW(x, arg2, arg3, arg4, arg5, arg6);
+void test__GetPrivateProfileStructA__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetPrivateProfileStructA(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileStringW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStringW(arg1, x, arg3, arg4, arg5, arg6);
+void test__GetPrivateProfileStructA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructA(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test__GetPrivateProfileStringW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStringW(arg1, arg2, x, arg4, arg5, arg6);
+void test__GetPrivateProfileStructA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructA(x, arg2, arg3, arg4, arg5);
 }
 
-void test__GetPrivateProfileStringW__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStringW(arg1, arg2, arg3, NULL, arg5, arg6);
+void test__GetPrivateProfileStructA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructA(arg1, NULL, arg3, arg4, arg5);
 }
 
-void test__GetPrivateProfileStringW__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStringW(arg1, arg2, arg3, arg4, x, arg6);
+void test__GetPrivateProfileStructA__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructA(arg1, x, arg3, arg4, arg5);
 }
 
-void test__GetPrivateProfileStringW__arg6__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStringW(arg1, arg2, arg3, arg4, arg5, NULL);
+void test__GetPrivateProfileStructA__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructA(arg1, arg2, NULL, arg4, arg5);
 }
 
-void test__GetPrivateProfileStringW__arg6__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStringW(arg1, arg2, arg3, arg4, arg5, x);
+void test__GetPrivateProfileStructA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructA(arg1, arg2, arg3, x, arg5);
 }
 
-void test__GetPrivateProfileStruct__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetPrivateProfileStruct(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileStructA__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructA(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test__GetPrivateProfileStruct__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetPrivateProfileStruct(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileStructA__arg5__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructA(arg1, arg2, arg3, arg4, x);
 }
 
-void test__GetPrivateProfileStruct__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStruct(NULL, arg2, arg3, arg4, arg5);
+void test__GetPrivateProfileStructW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetPrivateProfileStructW(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileStruct__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStruct(x, arg2, arg3, arg4, arg5);
+void test__GetPrivateProfileStructW__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetPrivateProfileStructW(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileStruct__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStruct(arg1, NULL, arg3, arg4, arg5);
+void test__GetPrivateProfileStructW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructW(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test__GetPrivateProfileStruct__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStruct(arg1, x, arg3, arg4, arg5);
+void test__GetPrivateProfileStructW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructW(x, arg2, arg3, arg4, arg5);
 }
 
-void test__GetPrivateProfileStruct__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStruct(arg1, arg2, NULL, arg4, arg5);
+void test__GetPrivateProfileStructW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructW(arg1, NULL, arg3, arg4, arg5);
 }
 
-void test__GetPrivateProfileStruct__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStruct(arg1, arg2, arg3, x, arg5);
+void test__GetPrivateProfileStructW__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructW(arg1, x, arg3, arg4, arg5);
 }
 
-void test__GetPrivateProfileStruct__arg5__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStruct(arg1, arg2, arg3, arg4, NULL);
+void test__GetPrivateProfileStructW__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructW(arg1, arg2, NULL, arg4, arg5);
 }
 
-void test__GetPrivateProfileStruct__arg5__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStruct(arg1, arg2, arg3, arg4, x);
+void test__GetPrivateProfileStructW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructW(arg1, arg2, arg3, x, arg5);
 }
 
-void test__GetPrivateProfileStructA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetPrivateProfileStructA(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetPrivateProfileStructW__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructW(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test__GetPrivateProfileStructA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetPrivateProfileStructA(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test__GetPrivateProfileStructW__arg5__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructW(arg1, arg2, arg3, arg4, x);
 }
 
-void test__GetPrivateProfileStructA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStructA(NULL, arg2, arg3, arg4, arg5);
+void test__BeginPaint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; BeginPaint(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileStructA__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStructA(x, arg2, arg3, arg4, arg5);
+void test__BeginPaint__leakignore() {
+  char *p = malloc(10); *p=0;
+  BeginPaint(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileStructA__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStructA(arg1, NULL, arg3, arg4, arg5);
+void test__BeginPaint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  BeginPaint(x, arg2);
 }
 
-void test__GetPrivateProfileStructA__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStructA(arg1, x, arg3, arg4, arg5);
+void test__BeginPaint__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  BeginPaint(arg1, NULL);
 }
 
-void test__GetPrivateProfileStructA__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStructA(arg1, arg2, NULL, arg4, arg5);
+void test__EndPaint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; EndPaint(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileStructA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStructA(arg1, arg2, arg3, x, arg5);
+void test__EndPaint__leakignore() {
+  char *p = malloc(10); *p=0;
+  EndPaint(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileStructA__arg5__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStructA(arg1, arg2, arg3, arg4, NULL);
+void test__EndPaint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  EndPaint(x, arg2);
 }
 
-void test__GetPrivateProfileStructA__arg5__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStructA(arg1, arg2, arg3, arg4, x);
+void test__EndPaint__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  EndPaint(arg1, NULL);
 }
 
-void test__GetPrivateProfileStructW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetPrivateProfileStructW(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetStockObject__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = GetStockObject(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileStructW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetPrivateProfileStructW(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test__GetStockObject__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetStockObject(arg1);
 }
 
-void test__GetPrivateProfileStructW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStructW(NULL, arg2, arg3, arg4, arg5);
+void test__GetStockObject__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((GetStockObject(arg1) > 10) || (GetStockObject(arg1) < 100)) {}
 }
 
-void test__GetPrivateProfileStructW__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStructW(x, arg2, arg3, arg4, arg5);
+void test__GetStockObject__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = GetStockObject(p);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileStructW__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStructW(arg1, NULL, arg3, arg4, arg5);
+void test__GetStockObject__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetStockObject(x);
 }
 
-void test__GetPrivateProfileStructW__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStructW(arg1, x, arg3, arg4, arg5);
+void test__LoadIcon__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = LoadIcon(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetPrivateProfileStructW__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStructW(arg1, arg2, NULL, arg4, arg5);
+void test__LoadIcon__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  LoadIcon(arg1, arg2);
 }
 
-void test__GetPrivateProfileStructW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStructW(arg1, arg2, arg3, x, arg5);
+void test__LoadIcon__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = LoadIcon(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileStructW__arg5__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetPrivateProfileStructW(arg1, arg2, arg3, arg4, NULL);
+void test__LoadIcon__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = LoadIcon(x, arg2);
 }
 
-void test__GetPrivateProfileStructW__arg5__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetPrivateProfileStructW(arg1, arg2, arg3, arg4, x);
+void test__LoadIcon__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = LoadIcon(arg1, NULL);
 }
 
-void test__BeginPaint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        BeginPaint(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__LoadIcon__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = LoadIcon(arg1, x);
 }
 
-void test__BeginPaint__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    BeginPaint(p, arg2);
-    // cppcheck-suppress memleak
+void test__LoadIconA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = LoadIconA(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__BeginPaint__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    BeginPaint(x, arg2);
+void test__LoadIconA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  LoadIconA(arg1, arg2);
 }
 
-void test__BeginPaint__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    BeginPaint(arg1, NULL);
+void test__LoadIconA__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = LoadIconA(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__EndPaint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        EndPaint(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__LoadIconA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = LoadIconA(x, arg2);
 }
 
-void test__EndPaint__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    EndPaint(p, arg2);
-    // cppcheck-suppress memleak
+void test__LoadIconA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = LoadIconA(arg1, NULL);
 }
 
-void test__EndPaint__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    EndPaint(x, arg2);
+void test__LoadIconA__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = LoadIconA(arg1, x);
 }
 
-void test__EndPaint__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    EndPaint(arg1, NULL);
+void test__LoadIconW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = LoadIconW(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetStockObject__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = GetStockObject(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__LoadIconW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  LoadIconW(arg1, arg2);
 }
 
-void test__GetStockObject__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    GetStockObject(arg1);
+void test__LoadIconW__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = LoadIconW(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__GetStockObject__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((GetStockObject(arg1) > 10) || (GetStockObject(arg1) < 100)) {}
+void test__LoadIconW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = LoadIconW(x, arg2);
 }
 
-void test__GetStockObject__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = GetStockObject(p);
-    // cppcheck-suppress memleak
+void test__LoadIconW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = LoadIconW(arg1, NULL);
 }
 
-void test__GetStockObject__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = GetStockObject(x);
+void test__LoadIconW__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = LoadIconW(arg1, x);
 }
 
-void test__LoadIcon__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = LoadIcon(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateSolidBrush__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = CreateSolidBrush(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__LoadIcon__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    LoadIcon(arg1, arg2);
+void test__CreateSolidBrush__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateSolidBrush(arg1);
 }
 
-void test__LoadIcon__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = LoadIcon(p, arg2);
-    // cppcheck-suppress memleak
+void test__CreateSolidBrush__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = CreateSolidBrush(p);
+  // cppcheck-suppress memleak
 }
 
-void test__LoadIcon__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = LoadIcon(x, arg2);
+void test__CreateSolidBrush__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateSolidBrush(x);
 }
 
-void test__LoadIcon__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = LoadIcon(arg1, NULL);
+void test__UpdateWindow__noreturn() {
+  int x = 1;
+  if (cond) { x=100; UpdateWindow(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__LoadIcon__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = LoadIcon(arg1, x);
+void test__UpdateWindow__leakignore() {
+  char *p = malloc(10); *p=0;
+  UpdateWindow(p);
+  // cppcheck-suppress memleak
 }
 
-void test__LoadIconA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = LoadIconA(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__UpdateWindow__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  UpdateWindow(NULL);
 }
 
-void test__LoadIconA__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    LoadIconA(arg1, arg2);
+void test__UpdateWindow__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  UpdateWindow(x);
 }
 
-void test__LoadIconA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = LoadIconA(p, arg2);
-    // cppcheck-suppress memleak
+void test__EnableWindow__noreturn() {
+  int x = 1;
+  if (cond) { x=100; EnableWindow(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__LoadIconA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = LoadIconA(x, arg2);
+void test__EnableWindow__leakignore() {
+  char *p = malloc(10); *p=0;
+  EnableWindow(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__LoadIconA__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = LoadIconA(arg1, NULL);
+void test__EnableWindow__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  EnableWindow(NULL, arg2);
 }
 
-void test__LoadIconA__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = LoadIconA(arg1, x);
+void test__EnableWindow__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  EnableWindow(x, arg2);
 }
 
-void test__LoadIconW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = LoadIconW(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__EnableWindow__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  EnableWindow(arg1, x);
 }
 
-void test__LoadIconW__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    LoadIconW(arg1, arg2);
+void test__CreateWindow__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__LoadIconW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = LoadIconW(p, arg2);
-    // cppcheck-suppress memleak
+void test__CreateWindow__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__LoadIconW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = LoadIconW(x, arg2);
+void test__CreateWindow__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = CreateWindow(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress memleak
 }
 
-void test__LoadIconW__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = LoadIconW(arg1, NULL);
+void test__CreateWindow__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__LoadIconW__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = LoadIconW(arg1, x);
+void test__CreateWindow__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateSolidBrush__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = CreateSolidBrush(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateWindow__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateSolidBrush__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    CreateSolidBrush(arg1);
+void test__CreateWindow__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateSolidBrush__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = CreateSolidBrush(p);
-    // cppcheck-suppress memleak
+void test__CreateWindow__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateSolidBrush__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateSolidBrush(x);
+void test__CreateWindow__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__UpdateWindow__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        UpdateWindow(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateWindow__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
 }
 
-void test__UpdateWindow__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    UpdateWindow(p);
-    // cppcheck-suppress memleak
+void test__CreateWindow__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
 }
 
-void test__UpdateWindow__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    UpdateWindow(NULL);
+void test__CreateWindow__arg7__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
 }
 
-void test__UpdateWindow__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    UpdateWindow(x);
+void test__CreateWindow__arg8__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
 }
 
-void test__EnableWindow__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        EnableWindow(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateWindow__arg9__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
 }
 
-void test__EnableWindow__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    EnableWindow(p, arg2);
-    // cppcheck-suppress memleak
+void test__CreateWindowA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__EnableWindow__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    EnableWindow(NULL, arg2);
+void test__CreateWindowA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__EnableWindow__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    EnableWindow(x, arg2);
+void test__CreateWindowA__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = CreateWindowA(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress memleak
 }
 
-void test__EnableWindow__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    EnableWindow(arg1, x);
+void test__CreateWindowA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindow__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateWindowA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindow__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindow__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = CreateWindow(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-    // cppcheck-suppress memleak
+void test__CreateWindowA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindow__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindow(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindow__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindow(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindow__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindow(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowA__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindow__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindow(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowA__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
 }
 
-void test__CreateWindow__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindow(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowA__arg7__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
 }
 
-void test__CreateWindow__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindow(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowA__arg8__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
 }
 
-void test__CreateWindow__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindow(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
+void test__CreateWindowA__arg9__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
 }
 
-void test__CreateWindow__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindow(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
+void test__CreateWindowW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateWindow__arg7__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
+void test__CreateWindowW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindow__arg8__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
+void test__CreateWindowW__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = CreateWindowW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateWindow__arg9__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
+void test__CreateWindowW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateWindowW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowA__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = CreateWindowA(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-    // cppcheck-suppress memleak
+void test__CreateWindowW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowW__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowA(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowW__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
 }
 
-void test__CreateWindowA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowA(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowW__arg7__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
 }
 
-void test__CreateWindowA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowA(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowW__arg8__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
 }
 
-void test__CreateWindowA__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowA(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
+void test__CreateWindowW__arg9__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
 }
 
-void test__CreateWindowA__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
+void test__CreateWindowEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateWindowA__arg7__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
+void test__CreateWindowEx__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowA__arg8__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
+void test__CreateWindowEx__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = CreateWindowEx(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateWindowA__arg9__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
+void test__CreateWindowEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateWindowEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowW__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = CreateWindowW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-    // cppcheck-suppress memleak
+void test__CreateWindowEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowEx__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowEx__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowW(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowEx__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowW(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowEx__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
 }
 
-void test__CreateWindowW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowW(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowEx__arg7__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
 }
 
-void test__CreateWindowW__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowW(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
+void test__CreateWindowEx__arg8__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
 }
 
-void test__CreateWindowW__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
+void test__CreateWindowEx__arg9__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
 }
 
-void test__CreateWindowW__arg7__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
+void test__CreateWindowExA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateWindowW__arg8__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
+void test__CreateWindowExA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowW__arg9__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
+void test__CreateWindowExA__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = CreateWindowExA(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateWindowEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateWindowExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowEx__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowEx__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = CreateWindowEx(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-    // cppcheck-suppress memleak
+void test__CreateWindowExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowEx__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowEx__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowEx__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowEx__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowEx__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowEx(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExA__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowEx__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowEx(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExA__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
 }
 
-void test__CreateWindowEx__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowEx(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExA__arg7__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
 }
 
-void test__CreateWindowEx__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowEx(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
+void test__CreateWindowExA__arg8__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
 }
 
-void test__CreateWindowEx__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
+void test__CreateWindowExA__arg9__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
 }
 
-void test__CreateWindowEx__arg7__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
+void test__CreateWindowExW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateWindowEx__arg8__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
+void test__CreateWindowExW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowEx__arg9__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
+void test__CreateWindowExW__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = CreateWindowExW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateWindowExA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateWindowExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowExA__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowExA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = CreateWindowExA(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-    // cppcheck-suppress memleak
+void test__CreateWindowExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowExA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowExA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowExA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowExA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowExA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExA(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExW__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
 }
 
-void test__CreateWindowExA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExA(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExW__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
 }
 
-void test__CreateWindowExA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExA(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindowExW__arg7__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
 }
 
-void test__CreateWindowExA__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExA(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
+void test__CreateWindowExW__arg8__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
 }
 
-void test__CreateWindowExA__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
+void test__CreateWindowExW__arg9__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
 }
 
-void test__CreateWindowExA__arg7__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
+void test__SetWindowText__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetWindowText(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateWindowExA__arg8__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
+void test__SetWindowText__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetWindowText(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateWindowExA__arg9__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
+void test__SetWindowText__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SetWindowText(NULL, arg2);
 }
 
-void test__CreateWindowExW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SetWindowText__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetWindowText(x, arg2);
 }
 
-void test__CreateWindowExW__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__SetWindowText__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  SetWindowText(arg1, NULL);
 }
 
-void test__CreateWindowExW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = CreateWindowExW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-    // cppcheck-suppress memleak
+void test__SetWindowText__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetWindowText(arg1, x);
 }
 
-void test__CreateWindowExW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__SetWindowTextA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetWindowTextA(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateWindowExW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__SetWindowTextA__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetWindowTextA(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateWindowExW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__SetWindowTextA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SetWindowTextA(NULL, arg2);
 }
 
-void test__CreateWindowExW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__SetWindowTextA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetWindowTextA(x, arg2);
 }
 
-void test__CreateWindowExW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExW(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__SetWindowTextA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  SetWindowTextA(arg1, NULL);
 }
 
-void test__CreateWindowExW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExW(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__SetWindowTextA__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetWindowTextA(arg1, x);
 }
 
-void test__CreateWindowExW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExW(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
+void test__SetWindowTextW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetWindowTextW(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateWindowExW__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExW(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
+void test__SetWindowTextW__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetWindowTextW(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateWindowExW__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
+void test__SetWindowTextW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SetWindowTextW(NULL, arg2);
 }
 
-void test__CreateWindowExW__arg7__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
+void test__SetWindowTextW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetWindowTextW(x, arg2);
 }
 
-void test__CreateWindowExW__arg8__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
+void test__SetWindowTextW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  SetWindowTextW(arg1, NULL);
 }
 
-void test__CreateWindowExW__arg9__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
+void test__SetWindowTextW__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetWindowTextW(arg1, x);
 }
 
-void test__SetWindowText__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetWindowText(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RegisterClass__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RegisterClass(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SetWindowText__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetWindowText(p, arg2);
-    // cppcheck-suppress memleak
+void test__RegisterClass__leakignore() {
+  char *p = malloc(10); *p=0;
+  RegisterClass(p);
+  // cppcheck-suppress memleak
 }
 
-void test__SetWindowText__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SetWindowText(NULL, arg2);
+void test__RegisterClass__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  RegisterClass(NULL);
 }
 
-void test__SetWindowText__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    SetWindowText(x, arg2);
+void test__RegisterClass__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  RegisterClass(x);
 }
 
-void test__SetWindowText__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SetWindowText(arg1, NULL);
+void test__RegisterClassEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RegisterClassEx(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SetWindowText__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    SetWindowText(arg1, x);
+void test__RegisterClassEx__leakignore() {
+  char *p = malloc(10); *p=0;
+  RegisterClassEx(p);
+  // cppcheck-suppress memleak
 }
 
-void test__SetWindowTextA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetWindowTextA(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RegisterClassEx__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  RegisterClassEx(NULL);
 }
 
-void test__SetWindowTextA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetWindowTextA(p, arg2);
-    // cppcheck-suppress memleak
+void test__RegisterClassEx__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  RegisterClassEx(x);
 }
 
-void test__SetWindowTextA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SetWindowTextA(NULL, arg2);
+void test__UnregisterClass__noreturn() {
+  int x = 1;
+  if (cond) { x=100; UnregisterClass(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SetWindowTextA__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    SetWindowTextA(x, arg2);
+void test__UnregisterClass__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  UnregisterClass(x, arg2);
 }
 
-void test__SetWindowTextA__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SetWindowTextA(arg1, NULL);
+void test__UnregisterClass__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  UnregisterClass(arg1, x);
 }
 
-void test__SetWindowTextA__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    SetWindowTextA(arg1, x);
+void test__UnregisterClassA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; UnregisterClassA(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SetWindowTextW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetWindowTextW(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__UnregisterClassA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  UnregisterClassA(x, arg2);
 }
 
-void test__SetWindowTextW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetWindowTextW(p, arg2);
-    // cppcheck-suppress memleak
+void test__UnregisterClassA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  UnregisterClassA(arg1, x);
 }
 
-void test__SetWindowTextW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SetWindowTextW(NULL, arg2);
+void test__UnregisterClassW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; UnregisterClassW(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SetWindowTextW__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    SetWindowTextW(x, arg2);
+void test__UnregisterClassW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  UnregisterClassW(x, arg2);
 }
 
-void test__SetWindowTextW__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SetWindowTextW(arg1, NULL);
+void test__UnregisterClassW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  UnregisterClassW(arg1, x);
 }
 
-void test__SetWindowTextW__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    SetWindowTextW(arg1, x);
+void test__MessageBox__noreturn() {
+  int x = 1;
+  if (cond) { x=100; MessageBox(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__RegisterClass__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RegisterClass(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__MessageBox__leakignore() {
+  char *p = malloc(10); *p=0;
+  MessageBox(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__RegisterClass__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RegisterClass(p);
-    // cppcheck-suppress memleak
+void test__MessageBox__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBox(x, arg2, arg3, arg4);
 }
 
-void test__RegisterClass__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    RegisterClass(NULL);
+void test__MessageBox__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBox(arg1, x, arg3, arg4);
 }
 
-void test__RegisterClass__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    RegisterClass(x);
+void test__MessageBox__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBox(arg1, arg2, x, arg4);
 }
 
-void test__RegisterClassEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RegisterClassEx(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__MessageBox__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBox(arg1, arg2, arg3, x);
 }
 
-void test__RegisterClassEx__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RegisterClassEx(p);
-    // cppcheck-suppress memleak
+void test__MessageBoxA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; MessageBoxA(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__RegisterClassEx__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    RegisterClassEx(NULL);
-}
-
-void test__RegisterClassEx__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    RegisterClassEx(x);
+void test__MessageBoxA__leakignore() {
+  char *p = malloc(10); *p=0;
+  MessageBoxA(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__UnregisterClass__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        UnregisterClass(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__MessageBoxA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxA(x, arg2, arg3, arg4);
 }
 
-void test__UnregisterClass__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    UnregisterClass(x, arg2);
+void test__MessageBoxA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxA(arg1, x, arg3, arg4);
 }
 
-void test__UnregisterClass__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    UnregisterClass(arg1, x);
+void test__MessageBoxA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxA(arg1, arg2, x, arg4);
 }
 
-void test__UnregisterClassA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        UnregisterClassA(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__MessageBoxA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxA(arg1, arg2, arg3, x);
 }
-
-void test__UnregisterClassA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    UnregisterClassA(x, arg2);
+
+void test__MessageBoxW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; MessageBoxW(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__UnregisterClassA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    UnregisterClassA(arg1, x);
+void test__MessageBoxW__leakignore() {
+  char *p = malloc(10); *p=0;
+  MessageBoxW(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__UnregisterClassW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        UnregisterClassW(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__MessageBoxW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxW(x, arg2, arg3, arg4);
 }
 
-void test__UnregisterClassW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    UnregisterClassW(x, arg2);
+void test__MessageBoxW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxW(arg1, x, arg3, arg4);
 }
 
-void test__UnregisterClassW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    UnregisterClassW(arg1, x);
+void test__MessageBoxW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxW(arg1, arg2, x, arg4);
 }
 
-void test__MessageBox__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        MessageBox(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__MessageBoxW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxW(arg1, arg2, arg3, x);
 }
 
-void test__MessageBox__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    MessageBox(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
-}
-
-void test__MessageBox__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    MessageBox(x, arg2, arg3, arg4);
-}
-
-void test__MessageBox__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    MessageBox(arg1, x, arg3, arg4);
+void test__GlobalLock__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GlobalLock(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__MessageBox__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    MessageBox(arg1, arg2, x, arg4);
+void test__GlobalLock__leakignore() {
+  char *p = malloc(10); *p=0;
+  GlobalLock(p);
+  // cppcheck-suppress memleak
 }
 
-void test__MessageBox__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    MessageBox(arg1, arg2, arg3, x);
+void test__GlobalLock__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GlobalLock(NULL);
 }
 
-void test__MessageBoxA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        MessageBoxA(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GlobalLock__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GlobalLock(x);
 }
 
-void test__MessageBoxA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    MessageBoxA(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__GlobalUnlock__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GlobalUnlock(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__MessageBoxA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    MessageBoxA(x, arg2, arg3, arg4);
+void test__GlobalUnlock__leakignore() {
+  char *p = malloc(10); *p=0;
+  GlobalUnlock(p);
+  // cppcheck-suppress memleak
 }
 
-void test__MessageBoxA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    MessageBoxA(arg1, x, arg3, arg4);
+void test__GlobalUnlock__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GlobalUnlock(NULL);
 }
 
-void test__MessageBoxA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    MessageBoxA(arg1, arg2, x, arg4);
+void test__GlobalUnlock__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GlobalUnlock(x);
 }
 
-void test__MessageBoxA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    MessageBoxA(arg1, arg2, arg3, x);
+void test__OpenClipboard__noreturn() {
+  int x = 1;
+  if (cond) { x=100; OpenClipboard(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__MessageBoxW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        MessageBoxW(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__OpenClipboard__leakignore() {
+  char *p = malloc(10); *p=0;
+  OpenClipboard(p);
+  // cppcheck-suppress memleak
 }
 
-void test__MessageBoxW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    MessageBoxW(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__OpenClipboard__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenClipboard(x);
 }
 
-void test__MessageBoxW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    MessageBoxW(x, arg2, arg3, arg4);
+void test__EmptyClipboard__noreturn() {
+  int x = 1;
+  if (cond) { x=100; EmptyClipboard(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__MessageBoxW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    MessageBoxW(arg1, x, arg3, arg4);
+void test__EmptyClipboard__leakignore() {
+  char *p = malloc(10); *p=0;
+  EmptyClipboard();
+  // cppcheck-suppress memleak
 }
 
-void test__MessageBoxW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    MessageBoxW(arg1, arg2, x, arg4);
+void test__CloseClipboard__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CloseClipboard(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__MessageBoxW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    MessageBoxW(arg1, arg2, arg3, x);
-}
-
-void test__GlobalLock__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GlobalLock(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CloseClipboard__leakignore() {
+  char *p = malloc(10); *p=0;
+  CloseClipboard();
+  // cppcheck-suppress memleak
 }
 
-void test__GlobalLock__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GlobalLock(p);
-    // cppcheck-suppress memleak
-}
-
-void test__GlobalLock__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GlobalLock(NULL);
+void test__SetClipboardData__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetClipboardData(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__GlobalLock__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GlobalLock(x);
+
+void test__SetClipboardData__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetClipboardData(p, arg2);
+  // cppcheck-suppress memleak
 }
-
-void test__GlobalUnlock__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GlobalUnlock(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__GlobalUnlock__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GlobalUnlock(p);
-    // cppcheck-suppress memleak
-}
-
-void test__GlobalUnlock__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GlobalUnlock(NULL);
-}
-
-void test__GlobalUnlock__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GlobalUnlock(x);
-}
-
-void test__OpenClipboard__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        OpenClipboard(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__OpenClipboard__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    OpenClipboard(p);
-    // cppcheck-suppress memleak
-}
-
-void test__OpenClipboard__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenClipboard(x);
-}
-
-void test__EmptyClipboard__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        EmptyClipboard();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__EmptyClipboard__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    EmptyClipboard();
-    // cppcheck-suppress memleak
-}
-
-void test__CloseClipboard__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CloseClipboard();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__CloseClipboard__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    CloseClipboard();
-    // cppcheck-suppress memleak
-}
-
-void test__SetClipboardData__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetClipboardData(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__SetClipboardData__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetClipboardData(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__SetClipboardData__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetClipboardData(x, arg2);
-}
-
-void test__SetClipboardData__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetClipboardData(arg1, x);
-}
-
-void test___rmdir__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _rmdir(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test___rmdir__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _rmdir(p);
-    // cppcheck-suppress memleak
-}
-
-void test___rmdir__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _rmdir(NULL);
-}
-
-void test___rmdir__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _rmdir(x);
-}
-
-void test___wrmdir__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wrmdir(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test___wrmdir__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _wrmdir(p);
-    // cppcheck-suppress memleak
+
+void test__SetClipboardData__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetClipboardData(x, arg2);
 }
 
-void test___wrmdir__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wrmdir(NULL);
+void test__SetClipboardData__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetClipboardData(arg1, x);
 }
 
-void test___wrmdir__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wrmdir(x);
+void test___rmdir__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _rmdir(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mkdir__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _mkdir(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___rmdir__leakignore() {
+  char *p = malloc(10); *p=0;
+  _rmdir(p);
+  // cppcheck-suppress memleak
 }
 
-void test___mkdir__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _mkdir(p);
-    // cppcheck-suppress memleak
+void test___rmdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _rmdir(NULL);
 }
 
-void test___mkdir__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mkdir(NULL);
+void test___rmdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _rmdir(x);
 }
 
-void test___mkdir__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _mkdir(x);
+void test___wrmdir__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wrmdir(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wmkdir__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wmkdir(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wrmdir__leakignore() {
+  char *p = malloc(10); *p=0;
+  _wrmdir(p);
+  // cppcheck-suppress memleak
 }
 
-void test___wmkdir__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _wmkdir(p);
-    // cppcheck-suppress memleak
+void test___wrmdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wrmdir(NULL);
 }
 
-void test___wmkdir__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wmkdir(NULL);
+void test___wrmdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wrmdir(x);
 }
 
-void test___wmkdir__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wmkdir(x);
+void test___mkdir__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _mkdir(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___abs64__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _abs64(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mkdir__leakignore() {
+  char *p = malloc(10); *p=0;
+  _mkdir(p);
+  // cppcheck-suppress memleak
 }
 
-void test___abs64__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _abs64(arg1);
+void test___mkdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mkdir(NULL);
 }
 
-void test___abs64__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_abs64(arg1) > 10) || (_abs64(arg1) < 100)) {}
+void test___mkdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mkdir(x);
 }
 
-void test___abs64__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _abs64(p);
-    // cppcheck-suppress memleak
+void test___wmkdir__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wmkdir(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___abs64__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = _abs64(!x);
+void test___wmkdir__leakignore() {
+  char *p = malloc(10); *p=0;
+  _wmkdir(p);
+  // cppcheck-suppress memleak
 }
 
-void test___abs64__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _abs64(x);
+void test___wmkdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wmkdir(NULL);
 }
 
-void test__CreateWaitableTimer__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = CreateWaitableTimer(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wmkdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wmkdir(x);
 }
 
-void test__CreateWaitableTimer__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    CreateWaitableTimer(arg1, arg2, arg3);
+void test___abs64__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _abs64(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateWaitableTimer__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWaitableTimer(x, arg2, arg3);
+void test___abs64__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _abs64(arg1);
 }
 
-void test__CreateWaitableTimer__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWaitableTimer(arg1, x, arg3);
+void test___abs64__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_abs64(arg1) > 10) || (_abs64(arg1) < 100)) {}
 }
 
-void test__CreateWaitableTimer__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateWaitableTimer(arg1, arg2, x);
+void test___abs64__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _abs64(p);
+  // cppcheck-suppress memleak
 }
 
-void test__SetWaitableTimer__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetWaitableTimer(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___abs64__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _abs64(!x);
 }
 
-void test__SetWaitableTimer__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetWaitableTimer(p, arg2, arg3, arg4, arg5, arg6);
-    // cppcheck-suppress memleak
+void test___abs64__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _abs64(x);
 }
 
-void test__SetWaitableTimer__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetWaitableTimer(x, arg2, arg3, arg4, arg5, arg6);
+void test__CreateWaitableTimer__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = CreateWaitableTimer(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SetWaitableTimer__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SetWaitableTimer(arg1, NULL, arg3, arg4, arg5, arg6);
+void test__CreateWaitableTimer__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateWaitableTimer(arg1, arg2, arg3);
 }
 
-void test__SetWaitableTimer__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    SetWaitableTimer(arg1, x, arg3, arg4, arg5, arg6);
+void test__CreateWaitableTimer__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWaitableTimer(x, arg2, arg3);
 }
 
-void test__SetWaitableTimer__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetWaitableTimer(arg1, arg2, x, arg4, arg5, arg6);
+void test__CreateWaitableTimer__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWaitableTimer(arg1, x, arg3);
 }
 
-void test__SetWaitableTimer__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetWaitableTimer(arg1, arg2, arg3, x, arg5, arg6);
+void test__CreateWaitableTimer__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWaitableTimer(arg1, arg2, x);
 }
 
-void test__SetWaitableTimer__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetWaitableTimer(arg1, arg2, arg3, arg4, x, arg6);
+void test__SetWaitableTimer__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetWaitableTimer(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SetWaitableTimer__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetWaitableTimer(arg1, arg2, arg3, arg4, arg5, x);
+void test__SetWaitableTimer__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetWaitableTimer(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
 }
 
-void test__WaitForSingleObject__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        WaitForSingleObject(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SetWaitableTimer__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetWaitableTimer(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__WaitForSingleObject__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    WaitForSingleObject(p, arg2);
-    // cppcheck-suppress memleak
+void test__SetWaitableTimer__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  SetWaitableTimer(arg1, NULL, arg3, arg4, arg5, arg6);
 }
 
-void test__WaitForSingleObject__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    WaitForSingleObject(x, arg2);
+void test__SetWaitableTimer__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetWaitableTimer(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__WaitForSingleObject__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    WaitForSingleObject(arg1, x);
+void test__SetWaitableTimer__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetWaitableTimer(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test___pclose__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _pclose(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SetWaitableTimer__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetWaitableTimer(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test___pclose__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _pclose(NULL);
+void test__SetWaitableTimer__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetWaitableTimer(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test___pclose__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _pclose(x);
+void test__SetWaitableTimer__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetWaitableTimer(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test___popen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _popen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__WaitForSingleObject__noreturn() {
+  int x = 1;
+  if (cond) { x=100; WaitForSingleObject(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___popen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _popen(arg1, arg2);
+void test__WaitForSingleObject__leakignore() {
+  char *p = malloc(10); *p=0;
+  WaitForSingleObject(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___popen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _popen(NULL, arg2);
+void test__WaitForSingleObject__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WaitForSingleObject(x, arg2);
 }
 
-void test___popen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _popen(x, arg2);
+void test__WaitForSingleObject__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WaitForSingleObject(arg1, x);
 }
 
-void test___popen__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _popen(arg1, NULL);
+void test___pclose__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _pclose(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___popen__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _popen(arg1, x);
+void test___pclose__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _pclose(NULL);
 }
 
-void test___wpopen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _wpopen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___pclose__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _pclose(x);
 }
 
-void test___wpopen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _wpopen(arg1, arg2);
+void test___popen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _popen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wpopen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _wpopen(NULL, arg2);
+void test___popen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _popen(arg1, arg2);
 }
 
-void test___wpopen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _wpopen(x, arg2);
+void test___popen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _popen(NULL, arg2);
 }
 
-void test___wpopen__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _wpopen(arg1, NULL);
+void test___popen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _popen(x, arg2);
 }
 
-void test___wpopen__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _wpopen(arg1, x);
+void test___popen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _popen(arg1, NULL);
 }
 
-void test___tpopen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _tpopen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___popen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _popen(arg1, x);
 }
 
-void test___tpopen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _tpopen(arg1, arg2);
+void test___wpopen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _wpopen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tpopen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tpopen(NULL, arg2);
+void test___wpopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _wpopen(arg1, arg2);
 }
 
-void test___tpopen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tpopen(x, arg2);
+void test___wpopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wpopen(NULL, arg2);
 }
 
-void test___tpopen__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tpopen(arg1, NULL);
+void test___wpopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wpopen(x, arg2);
 }
 
-void test___tpopen__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tpopen(arg1, x);
+void test___wpopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wpopen(arg1, NULL);
 }
 
-void test___mktemp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mktemp(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wpopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wpopen(arg1, x);
 }
 
-void test___mktemp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mktemp(arg1);
+void test___tpopen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _tpopen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mktemp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mktemp(p);
-    // cppcheck-suppress memleak
+void test___tpopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tpopen(arg1, arg2);
 }
 
-void test___mktemp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mktemp(NULL);
+void test___tpopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tpopen(NULL, arg2);
 }
 
-void test___mktemp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mktemp(x);
+void test___tpopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tpopen(x, arg2);
 }
 
-void test___wmktemp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _wmktemp(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tpopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tpopen(arg1, NULL);
 }
 
-void test___wmktemp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _wmktemp(arg1);
+void test___tpopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tpopen(arg1, x);
 }
 
-void test___wmktemp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _wmktemp(p);
-    // cppcheck-suppress memleak
+void test___mktemp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mktemp(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wmktemp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _wmktemp(NULL);
+void test___mktemp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mktemp(arg1);
 }
 
-void test___wmktemp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _wmktemp(x);
+void test___mktemp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mktemp(p);
+  // cppcheck-suppress memleak
 }
 
-void test__FindFirstFileEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = FindFirstFileEx(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mktemp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mktemp(NULL);
 }
 
-void test__FindFirstFileEx__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    FindFirstFileEx(arg1, arg2, arg3, arg4, arg5, arg6);
+void test___mktemp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mktemp(x);
 }
 
-void test__FindFirstFileEx__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindFirstFileEx(NULL, arg2, arg3, arg4, arg5, arg6);
+void test___wmktemp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _wmktemp(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__FindFirstFileEx__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = FindFirstFileEx(x, arg2, arg3, arg4, arg5, arg6);
+void test___wmktemp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _wmktemp(arg1);
 }
 
-void test__FindFirstFileEx__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = FindFirstFileEx(arg1, x, arg3, arg4, arg5, arg6);
+void test___wmktemp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _wmktemp(p);
+  // cppcheck-suppress memleak
 }
 
-void test__FindFirstFileEx__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindFirstFileEx(arg1, arg2, NULL, arg4, arg5, arg6);
+void test___wmktemp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wmktemp(NULL);
 }
 
-void test__FindFirstFileEx__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = FindFirstFileEx(arg1, arg2, arg3, x, arg5, arg6);
+void test___wmktemp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wmktemp(x);
 }
 
-void test__FindFirstFileEx__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = FindFirstFileEx(arg1, arg2, arg3, arg4, arg5, x);
+void test__FindFirstFileEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = FindFirstFileEx(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__FindFirstFileExA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = FindFirstFileExA(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__FindFirstFileEx__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindFirstFileEx(arg1, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileExA__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    FindFirstFileExA(arg1, arg2, arg3, arg4, arg5, arg6);
+void test__FindFirstFileEx__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileEx(NULL, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileExA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindFirstFileExA(NULL, arg2, arg3, arg4, arg5, arg6);
+void test__FindFirstFileEx__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileEx(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileExA__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = FindFirstFileExA(x, arg2, arg3, arg4, arg5, arg6);
+void test__FindFirstFileEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileEx(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileExA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = FindFirstFileExA(arg1, x, arg3, arg4, arg5, arg6);
+void test__FindFirstFileEx__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileEx(arg1, arg2, NULL, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileExA__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindFirstFileExA(arg1, arg2, NULL, arg4, arg5, arg6);
+void test__FindFirstFileEx__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileEx(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__FindFirstFileExA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = FindFirstFileExA(arg1, arg2, arg3, x, arg5, arg6);
+void test__FindFirstFileEx__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileEx(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__FindFirstFileExA__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = FindFirstFileExA(arg1, arg2, arg3, arg4, arg5, x);
+void test__FindFirstFileExA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = FindFirstFileExA(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__FindFirstFileExW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = FindFirstFileExW(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__FindFirstFileExA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindFirstFileExA(arg1, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileExW__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    FindFirstFileExW(arg1, arg2, arg3, arg4, arg5, arg6);
+void test__FindFirstFileExA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileExA(NULL, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileExW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindFirstFileExW(NULL, arg2, arg3, arg4, arg5, arg6);
+void test__FindFirstFileExA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExA(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileExW__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = FindFirstFileExW(x, arg2, arg3, arg4, arg5, arg6);
+void test__FindFirstFileExA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExA(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileExW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = FindFirstFileExW(arg1, x, arg3, arg4, arg5, arg6);
+void test__FindFirstFileExA__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileExA(arg1, arg2, NULL, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileExW__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindFirstFileExW(arg1, arg2, NULL, arg4, arg5, arg6);
+void test__FindFirstFileExA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExA(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__FindFirstFileExW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = FindFirstFileExW(arg1, arg2, arg3, x, arg5, arg6);
+void test__FindFirstFileExA__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExA(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__FindFirstFileExW__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = FindFirstFileExW(arg1, arg2, arg3, arg4, arg5, x);
+void test__FindFirstFileExW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = FindFirstFileExW(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__FindFirstFile__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = FindFirstFile(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__FindFirstFileExW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindFirstFileExW(arg1, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFile__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    FindFirstFile(arg1, arg2);
+void test__FindFirstFileExW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileExW(NULL, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFile__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindFirstFile(NULL, arg2);
+void test__FindFirstFileExW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExW(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFile__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = FindFirstFile(x, arg2);
+void test__FindFirstFileExW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExW(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFile__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindFirstFile(arg1, NULL);
+void test__FindFirstFileExW__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileExW(arg1, arg2, NULL, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = FindFirstFileW(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__FindFirstFileExW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExW(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__FindFirstFileW__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    FindFirstFileW(arg1, arg2);
+void test__FindFirstFileExW__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExW(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__FindFirstFileW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindFirstFileW(NULL, arg2);
+void test__FindFirstFile__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = FindFirstFile(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__FindFirstFileW__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = FindFirstFileW(x, arg2);
+void test__FindFirstFile__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindFirstFile(arg1, arg2);
 }
 
-void test__FindFirstFileW__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindFirstFileW(arg1, NULL);
+void test__FindFirstFile__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFile(NULL, arg2);
 }
 
-void test__FindFirstFileA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = FindFirstFileA(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__FindFirstFile__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindFirstFile(x, arg2);
 }
 
-void test__FindFirstFileA__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    FindFirstFileA(arg1, arg2);
+void test__FindFirstFile__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFile(arg1, NULL);
 }
 
-void test__FindFirstFileA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindFirstFileA(NULL, arg2);
+void test__FindFirstFileW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = FindFirstFileW(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__FindFirstFileA__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = FindFirstFileA(x, arg2);
+void test__FindFirstFileW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindFirstFileW(arg1, arg2);
 }
 
-void test__FindFirstFileA__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindFirstFileA(arg1, NULL);
+void test__FindFirstFileW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileW(NULL, arg2);
 }
 
-void test__FindClose__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        FindClose(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__FindFirstFileW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileW(x, arg2);
 }
 
-void test__FindClose__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    FindClose(NULL);
+void test__FindFirstFileW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileW(arg1, NULL);
 }
 
-void test__FindClose__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    FindClose(x);
+void test__FindFirstFileA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = FindFirstFileA(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateThread__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = CreateThread(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__FindFirstFileA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindFirstFileA(arg1, arg2);
 }
 
-void test__CreateThread__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    CreateThread(arg1, arg2, arg3, arg4, arg5, arg6);
+void test__FindFirstFileA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileA(NULL, arg2);
 }
 
-void test__CreateThread__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateThread(x, arg2, arg3, arg4, arg5, arg6);
+void test__FindFirstFileA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileA(x, arg2);
 }
 
-void test__CreateThread__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateThread(arg1, x, arg3, arg4, arg5, arg6);
+void test__FindFirstFileA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileA(arg1, NULL);
 }
 
-void test__CreateThread__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateThread(arg1, arg2, x, arg4, arg5, arg6);
+void test__FindClose__noreturn() {
+  int x = 1;
+  if (cond) { x=100; FindClose(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateThread__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateThread(arg1, arg2, arg3, x, arg5, arg6);
+void test__FindClose__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  FindClose(NULL);
 }
 
-void test__CreateThread__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = CreateThread(arg1, arg2, arg3, arg4, x, arg6);
+void test__FindClose__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  FindClose(x);
 }
 
-void test__FindNextFile__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = FindNextFile(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateThread__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = CreateThread(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__FindNextFile__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    FindNextFile(arg1, arg2);
+void test__CreateThread__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateThread(arg1, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__FindNextFile__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = FindNextFile(p, arg2);
-    // cppcheck-suppress memleak
+void test__CreateThread__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateThread(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__FindNextFile__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindNextFile(NULL, arg2);
+void test__CreateThread__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateThread(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__FindNextFile__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = FindNextFile(x, arg2);
+void test__CreateThread__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateThread(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__FindNextFile__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindNextFile(arg1, NULL);
+void test__CreateThread__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateThread(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__FindNextFileW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = FindNextFileW(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateThread__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateThread(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__FindNextFileW__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    FindNextFileW(arg1, arg2);
+void test__FindNextFile__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = FindNextFile(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__FindNextFileW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = FindNextFileW(p, arg2);
-    // cppcheck-suppress memleak
+void test__FindNextFile__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindNextFile(arg1, arg2);
 }
 
-void test__FindNextFileW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindNextFileW(NULL, arg2);
+void test__FindNextFile__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = FindNextFile(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__FindNextFileW__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = FindNextFileW(x, arg2);
+void test__FindNextFile__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindNextFile(NULL, arg2);
 }
 
-void test__FindNextFileW__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindNextFileW(arg1, NULL);
+void test__FindNextFile__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindNextFile(x, arg2);
 }
 
-void test__FindNextFileA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = FindNextFileA(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__FindNextFile__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindNextFile(arg1, NULL);
 }
 
-void test__FindNextFileA__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    FindNextFileA(arg1, arg2);
+void test__FindNextFileW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = FindNextFileW(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__FindNextFileA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = FindNextFileA(p, arg2);
-    // cppcheck-suppress memleak
+void test__FindNextFileW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindNextFileW(arg1, arg2);
 }
 
-void test__FindNextFileA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindNextFileA(NULL, arg2);
+void test__FindNextFileW__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = FindNextFileW(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__FindNextFileA__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = FindNextFileA(x, arg2);
+void test__FindNextFileW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindNextFileW(NULL, arg2);
 }
 
-void test__FindNextFileA__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = FindNextFileA(arg1, NULL);
+void test__FindNextFileW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindNextFileW(x, arg2);
 }
 
-void test__SetEnvironmentVariable__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetEnvironmentVariable(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__FindNextFileW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindNextFileW(arg1, NULL);
 }
 
-void test__SetEnvironmentVariable__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetEnvironmentVariable(p, arg2);
-    // cppcheck-suppress memleak
+void test__FindNextFileA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = FindNextFileA(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SetEnvironmentVariable__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetEnvironmentVariable(x, arg2);
+void test__FindNextFileA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindNextFileA(arg1, arg2);
 }
 
-void test__SetEnvironmentVariableW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetEnvironmentVariableW(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__FindNextFileA__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = FindNextFileA(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__SetEnvironmentVariableW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetEnvironmentVariableW(p, arg2);
-    // cppcheck-suppress memleak
+void test__FindNextFileA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindNextFileA(NULL, arg2);
 }
 
-void test__SetEnvironmentVariableW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetEnvironmentVariableW(x, arg2);
+void test__FindNextFileA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindNextFileA(x, arg2);
 }
 
-void test__SetEnvironmentVariableA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetEnvironmentVariableA(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__FindNextFileA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindNextFileA(arg1, NULL);
 }
 
-void test__SetEnvironmentVariableA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetEnvironmentVariableA(p, arg2);
-    // cppcheck-suppress memleak
+void test__SetEnvironmentVariable__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetEnvironmentVariable(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SetEnvironmentVariableA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetEnvironmentVariableA(x, arg2);
+void test__SetEnvironmentVariable__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetEnvironmentVariable(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__QueryDosDevice__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QueryDosDevice(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SetEnvironmentVariable__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetEnvironmentVariable(x, arg2);
 }
 
-void test__QueryDosDevice__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QueryDosDevice(arg1, arg2, arg3);
+void test__SetEnvironmentVariableW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetEnvironmentVariableW(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QueryDosDevice__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = QueryDosDevice(p, arg2, arg3);
-    // cppcheck-suppress memleak
-}
-
-void test__QueryDosDevice__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QueryDosDevice(x, arg2, arg3);
+void test__SetEnvironmentVariableW__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetEnvironmentVariableW(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__QueryDosDevice__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QueryDosDevice(arg1, arg2, x);
+void test__SetEnvironmentVariableW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetEnvironmentVariableW(x, arg2);
 }
 
-void test__QueryDosDeviceW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QueryDosDeviceW(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SetEnvironmentVariableA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetEnvironmentVariableA(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QueryDosDeviceW__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QueryDosDeviceW(arg1, arg2, arg3);
+void test__SetEnvironmentVariableA__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetEnvironmentVariableA(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__QueryDosDeviceW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = QueryDosDeviceW(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__SetEnvironmentVariableA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetEnvironmentVariableA(x, arg2);
 }
 
-void test__QueryDosDeviceW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QueryDosDeviceW(x, arg2, arg3);
+void test__QueryDosDevice__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QueryDosDevice(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QueryDosDeviceW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QueryDosDeviceW(arg1, arg2, x);
+void test__QueryDosDevice__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QueryDosDevice(arg1, arg2, arg3);
 }
 
-void test__QueryDosDeviceA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = QueryDosDeviceA(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QueryDosDevice__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = QueryDosDevice(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__QueryDosDeviceA__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    QueryDosDeviceA(arg1, arg2, arg3);
+void test__QueryDosDevice__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QueryDosDevice(x, arg2, arg3);
 }
 
-void test__QueryDosDeviceA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = QueryDosDeviceA(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__QueryDosDevice__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QueryDosDevice(arg1, arg2, x);
 }
 
-void test__QueryDosDeviceA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QueryDosDeviceA(x, arg2, arg3);
+void test__QueryDosDeviceW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QueryDosDeviceW(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__QueryDosDeviceA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = QueryDosDeviceA(arg1, arg2, x);
+void test__QueryDosDeviceW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QueryDosDeviceW(arg1, arg2, arg3);
 }
 
-void test__GetDefaultCommConfig__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = GetDefaultCommConfig(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QueryDosDeviceW__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = QueryDosDeviceW(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__GetDefaultCommConfig__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    GetDefaultCommConfig(arg1, arg2, arg3);
+void test__QueryDosDeviceW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QueryDosDeviceW(x, arg2, arg3);
 }
 
-void test__GetDefaultCommConfig__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = GetDefaultCommConfig(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__QueryDosDeviceW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QueryDosDeviceW(arg1, arg2, x);
 }
 
-void test__GetDefaultCommConfig__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = GetDefaultCommConfig(x, arg2, arg3);
+void test__QueryDosDeviceA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = QueryDosDeviceA(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetDefaultCommConfig__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = GetDefaultCommConfig(arg1, NULL, arg3);
+void test__QueryDosDeviceA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QueryDosDeviceA(arg1, arg2, arg3);
 }
 
-void test__GetDefaultCommConfigW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = GetDefaultCommConfigW(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__QueryDosDeviceA__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = QueryDosDeviceA(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__GetDefaultCommConfigW__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    GetDefaultCommConfigW(arg1, arg2, arg3);
+void test__QueryDosDeviceA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QueryDosDeviceA(x, arg2, arg3);
 }
 
-void test__GetDefaultCommConfigW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = GetDefaultCommConfigW(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__QueryDosDeviceA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QueryDosDeviceA(arg1, arg2, x);
 }
 
-void test__GetDefaultCommConfigW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = GetDefaultCommConfigW(x, arg2, arg3);
+void test__GetDefaultCommConfig__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = GetDefaultCommConfig(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetDefaultCommConfigW__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = GetDefaultCommConfigW(arg1, NULL, arg3);
+void test__GetDefaultCommConfig__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetDefaultCommConfig(arg1, arg2, arg3);
 }
 
-void test__GetDefaultCommConfigA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = GetDefaultCommConfigA(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetDefaultCommConfig__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = GetDefaultCommConfig(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__GetDefaultCommConfigA__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    GetDefaultCommConfigA(arg1, arg2, arg3);
+void test__GetDefaultCommConfig__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetDefaultCommConfig(x, arg2, arg3);
 }
 
-void test__GetDefaultCommConfigA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = GetDefaultCommConfigA(p, arg2, arg3);
-    // cppcheck-suppress memleak
-}
-
-void test__GetDefaultCommConfigA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = GetDefaultCommConfigA(x, arg2, arg3);
+void test__GetDefaultCommConfig__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetDefaultCommConfig(arg1, NULL, arg3);
 }
 
-void test__GetDefaultCommConfigA__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = GetDefaultCommConfigA(arg1, NULL, arg3);
+void test__GetDefaultCommConfigW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = GetDefaultCommConfigW(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetTempPath__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetTempPath(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__GetTempPath__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetTempPath(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__GetTempPath__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetTempPath(x, arg2);
-}
-
-void test__GetTempPathW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetTempPathW(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetDefaultCommConfigW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetDefaultCommConfigW(arg1, arg2, arg3);
 }
 
-void test__GetTempPathW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetTempPathW(p, arg2);
-    // cppcheck-suppress memleak
+void test__GetDefaultCommConfigW__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = GetDefaultCommConfigW(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__GetTempPathW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetTempPathW(x, arg2);
-}
-
-void test__GetTempPathA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetTempPathA(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__GetTempPathA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetTempPathA(p, arg2);
-    // cppcheck-suppress memleak
+void test__GetDefaultCommConfigW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetDefaultCommConfigW(x, arg2, arg3);
 }
 
-void test__GetTempPathA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetTempPathA(x, arg2);
+void test__GetDefaultCommConfigW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetDefaultCommConfigW(arg1, NULL, arg3);
 }
 
-void test__SetupDiDestroyDeviceInfoList__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetupDiDestroyDeviceInfoList(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__SetupDiDestroyDeviceInfoList__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetupDiDestroyDeviceInfoList(p);
-    // cppcheck-suppress memleak
-}
-
-void test__SetupDiDestroyDeviceInfoList__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetupDiDestroyDeviceInfoList(x);
-}
-
-void test__SetupDiGetDeviceInstanceId__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetupDiGetDeviceInstanceId(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__SetupDiGetDeviceInstanceId__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetupDiGetDeviceInstanceId(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
-}
-
-void test__SetupDiGetDeviceInstanceId__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetupDiGetDeviceInstanceId(x, arg2, arg3, arg4, arg5);
-}
-
-void test__SetupDiGetDeviceInstanceId__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetupDiGetDeviceInstanceId(arg1, x, arg3, arg4, arg5);
+void test__GetDefaultCommConfigA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = GetDefaultCommConfigA(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__SetupDiGetDeviceInstanceId__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetupDiGetDeviceInstanceId(arg1, arg2, arg3, x, arg5);
+
+void test__GetDefaultCommConfigA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetDefaultCommConfigA(arg1, arg2, arg3);
 }
 
-void test__SetupDiEnumDeviceInfo__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetupDiEnumDeviceInfo(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test__GetDefaultCommConfigA__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = GetDefaultCommConfigA(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
 
-void test__SetupDiEnumDeviceInfo__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetupDiEnumDeviceInfo(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__GetDefaultCommConfigA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetDefaultCommConfigA(x, arg2, arg3);
 }
 
-void test__SetupDiEnumDeviceInfo__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetupDiEnumDeviceInfo(x, arg2, arg3);
+void test__GetDefaultCommConfigA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetDefaultCommConfigA(arg1, NULL, arg3);
 }
 
-void test__SetupDiEnumDeviceInfo__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetupDiEnumDeviceInfo(arg1, x, arg3);
+void test__GetTempPath__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetTempPath(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SetupDiGetClassDevs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetupDiGetClassDevs(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetTempPath__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetTempPath(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__SetupDiGetClassDevs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetupDiGetClassDevs(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__GetTempPath__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetTempPath(x, arg2);
 }
 
-void test__SetupDiGetClassDevs__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetupDiGetClassDevs(arg1, x, arg3, arg4);
+void test__GetTempPathW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetTempPathW(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SetupDiGetClassDevs__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetupDiGetClassDevs(arg1, arg2, x, arg4);
+void test__GetTempPathW__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetTempPathW(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__SetupDiGetClassDevs__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetupDiGetClassDevs(arg1, arg2, arg3, x);
+void test__GetTempPathW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetTempPathW(x, arg2);
 }
 
-void test___mbsstr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mbsstr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetTempPathA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetTempPathA(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsstr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mbsstr(arg1, arg2);
+void test__GetTempPathA__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetTempPathA(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___mbsstr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mbsstr(p, arg2);
-    // cppcheck-suppress memleak
+void test__GetTempPathA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetTempPathA(x, arg2);
 }
 
-void test___mbsstr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbsstr(NULL, arg2);
+void test__SetupDiDestroyDeviceInfoList__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetupDiDestroyDeviceInfoList(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsstr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbsstr(x, arg2);
+void test__SetupDiDestroyDeviceInfoList__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetupDiDestroyDeviceInfoList(p);
+  // cppcheck-suppress memleak
 }
 
-void test___mbsstr__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbsstr(arg1, NULL);
+void test__SetupDiDestroyDeviceInfoList__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiDestroyDeviceInfoList(x);
 }
 
-void test___mbsstr__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbsstr(arg1, x);
+void test__SetupDiGetDeviceInstanceId__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetupDiGetDeviceInstanceId(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcsstr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _tcsstr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SetupDiGetDeviceInstanceId__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetupDiGetDeviceInstanceId(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test___tcsstr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _tcsstr(arg1, arg2);
+void test__SetupDiGetDeviceInstanceId__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiGetDeviceInstanceId(x, arg2, arg3, arg4, arg5);
 }
 
-void test___tcsstr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _tcsstr(p, arg2);
-    // cppcheck-suppress memleak
+void test__SetupDiGetDeviceInstanceId__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiGetDeviceInstanceId(arg1, x, arg3, arg4, arg5);
 }
 
-void test___tcsstr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tcsstr(NULL, arg2);
+void test__SetupDiGetDeviceInstanceId__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiGetDeviceInstanceId(arg1, arg2, arg3, x, arg5);
 }
 
-void test___tcsstr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tcsstr(x, arg2);
+void test__SetupDiEnumDeviceInfo__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetupDiEnumDeviceInfo(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcsstr__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tcsstr(arg1, NULL);
+void test__SetupDiEnumDeviceInfo__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetupDiEnumDeviceInfo(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___tcsstr__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tcsstr(arg1, x);
+void test__SetupDiEnumDeviceInfo__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiEnumDeviceInfo(x, arg2, arg3);
 }
 
-void test___mbsstr_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mbsstr_l(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SetupDiEnumDeviceInfo__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiEnumDeviceInfo(arg1, x, arg3);
 }
 
-void test___mbsstr_l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mbsstr_l(arg1, arg2, arg3);
+void test__SetupDiGetClassDevs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetupDiGetClassDevs(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsstr_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mbsstr_l(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__SetupDiGetClassDevs__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetupDiGetClassDevs(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test___mbsstr_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbsstr_l(NULL, arg2, arg3);
+void test__SetupDiGetClassDevs__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiGetClassDevs(arg1, x, arg3, arg4);
 }
 
-void test___mbsstr_l__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbsstr_l(x, arg2, arg3);
+void test__SetupDiGetClassDevs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiGetClassDevs(arg1, arg2, x, arg4);
 }
 
-void test___mbsstr_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbsstr_l(arg1, NULL, arg3);
+void test__SetupDiGetClassDevs__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiGetClassDevs(arg1, arg2, arg3, x);
 }
 
-void test___mbsstr_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbsstr_l(arg1, x, arg3);
+void test___mbsstr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mbsstr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsstr_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _mbsstr_l(arg1, arg2, x);
+void test___mbsstr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsstr(arg1, arg2);
 }
 
-void test___memccpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _memccpy(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbsstr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mbsstr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___memccpy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _memccpy(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___mbsstr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsstr(NULL, arg2);
 }
 
-void test___memccpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _memccpy(NULL, arg2, arg3, arg4);
+void test___mbsstr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsstr(x, arg2);
 }
 
-void test___memccpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _memccpy(arg1, NULL, arg3, arg4);
+void test___mbsstr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsstr(arg1, NULL);
 }
 
-void test___memccpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _memccpy(arg1, x, arg3, arg4);
+void test___mbsstr__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsstr(arg1, x);
 }
 
-void test___memccpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _memccpy(arg1, arg2, x, arg4);
+void test___tcsstr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _tcsstr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___memccpy__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _memccpy(arg1, arg2, arg3, x);
+void test___tcsstr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcsstr(arg1, arg2);
 }
 
-void test___fcloseall__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _fcloseall();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcsstr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _tcsstr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___open__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _open(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcsstr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsstr(NULL, arg2);
 }
 
-void test___open__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _open(arg1, arg2, arg3);
+void test___tcsstr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsstr(x, arg2);
 }
 
-void test___open__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _open(NULL, arg2, arg3);
+void test___tcsstr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsstr(arg1, NULL);
 }
 
-void test___open__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _open(x, arg2, arg3);
+void test___tcsstr__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsstr(arg1, x);
 }
 
-void test___open__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _open(arg1, x, arg3);
+void test___mbsstr_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mbsstr_l(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___open__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _open(arg1, arg2, x);
+void test___mbsstr_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsstr_l(arg1, arg2, arg3);
 }
 
-void test___wopen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _wopen(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbsstr_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mbsstr_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___wopen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _wopen(arg1, arg2, arg3);
+void test___mbsstr_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsstr_l(NULL, arg2, arg3);
 }
 
-void test___wopen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _wopen(NULL, arg2, arg3);
+void test___mbsstr_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsstr_l(x, arg2, arg3);
 }
 
-void test___wopen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _wopen(x, arg2, arg3);
+void test___mbsstr_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsstr_l(arg1, NULL, arg3);
 }
 
-void test___wopen__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _wopen(arg1, x, arg3);
+void test___mbsstr_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsstr_l(arg1, x, arg3);
 }
 
-void test___wopen__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _wopen(arg1, arg2, x);
+void test___mbsstr_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsstr_l(arg1, arg2, x);
 }
 
-void test___topen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _topen(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___memccpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _memccpy(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___topen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _topen(arg1, arg2, arg3);
+void test___memccpy__leakignore() {
+  char *p = malloc(10); *p=0;
+  _memccpy(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test___topen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _topen(NULL, arg2, arg3);
+void test___memccpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _memccpy(NULL, arg2, arg3, arg4);
 }
 
-void test___topen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _topen(x, arg2, arg3);
+void test___memccpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _memccpy(arg1, NULL, arg3, arg4);
 }
 
-void test___topen__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _topen(arg1, x, arg3);
+void test___memccpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _memccpy(arg1, x, arg3, arg4);
 }
 
-void test___topen__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _topen(arg1, arg2, x);
+void test___memccpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _memccpy(arg1, arg2, x, arg4);
 }
 
-void test___close__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _close(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___memccpy__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _memccpy(arg1, arg2, arg3, x);
 }
 
-void test___close__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _close(x);
+void test___fcloseall__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _fcloseall(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___swab__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _swab(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___open__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _open(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___swab__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _swab(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___open__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _open(arg1, arg2, arg3);
 }
 
-void test___swab__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _swab(NULL, arg2, arg3);
+void test___open__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _open(NULL, arg2, arg3);
 }
 
-void test___swab__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _swab(arg1, NULL, arg3);
+void test___open__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _open(x, arg2, arg3);
 }
 
-void test___swab__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _swab(arg1, x, arg3);
+void test___open__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _open(arg1, x, arg3);
 }
 
-void test___swab__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    _swab(arg1, arg2, !x);
+void test___open__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _open(arg1, arg2, x);
 }
 
-void test___swab__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _swab(arg1, arg2, x);
+void test___wopen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _wopen(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___strnicmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _strnicmp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _wopen(arg1, arg2, arg3);
 }
 
-void test___strnicmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _strnicmp(arg1, arg2, arg3);
+void test___wopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wopen(NULL, arg2, arg3);
 }
 
-void test___strnicmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _strnicmp(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___wopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wopen(x, arg2, arg3);
 }
 
-void test___strnicmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _strnicmp(NULL, arg2, arg3);
+void test___wopen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _wopen(arg1, x, arg3);
 }
 
-void test___strnicmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _strnicmp(x, arg2, arg3);
+void test___wopen__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _wopen(arg1, arg2, x);
 }
 
-void test___strnicmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _strnicmp(arg1, NULL, arg3);
+void test___topen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _topen(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___strnicmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _strnicmp(arg1, x, arg3);
+void test___topen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _topen(arg1, arg2, arg3);
 }
 
-void test___strnicmp__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = _strnicmp(arg1, arg2, !x);
+void test___topen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _topen(NULL, arg2, arg3);
 }
 
-void test___strnicmp__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _strnicmp(arg1, arg2, x);
+void test___topen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _topen(x, arg2, arg3);
 }
 
-void test___wcsnicmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _wcsnicmp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___topen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _topen(arg1, x, arg3);
 }
 
-void test___wcsnicmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _wcsnicmp(arg1, arg2, arg3);
+void test___topen__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _topen(arg1, arg2, x);
 }
 
-void test___wcsnicmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _wcsnicmp(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___close__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _close(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wcsnicmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _wcsnicmp(NULL, arg2, arg3);
+void test___close__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _close(x);
 }
 
-void test___wcsnicmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _wcsnicmp(x, arg2, arg3);
+void test___swab__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _swab(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wcsnicmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _wcsnicmp(arg1, NULL, arg3);
+void test___swab__leakignore() {
+  char *p = malloc(10); *p=0;
+  _swab(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___wcsnicmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _wcsnicmp(arg1, x, arg3);
+void test___swab__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _swab(NULL, arg2, arg3);
 }
 
-void test___wcsnicmp__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = _wcsnicmp(arg1, arg2, !x);
+void test___swab__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _swab(arg1, NULL, arg3);
 }
 
-void test___wcsnicmp__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _wcsnicmp(arg1, arg2, x);
+void test___swab__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _swab(arg1, x, arg3);
 }
 
-void test___mbsnicmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mbsnicmp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___swab__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _swab(arg1, arg2, !x);
 }
 
-void test___mbsnicmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mbsnicmp(arg1, arg2, arg3);
+void test___swab__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _swab(arg1, arg2, x);
 }
 
-void test___mbsnicmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mbsnicmp(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___strnicmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _strnicmp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsnicmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbsnicmp(NULL, arg2, arg3);
+void test___strnicmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _strnicmp(arg1, arg2, arg3);
 }
 
-void test___mbsnicmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbsnicmp(x, arg2, arg3);
+void test___strnicmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _strnicmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___mbsnicmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbsnicmp(arg1, NULL, arg3);
+void test___strnicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _strnicmp(NULL, arg2, arg3);
 }
 
-void test___mbsnicmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbsnicmp(arg1, x, arg3);
+void test___strnicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _strnicmp(x, arg2, arg3);
 }
 
-void test___mbsnicmp__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = _mbsnicmp(arg1, arg2, !x);
+void test___strnicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _strnicmp(arg1, NULL, arg3);
 }
 
-void test___mbsnicmp__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _mbsnicmp(arg1, arg2, x);
+void test___strnicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _strnicmp(arg1, x, arg3);
 }
 
-void test___tcsncicmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _tcsncicmp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___strnicmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _strnicmp(arg1, arg2, !x);
 }
 
-void test___tcsncicmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _tcsncicmp(arg1, arg2, arg3);
+void test___strnicmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _strnicmp(arg1, arg2, x);
 }
 
-void test___tcsncicmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _tcsncicmp(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___wcsnicmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _wcsnicmp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcsncicmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tcsncicmp(NULL, arg2, arg3);
+void test___wcsnicmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _wcsnicmp(arg1, arg2, arg3);
 }
 
-void test___tcsncicmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tcsncicmp(x, arg2, arg3);
+void test___wcsnicmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _wcsnicmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___tcsncicmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tcsncicmp(arg1, NULL, arg3);
+void test___wcsnicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wcsnicmp(NULL, arg2, arg3);
 }
 
-void test___tcsncicmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tcsncicmp(arg1, x, arg3);
+void test___wcsnicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wcsnicmp(x, arg2, arg3);
 }
 
-void test___tcsncicmp__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = _tcsncicmp(arg1, arg2, !x);
+void test___wcsnicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wcsnicmp(arg1, NULL, arg3);
 }
 
-void test___tcsncicmp__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _tcsncicmp(arg1, arg2, x);
+void test___wcsnicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wcsnicmp(arg1, x, arg3);
 }
 
-void test___tcsnicmp__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _tcsnicmp(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wcsnicmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _wcsnicmp(arg1, arg2, !x);
 }
 
-void test___tcsnicmp__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _tcsnicmp(arg1, arg2, arg3);
+void test___wcsnicmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _wcsnicmp(arg1, arg2, x);
 }
 
-void test___tcsnicmp__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _tcsnicmp(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___mbsnicmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mbsnicmp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcsnicmp__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tcsnicmp(NULL, arg2, arg3);
+void test___mbsnicmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsnicmp(arg1, arg2, arg3);
 }
 
-void test___tcsnicmp__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tcsnicmp(x, arg2, arg3);
+void test___mbsnicmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mbsnicmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___tcsnicmp__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tcsnicmp(arg1, NULL, arg3);
+void test___mbsnicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsnicmp(NULL, arg2, arg3);
 }
 
-void test___tcsnicmp__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tcsnicmp(arg1, x, arg3);
+void test___mbsnicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsnicmp(x, arg2, arg3);
 }
 
-void test___tcsnicmp__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = _tcsnicmp(arg1, arg2, !x);
+void test___mbsnicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsnicmp(arg1, NULL, arg3);
 }
 
-void test___tcsnicmp__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _tcsnicmp(arg1, arg2, x);
+void test___mbsnicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsnicmp(arg1, x, arg3);
 }
 
-void test___strnicmp_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _strnicmp_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbsnicmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _mbsnicmp(arg1, arg2, !x);
 }
 
-void test___strnicmp_l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _strnicmp_l(arg1, arg2, arg3, arg4);
+void test___mbsnicmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsnicmp(arg1, arg2, x);
 }
 
-void test___strnicmp_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _strnicmp_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___tcsncicmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _tcsncicmp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___strnicmp_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _strnicmp_l(NULL, arg2, arg3, arg4);
+void test___tcsncicmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcsncicmp(arg1, arg2, arg3);
 }
 
-void test___strnicmp_l__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _strnicmp_l(x, arg2, arg3, arg4);
+void test___tcsncicmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _tcsncicmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___strnicmp_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _strnicmp_l(arg1, NULL, arg3, arg4);
+void test___tcsncicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsncicmp(NULL, arg2, arg3);
 }
 
-void test___strnicmp_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _strnicmp_l(arg1, x, arg3, arg4);
+void test___tcsncicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsncicmp(x, arg2, arg3);
 }
 
-void test___strnicmp_l__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = _strnicmp_l(arg1, arg2, !x, arg4);
+void test___tcsncicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsncicmp(arg1, NULL, arg3);
 }
 
-void test___strnicmp_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _strnicmp_l(arg1, arg2, x, arg4);
+void test___tcsncicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsncicmp(arg1, x, arg3);
 }
 
-void test___strnicmp_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _strnicmp_l(arg1, arg2, arg3, x);
+void test___tcsncicmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _tcsncicmp(arg1, arg2, !x);
 }
 
-void test___wcsnicmp_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _wcsnicmp_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcsncicmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tcsncicmp(arg1, arg2, x);
 }
 
-void test___wcsnicmp_l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _wcsnicmp_l(arg1, arg2, arg3, arg4);
+void test___tcsnicmp__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _tcsnicmp(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wcsnicmp_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _wcsnicmp_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___tcsnicmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcsnicmp(arg1, arg2, arg3);
 }
 
-void test___wcsnicmp_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _wcsnicmp_l(NULL, arg2, arg3, arg4);
+void test___tcsnicmp__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _tcsnicmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___wcsnicmp_l__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _wcsnicmp_l(x, arg2, arg3, arg4);
+void test___tcsnicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsnicmp(NULL, arg2, arg3);
 }
 
-void test___wcsnicmp_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _wcsnicmp_l(arg1, NULL, arg3, arg4);
+void test___tcsnicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsnicmp(x, arg2, arg3);
 }
 
-void test___wcsnicmp_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _wcsnicmp_l(arg1, x, arg3, arg4);
+void test___tcsnicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsnicmp(arg1, NULL, arg3);
 }
 
-void test___wcsnicmp_l__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = _wcsnicmp_l(arg1, arg2, !x, arg4);
+void test___tcsnicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsnicmp(arg1, x, arg3);
 }
 
-void test___wcsnicmp_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _wcsnicmp_l(arg1, arg2, x, arg4);
+void test___tcsnicmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _tcsnicmp(arg1, arg2, !x);
 }
 
-void test___wcsnicmp_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _wcsnicmp_l(arg1, arg2, arg3, x);
+void test___tcsnicmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tcsnicmp(arg1, arg2, x);
 }
 
-void test___mbsnicmp_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mbsnicmp_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___strnicmp_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _strnicmp_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsnicmp_l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mbsnicmp_l(arg1, arg2, arg3, arg4);
+void test___strnicmp_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _strnicmp_l(arg1, arg2, arg3, arg4);
 }
 
-void test___mbsnicmp_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mbsnicmp_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___strnicmp_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _strnicmp_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test___mbsnicmp_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbsnicmp_l(NULL, arg2, arg3, arg4);
+void test___strnicmp_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _strnicmp_l(NULL, arg2, arg3, arg4);
 }
 
-void test___mbsnicmp_l__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbsnicmp_l(x, arg2, arg3, arg4);
+void test___strnicmp_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _strnicmp_l(x, arg2, arg3, arg4);
 }
 
-void test___mbsnicmp_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbsnicmp_l(arg1, NULL, arg3, arg4);
+void test___strnicmp_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _strnicmp_l(arg1, NULL, arg3, arg4);
 }
 
-void test___mbsnicmp_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbsnicmp_l(arg1, x, arg3, arg4);
+void test___strnicmp_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _strnicmp_l(arg1, x, arg3, arg4);
 }
 
-void test___mbsnicmp_l__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = _mbsnicmp_l(arg1, arg2, !x, arg4);
+void test___strnicmp_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _strnicmp_l(arg1, arg2, !x, arg4);
 }
 
-void test___mbsnicmp_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _mbsnicmp_l(arg1, arg2, x, arg4);
+void test___strnicmp_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _strnicmp_l(arg1, arg2, x, arg4);
 }
 
-void test___mbsnicmp_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _mbsnicmp_l(arg1, arg2, arg3, x);
+void test___strnicmp_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _strnicmp_l(arg1, arg2, arg3, x);
 }
 
-void test___tcsncicmp_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _tcsncicmp_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wcsnicmp_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _wcsnicmp_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcsncicmp_l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _tcsncicmp_l(arg1, arg2, arg3, arg4);
+void test___wcsnicmp_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _wcsnicmp_l(arg1, arg2, arg3, arg4);
 }
 
-void test___tcsncicmp_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _tcsncicmp_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___wcsnicmp_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _wcsnicmp_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test___tcsncicmp_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tcsncicmp_l(NULL, arg2, arg3, arg4);
+void test___wcsnicmp_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wcsnicmp_l(NULL, arg2, arg3, arg4);
 }
 
-void test___tcsncicmp_l__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tcsncicmp_l(x, arg2, arg3, arg4);
+void test___wcsnicmp_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wcsnicmp_l(x, arg2, arg3, arg4);
 }
 
-void test___tcsncicmp_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tcsncicmp_l(arg1, NULL, arg3, arg4);
+void test___wcsnicmp_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wcsnicmp_l(arg1, NULL, arg3, arg4);
 }
 
-void test___tcsncicmp_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tcsncicmp_l(arg1, x, arg3, arg4);
+void test___wcsnicmp_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wcsnicmp_l(arg1, x, arg3, arg4);
 }
 
-void test___tcsncicmp_l__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = _tcsncicmp_l(arg1, arg2, !x, arg4);
+void test___wcsnicmp_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _wcsnicmp_l(arg1, arg2, !x, arg4);
 }
 
-void test___tcsncicmp_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _tcsncicmp_l(arg1, arg2, x, arg4);
+void test___wcsnicmp_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _wcsnicmp_l(arg1, arg2, x, arg4);
 }
 
-void test___tcsncicmp_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _tcsncicmp_l(arg1, arg2, arg3, x);
+void test___wcsnicmp_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _wcsnicmp_l(arg1, arg2, arg3, x);
 }
 
-void test___malloc_dbg__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _malloc_dbg(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbsnicmp_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mbsnicmp_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___malloc_dbg__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _malloc_dbg(arg1, arg2, arg3, arg4);
+void test___mbsnicmp_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsnicmp_l(arg1, arg2, arg3, arg4);
 }
 
-void test___malloc_dbg__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _malloc_dbg(x, arg2, arg3, arg4);
+void test___mbsnicmp_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mbsnicmp_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test___malloc_dbg__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _malloc_dbg(arg1, x, arg3, arg4);
+void test___mbsnicmp_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsnicmp_l(NULL, arg2, arg3, arg4);
 }
 
-void test___malloc_dbg__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _malloc_dbg(arg1, arg2, x, arg4);
+void test___mbsnicmp_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsnicmp_l(x, arg2, arg3, arg4);
 }
 
-void test___malloc_dbg__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _malloc_dbg(arg1, arg2, arg3, x);
+void test___mbsnicmp_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsnicmp_l(arg1, NULL, arg3, arg4);
 }
 
-void test___aligned_malloc_dbg__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _aligned_malloc_dbg(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbsnicmp_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsnicmp_l(arg1, x, arg3, arg4);
 }
 
-void test___aligned_malloc_dbg__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _aligned_malloc_dbg(arg1, arg2, arg3, arg4);
+void test___mbsnicmp_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _mbsnicmp_l(arg1, arg2, !x, arg4);
 }
 
-void test___aligned_malloc_dbg__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _aligned_malloc_dbg(x, arg2, arg3, arg4);
+void test___mbsnicmp_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsnicmp_l(arg1, arg2, x, arg4);
 }
 
-void test___aligned_malloc_dbg__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _aligned_malloc_dbg(arg1, x, arg3, arg4);
+void test___mbsnicmp_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsnicmp_l(arg1, arg2, arg3, x);
 }
 
-void test___aligned_malloc_dbg__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _aligned_malloc_dbg(arg1, arg2, x, arg4);
+void test___tcsncicmp_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _tcsncicmp_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___aligned_malloc_dbg__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _aligned_malloc_dbg(arg1, arg2, arg3, x);
+void test___tcsncicmp_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcsncicmp_l(arg1, arg2, arg3, arg4);
 }
 
-void test___aligned_malloc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _aligned_malloc(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcsncicmp_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _tcsncicmp_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test___aligned_malloc__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _aligned_malloc(arg1, arg2);
+void test___tcsncicmp_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsncicmp_l(NULL, arg2, arg3, arg4);
 }
 
-void test___aligned_malloc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _aligned_malloc(x, arg2);
+void test___tcsncicmp_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsncicmp_l(x, arg2, arg3, arg4);
 }
 
-void test___aligned_malloc__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _aligned_malloc(arg1, x);
+void test___tcsncicmp_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsncicmp_l(arg1, NULL, arg3, arg4);
 }
 
-void test___mbslen_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mbslen_l(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcsncicmp_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsncicmp_l(arg1, x, arg3, arg4);
 }
 
-void test___mbslen_l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mbslen_l(arg1, arg2);
+void test___tcsncicmp_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _tcsncicmp_l(arg1, arg2, !x, arg4);
 }
 
-void test___mbslen_l__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_mbslen_l(arg1, arg2) > 10) || (_mbslen_l(arg1, arg2) < 100)) {}
+void test___tcsncicmp_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tcsncicmp_l(arg1, arg2, x, arg4);
 }
 
-void test___mbslen_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mbslen_l(p, arg2);
-    // cppcheck-suppress memleak
+void test___tcsncicmp_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tcsncicmp_l(arg1, arg2, arg3, x);
 }
 
-void test___mbslen_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbslen_l(NULL, arg2);
+void test___malloc_dbg__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _malloc_dbg(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbslen_l__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbslen_l(x, arg2);
+void test___malloc_dbg__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _malloc_dbg(arg1, arg2, arg3, arg4);
 }
 
-void test___mbslen_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _mbslen_l(arg1, x);
+void test___malloc_dbg__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _malloc_dbg(x, arg2, arg3, arg4);
 }
 
-void test___mbstrlen_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mbstrlen_l(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___malloc_dbg__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _malloc_dbg(arg1, x, arg3, arg4);
 }
 
-void test___mbstrlen_l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mbstrlen_l(arg1, arg2);
+void test___malloc_dbg__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _malloc_dbg(arg1, arg2, x, arg4);
 }
 
-void test___mbstrlen_l__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_mbstrlen_l(arg1, arg2) > 10) || (_mbstrlen_l(arg1, arg2) < 100)) {}
+void test___malloc_dbg__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _malloc_dbg(arg1, arg2, arg3, x);
 }
 
-void test___mbstrlen_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mbstrlen_l(p, arg2);
-    // cppcheck-suppress memleak
+void test___aligned_malloc_dbg__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _aligned_malloc_dbg(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbstrlen_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbstrlen_l(NULL, arg2);
+void test___aligned_malloc_dbg__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _aligned_malloc_dbg(arg1, arg2, arg3, arg4);
 }
 
-void test___mbstrlen_l__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbstrlen_l(x, arg2);
+void test___aligned_malloc_dbg__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _aligned_malloc_dbg(x, arg2, arg3, arg4);
 }
 
-void test___mbstrlen_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _mbstrlen_l(arg1, x);
+void test___aligned_malloc_dbg__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _aligned_malloc_dbg(arg1, x, arg3, arg4);
 }
 
-void test___tcsclen_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _tcsclen_l(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___aligned_malloc_dbg__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _aligned_malloc_dbg(arg1, arg2, x, arg4);
 }
 
-void test___tcsclen_l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _tcsclen_l(arg1, arg2);
+void test___aligned_malloc_dbg__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _aligned_malloc_dbg(arg1, arg2, arg3, x);
 }
 
-void test___tcsclen_l__pure(int arg1,int arg2)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_tcsclen_l(arg1, arg2) > 10) || (_tcsclen_l(arg1, arg2) < 100)) {}
+void test___aligned_malloc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _aligned_malloc(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcsclen_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _tcsclen_l(p, arg2);
-    // cppcheck-suppress memleak
+void test___aligned_malloc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _aligned_malloc(arg1, arg2);
 }
 
-void test___tcsclen_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tcsclen_l(NULL, arg2);
+void test___aligned_malloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _aligned_malloc(x, arg2);
 }
 
-void test___tcsclen_l__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tcsclen_l(x, arg2);
+void test___aligned_malloc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _aligned_malloc(arg1, x);
 }
 
-void test___tcsclen_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _tcsclen_l(arg1, x);
+void test___mbslen_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mbslen_l(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbslen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mbslen(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbslen_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbslen_l(arg1, arg2);
 }
 
-void test___mbslen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mbslen(arg1);
+void test___mbslen_l__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_mbslen_l(arg1, arg2) > 10) || (_mbslen_l(arg1, arg2) < 100)) {}
 }
 
-void test___mbslen__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_mbslen(arg1) > 10) || (_mbslen(arg1) < 100)) {}
+void test___mbslen_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mbslen_l(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___mbslen__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mbslen(p);
-    // cppcheck-suppress memleak
+void test___mbslen_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbslen_l(NULL, arg2);
 }
 
-void test___mbslen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbslen(NULL);
+void test___mbslen_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbslen_l(x, arg2);
 }
 
-void test___mbslen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbslen(x);
+void test___mbslen_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbslen_l(arg1, x);
 }
 
-void test___mbstrlen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mbstrlen(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbstrlen_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mbstrlen_l(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbstrlen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mbstrlen(arg1);
+void test___mbstrlen_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbstrlen_l(arg1, arg2);
 }
 
-void test___mbstrlen__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_mbstrlen(arg1) > 10) || (_mbstrlen(arg1) < 100)) {}
+void test___mbstrlen_l__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_mbstrlen_l(arg1, arg2) > 10) || (_mbstrlen_l(arg1, arg2) < 100)) {}
 }
 
-void test___mbstrlen__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mbstrlen(p);
-    // cppcheck-suppress memleak
+void test___mbstrlen_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mbstrlen_l(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___mbstrlen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbstrlen(NULL);
+void test___mbstrlen_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbstrlen_l(NULL, arg2);
 }
 
-void test___mbstrlen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbstrlen(x);
+void test___mbstrlen_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbstrlen_l(x, arg2);
 }
 
-void test___tcslen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _tcslen(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbstrlen_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbstrlen_l(arg1, x);
 }
 
-void test___tcslen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _tcslen(arg1);
+void test___tcsclen_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _tcsclen_l(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcslen__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_tcslen(arg1) > 10) || (_tcslen(arg1) < 100)) {}
+void test___tcsclen_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcsclen_l(arg1, arg2);
 }
 
-void test___tcslen__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _tcslen(p);
-    // cppcheck-suppress memleak
+void test___tcsclen_l__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_tcsclen_l(arg1, arg2) > 10) || (_tcsclen_l(arg1, arg2) < 100)) {}
 }
 
-void test___tcslen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tcslen(NULL);
+void test___tcsclen_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _tcsclen_l(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___tcslen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tcslen(x);
+void test___tcsclen_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsclen_l(NULL, arg2);
 }
 
-void test___tcsclen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _tcsclen(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcsclen_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsclen_l(x, arg2);
 }
 
-void test___tcsclen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _tcsclen(arg1);
+void test___tcsclen_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tcsclen_l(arg1, x);
 }
 
-void test___tcsclen__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((_tcsclen(arg1) > 10) || (_tcsclen(arg1) < 100)) {}
+void test___mbslen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mbslen(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcsclen__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _tcsclen(p);
-    // cppcheck-suppress memleak
+void test___mbslen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbslen(arg1);
 }
 
-void test___tcsclen__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tcsclen(NULL);
+void test___mbslen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_mbslen(arg1) > 10) || (_mbslen(arg1) < 100)) {}
 }
 
-void test___tcsclen__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tcsclen(x);
+void test___mbslen__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mbslen(p);
+  // cppcheck-suppress memleak
 }
 
-void test___mbsrchr_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mbsrchr_l(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbslen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbslen(NULL);
 }
 
-void test___mbsrchr_l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mbsrchr_l(arg1, arg2, arg3);
+void test___mbslen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbslen(x);
 }
 
-void test___mbsrchr_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mbsrchr_l(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___mbstrlen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mbstrlen(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsrchr_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbsrchr_l(NULL, arg2, arg3);
+void test___mbstrlen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbstrlen(arg1);
 }
 
-void test___mbsrchr_l__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbsrchr_l(x, arg2, arg3);
+void test___mbstrlen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_mbstrlen(arg1) > 10) || (_mbstrlen(arg1) < 100)) {}
 }
 
-void test___mbsrchr_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _mbsrchr_l(arg1, x, arg3);
+void test___mbstrlen__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mbstrlen(p);
+  // cppcheck-suppress memleak
 }
 
-void test___mbsrchr_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _mbsrchr_l(arg1, arg2, x);
+void test___mbstrlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbstrlen(NULL);
 }
 
-void test___mbsrchr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _mbsrchr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbstrlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbstrlen(x);
 }
 
-void test___mbsrchr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _mbsrchr(arg1, arg2);
+void test___tcslen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _tcslen(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsrchr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _mbsrchr(p, arg2);
-    // cppcheck-suppress memleak
+void test___tcslen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcslen(arg1);
 }
 
-void test___mbsrchr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _mbsrchr(NULL, arg2);
+void test___tcslen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_tcslen(arg1) > 10) || (_tcslen(arg1) < 100)) {}
 }
 
-void test___mbsrchr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _mbsrchr(x, arg2);
+void test___tcslen__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _tcslen(p);
+  // cppcheck-suppress memleak
 }
 
-void test___mbsrchr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _mbsrchr(arg1, x);
+void test___tcslen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcslen(NULL);
 }
 
-void test___tcsrchr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _tcsrchr(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcslen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcslen(x);
 }
 
-void test___tcsrchr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _tcsrchr(arg1, arg2);
+void test___tcsclen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _tcsclen(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcsrchr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _tcsrchr(p, arg2);
-    // cppcheck-suppress memleak
+void test___tcsclen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcsclen(arg1);
 }
 
-void test___tcsrchr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tcsrchr(NULL, arg2);
+void test___tcsclen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_tcsclen(arg1) > 10) || (_tcsclen(arg1) < 100)) {}
 }
 
-void test___tcsrchr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tcsrchr(x, arg2);
+void test___tcsclen__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _tcsclen(p);
+  // cppcheck-suppress memleak
 }
 
-void test___tcsrchr__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _tcsrchr(arg1, x);
+void test___tcsclen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsclen(NULL);
 }
 
-void test___strftime_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _strftime_l(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcsclen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsclen(x);
 }
 
-void test___strftime_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _strftime_l(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test___mbsrchr_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mbsrchr_l(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___strftime_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _strftime_l(NULL, arg2, arg3, arg4, arg5);
+void test___mbsrchr_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsrchr_l(arg1, arg2, arg3);
 }
 
-void test___strftime_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _strftime_l(arg1, x, arg3, arg4, arg5);
+void test___mbsrchr_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mbsrchr_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___strftime_l__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _strftime_l(arg1, arg2, NULL, arg4, arg5);
+void test___mbsrchr_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsrchr_l(NULL, arg2, arg3);
 }
 
-void test___strftime_l__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _strftime_l(arg1, arg2, x, arg4, arg5);
+void test___mbsrchr_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsrchr_l(x, arg2, arg3);
 }
 
-void test___strftime_l__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _strftime_l(arg1, arg2, arg3, NULL, arg5);
+void test___mbsrchr_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsrchr_l(arg1, x, arg3);
 }
 
-void test___strftime_l__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _strftime_l(arg1, arg2, arg3, x, arg5);
+void test___mbsrchr_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsrchr_l(arg1, arg2, x);
 }
 
-void test___strftime_l__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _strftime_l(arg1, arg2, arg3, arg4, x);
+void test___mbsrchr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _mbsrchr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wcsftime_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wcsftime_l(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbsrchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsrchr(arg1, arg2);
 }
 
-void test___wcsftime_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _wcsftime_l(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test___mbsrchr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _mbsrchr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___wcsftime_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wcsftime_l(NULL, arg2, arg3, arg4, arg5);
+void test___mbsrchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsrchr(NULL, arg2);
 }
 
-void test___wcsftime_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _wcsftime_l(arg1, x, arg3, arg4, arg5);
+void test___mbsrchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsrchr(x, arg2);
 }
 
-void test___wcsftime_l__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wcsftime_l(arg1, arg2, NULL, arg4, arg5);
+void test___mbsrchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsrchr(arg1, x);
 }
 
-void test___wcsftime_l__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wcsftime_l(arg1, arg2, x, arg4, arg5);
+void test___tcsrchr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _tcsrchr(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wcsftime_l__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wcsftime_l(arg1, arg2, arg3, NULL, arg5);
+void test___tcsrchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcsrchr(arg1, arg2);
 }
 
-void test___wcsftime_l__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wcsftime_l(arg1, arg2, arg3, x, arg5);
+void test___tcsrchr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _tcsrchr(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___wcsftime_l__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _wcsftime_l(arg1, arg2, arg3, arg4, x);
+void test___tcsrchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsrchr(NULL, arg2);
 }
 
-void test___tcsftime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tcsftime(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcsrchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsrchr(x, arg2);
 }
 
-void test___tcsftime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _tcsftime(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___tcsrchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tcsrchr(arg1, x);
 }
 
-void test___tcsftime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcsftime(NULL, arg2, arg3, arg4);
+void test___strftime_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _strftime_l(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcsftime__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _tcsftime(arg1, x, arg3, arg4);
+void test___strftime_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _strftime_l(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test___tcsftime__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcsftime(arg1, arg2, NULL, arg4);
+void test___strftime_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _strftime_l(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test___tcsftime__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tcsftime(arg1, arg2, x, arg4);
+void test___strftime_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strftime_l(arg1, x, arg3, arg4, arg5);
 }
 
-void test___tcsftime__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcsftime(arg1, arg2, arg3, NULL);
+void test___strftime_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _strftime_l(arg1, arg2, NULL, arg4, arg5);
 }
 
-void test___tcsftime__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tcsftime(arg1, arg2, arg3, x);
+void test___strftime_l__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _strftime_l(arg1, arg2, x, arg4, arg5);
 }
 
-void test___wfreopen_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _wfreopen_s(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___strftime_l__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _strftime_l(arg1, arg2, arg3, NULL, arg5);
 }
 
-void test___wfreopen_s__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _wfreopen_s(arg1, arg2, arg3, arg4);
+void test___strftime_l__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _strftime_l(arg1, arg2, arg3, x, arg5);
 }
 
-void test___wfreopen_s__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _wfreopen_s(x, arg2, arg3, arg4);
+void test___strftime_l__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strftime_l(arg1, arg2, arg3, arg4, x);
 }
 
-void test___wfreopen_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _wfreopen_s(arg1, x, arg3, arg4);
+void test___wcsftime_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wcsftime_l(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wfreopen_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _wfreopen_s(arg1, arg2, NULL, arg4);
+void test___wcsftime_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _wcsftime_l(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test___wfreopen_s__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _wfreopen_s(arg1, arg2, x, arg4);
+void test___wcsftime_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsftime_l(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test___wfreopen_s__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _wfreopen_s(arg1, arg2, arg3, NULL);
+void test___wcsftime_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsftime_l(arg1, x, arg3, arg4, arg5);
 }
 
-void test___wfreopen_s__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _wfreopen_s(arg1, arg2, arg3, x);
+void test___wcsftime_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsftime_l(arg1, arg2, NULL, arg4, arg5);
 }
 
-void test___tfreopen_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _tfreopen_s(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wcsftime_l__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsftime_l(arg1, arg2, x, arg4, arg5);
 }
 
-void test___tfreopen_s__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _tfreopen_s(arg1, arg2, arg3, arg4);
+void test___wcsftime_l__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsftime_l(arg1, arg2, arg3, NULL, arg5);
 }
 
-void test___tfreopen_s__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _tfreopen_s(x, arg2, arg3, arg4);
+void test___wcsftime_l__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsftime_l(arg1, arg2, arg3, x, arg5);
 }
 
-void test___tfreopen_s__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _tfreopen_s(arg1, x, arg3, arg4);
+void test___wcsftime_l__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsftime_l(arg1, arg2, arg3, arg4, x);
 }
 
-void test___tfreopen_s__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tfreopen_s(arg1, arg2, NULL, arg4);
+void test___tcsftime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tcsftime(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tfreopen_s__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tfreopen_s(arg1, arg2, x, arg4);
+void test___tcsftime__leakignore() {
+  char *p = malloc(10); *p=0;
+  _tcsftime(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test___tfreopen_s__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tfreopen_s(arg1, arg2, arg3, NULL);
+void test___tcsftime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsftime(NULL, arg2, arg3, arg4);
 }
 
-void test___tfreopen_s__arg4__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tfreopen_s(arg1, arg2, arg3, x);
+void test___tcsftime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcsftime(arg1, x, arg3, arg4);
 }
 
-void test___wfreopen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _wfreopen(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcsftime__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsftime(arg1, arg2, NULL, arg4);
 }
 
-void test___wfreopen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _wfreopen(arg1, arg2, arg3);
+void test___tcsftime__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsftime(arg1, arg2, x, arg4);
 }
 
-void test___wfreopen__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _wfreopen(x, arg2, arg3);
+void test___tcsftime__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsftime(arg1, arg2, arg3, NULL);
 }
 
-void test___wfreopen__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _wfreopen(arg1, NULL, arg3);
+void test___tcsftime__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsftime(arg1, arg2, arg3, x);
 }
 
-void test___wfreopen__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _wfreopen(arg1, x, arg3);
+void test___wfreopen_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _wfreopen_s(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wfreopen__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _wfreopen(arg1, arg2, NULL);
+void test___wfreopen_s__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _wfreopen_s(arg1, arg2, arg3, arg4);
 }
 
-void test___wfreopen__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _wfreopen(arg1, arg2, x);
+void test___wfreopen_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _wfreopen_s(x, arg2, arg3, arg4);
 }
 
-void test___tfreopen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _tfreopen(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wfreopen_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _wfreopen_s(arg1, x, arg3, arg4);
 }
 
-void test___tfreopen__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _tfreopen(arg1, arg2, arg3);
+void test___wfreopen_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wfreopen_s(arg1, arg2, NULL, arg4);
 }
 
-void test___tfreopen__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _tfreopen(x, arg2, arg3);
+void test___wfreopen_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wfreopen_s(arg1, arg2, x, arg4);
 }
 
-void test___tfreopen__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tfreopen(arg1, NULL, arg3);
+void test___wfreopen_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wfreopen_s(arg1, arg2, arg3, NULL);
 }
 
-void test___tfreopen__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tfreopen(arg1, x, arg3);
+void test___wfreopen_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wfreopen_s(arg1, arg2, arg3, x);
 }
 
-void test___tfreopen__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _tfreopen(arg1, arg2, NULL);
+void test___tfreopen_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _tfreopen_s(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tfreopen__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _tfreopen(arg1, arg2, x);
+void test___tfreopen_s__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tfreopen_s(arg1, arg2, arg3, arg4);
 }
 
-void test___mbsncpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _mbsncpy(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tfreopen_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tfreopen_s(x, arg2, arg3, arg4);
 }
 
-void test___mbsncpy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _mbsncpy(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___tfreopen_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tfreopen_s(arg1, x, arg3, arg4);
 }
 
-void test___mbsncpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbsncpy(NULL, arg2, arg3);
+void test___tfreopen_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tfreopen_s(arg1, arg2, NULL, arg4);
 }
 
-void test___mbsncpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbsncpy(arg1, NULL, arg3);
+void test___tfreopen_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tfreopen_s(arg1, arg2, x, arg4);
 }
 
-void test___mbsncpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _mbsncpy(arg1, x, arg3);
+void test___tfreopen_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tfreopen_s(arg1, arg2, arg3, NULL);
 }
 
-void test___mbsncpy__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    _mbsncpy(arg1, arg2, !x);
+void test___tfreopen_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tfreopen_s(arg1, arg2, arg3, x);
 }
 
-void test___mbsncpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _mbsncpy(arg1, arg2, x);
+void test___wfreopen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _wfreopen(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsnbcpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _mbsnbcpy(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wfreopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _wfreopen(arg1, arg2, arg3);
 }
 
-void test___mbsnbcpy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _mbsnbcpy(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___wfreopen__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _wfreopen(x, arg2, arg3);
 }
 
-void test___mbsnbcpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbsnbcpy(NULL, arg2, arg3);
+void test___wfreopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wfreopen(arg1, NULL, arg3);
 }
 
-void test___mbsnbcpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbsnbcpy(arg1, NULL, arg3);
+void test___wfreopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wfreopen(arg1, x, arg3);
 }
 
-void test___mbsnbcpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _mbsnbcpy(arg1, x, arg3);
+void test___wfreopen__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wfreopen(arg1, arg2, NULL);
 }
 
-void test___mbsnbcpy__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    _mbsnbcpy(arg1, arg2, !x);
+void test___wfreopen__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wfreopen(arg1, arg2, x);
 }
 
-void test___mbsnbcpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _mbsnbcpy(arg1, arg2, x);
+void test___tfreopen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _tfreopen(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcsncpy__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tcsncpy(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tfreopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tfreopen(arg1, arg2, arg3);
 }
 
-void test___tcsncpy__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _tcsncpy(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___tfreopen__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tfreopen(x, arg2, arg3);
 }
 
-void test___tcsncpy__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcsncpy(NULL, arg2, arg3);
+void test___tfreopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tfreopen(arg1, NULL, arg3);
 }
 
-void test___tcsncpy__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcsncpy(arg1, NULL, arg3);
+void test___tfreopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tfreopen(arg1, x, arg3);
 }
 
-void test___tcsncpy__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tcsncpy(arg1, x, arg3);
+void test___tfreopen__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tfreopen(arg1, arg2, NULL);
 }
 
-void test___tcsncpy__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    _tcsncpy(arg1, arg2, !x);
+void test___tfreopen__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tfreopen(arg1, arg2, x);
 }
 
-void test___tcsncpy__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _tcsncpy(arg1, arg2, x);
+void test___mbsncpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _mbsncpy(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___strncpy_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _strncpy_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbsncpy__leakignore() {
+  char *p = malloc(10); *p=0;
+  _mbsncpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___strncpy_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _strncpy_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___mbsncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsncpy(NULL, arg2, arg3);
 }
 
-void test___strncpy_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _strncpy_l(NULL, arg2, arg3, arg4);
+void test___mbsncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsncpy(arg1, NULL, arg3);
 }
 
-void test___strncpy_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _strncpy_l(arg1, NULL, arg3, arg4);
+void test___mbsncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsncpy(arg1, x, arg3);
 }
 
-void test___strncpy_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _strncpy_l(arg1, x, arg3, arg4);
+void test___mbsncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _mbsncpy(arg1, arg2, !x);
 }
 
-void test___strncpy_l__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    _strncpy_l(arg1, arg2, !x, arg4);
+void test___mbsncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbsncpy(arg1, arg2, x);
 }
 
-void test___strncpy_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _strncpy_l(arg1, arg2, x, arg4);
+void test___mbsnbcpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _mbsnbcpy(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___strncpy_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _strncpy_l(arg1, arg2, arg3, x);
+void test___mbsnbcpy__leakignore() {
+  char *p = malloc(10); *p=0;
+  _mbsnbcpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___wcsncpy_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _wcsncpy_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbsnbcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsnbcpy(NULL, arg2, arg3);
 }
 
-void test___wcsncpy_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _wcsncpy_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___mbsnbcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsnbcpy(arg1, NULL, arg3);
 }
 
-void test___wcsncpy_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wcsncpy_l(NULL, arg2, arg3, arg4);
+void test___mbsnbcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsnbcpy(arg1, x, arg3);
 }
 
-void test___wcsncpy_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _wcsncpy_l(arg1, NULL, arg3, arg4);
+void test___mbsnbcpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _mbsnbcpy(arg1, arg2, !x);
 }
 
-void test___wcsncpy_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _wcsncpy_l(arg1, x, arg3, arg4);
+void test___mbsnbcpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbsnbcpy(arg1, arg2, x);
 }
 
-void test___wcsncpy_l__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    _wcsncpy_l(arg1, arg2, !x, arg4);
+void test___tcsncpy__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tcsncpy(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___wcsncpy_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _wcsncpy_l(arg1, arg2, x, arg4);
+void test___tcsncpy__leakignore() {
+  char *p = malloc(10); *p=0;
+  _tcsncpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test___wcsncpy_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _wcsncpy_l(arg1, arg2, arg3, x);
+void test___tcsncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsncpy(NULL, arg2, arg3);
 }
 
-void test___mbsncpy_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _mbsncpy_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcsncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsncpy(arg1, NULL, arg3);
 }
 
-void test___mbsncpy_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _mbsncpy_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___tcsncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsncpy(arg1, x, arg3);
 }
 
-void test___mbsncpy_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbsncpy_l(NULL, arg2, arg3, arg4);
+void test___tcsncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _tcsncpy(arg1, arg2, !x);
 }
 
-void test___mbsncpy_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _mbsncpy_l(arg1, NULL, arg3, arg4);
+void test___tcsncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcsncpy(arg1, arg2, x);
 }
 
-void test___mbsncpy_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _mbsncpy_l(arg1, x, arg3, arg4);
+void test___strncpy_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _strncpy_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___mbsncpy_l__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    _mbsncpy_l(arg1, arg2, !x, arg4);
+void test___strncpy_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _strncpy_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test___mbsncpy_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _mbsncpy_l(arg1, arg2, x, arg4);
+void test___strncpy_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _strncpy_l(NULL, arg2, arg3, arg4);
 }
 
-void test___mbsncpy_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _mbsncpy_l(arg1, arg2, arg3, x);
+void test___strncpy_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _strncpy_l(arg1, NULL, arg3, arg4);
 }
 
-void test___tcsncpy_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _tcsncpy_l(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___strncpy_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _strncpy_l(arg1, x, arg3, arg4);
 }
 
-void test___tcsncpy_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _tcsncpy_l(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test___strncpy_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _strncpy_l(arg1, arg2, !x, arg4);
 }
 
-void test___tcsncpy_l__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcsncpy_l(NULL, arg2, arg3, arg4);
+void test___strncpy_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strncpy_l(arg1, arg2, x, arg4);
 }
 
-void test___tcsncpy_l__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _tcsncpy_l(arg1, NULL, arg3, arg4);
+void test___strncpy_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strncpy_l(arg1, arg2, arg3, x);
 }
 
-void test___tcsncpy_l__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    _tcsncpy_l(arg1, x, arg3, arg4);
+void test___wcsncpy_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _wcsncpy_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tcsncpy_l__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    _tcsncpy_l(arg1, arg2, !x, arg4);
+void test___wcsncpy_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _wcsncpy_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test___tcsncpy_l__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _tcsncpy_l(arg1, arg2, x, arg4);
+void test___wcsncpy_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsncpy_l(NULL, arg2, arg3, arg4);
 }
 
-void test___tcsncpy_l__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _tcsncpy_l(arg1, arg2, arg3, x);
+void test___wcsncpy_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsncpy_l(arg1, NULL, arg3, arg4);
 }
 
-void test___localtime32_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _localtime32_s(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___wcsncpy_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsncpy_l(arg1, x, arg3, arg4);
 }
 
-void test___localtime32_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _localtime32_s(p, arg2);
-    // cppcheck-suppress memleak
+void test___wcsncpy_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _wcsncpy_l(arg1, arg2, !x, arg4);
 }
 
-void test___localtime32_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _localtime32_s(NULL, arg2);
+void test___wcsncpy_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsncpy_l(arg1, arg2, x, arg4);
 }
 
-void test___localtime32_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _localtime32_s(arg1, NULL);
+void test___wcsncpy_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsncpy_l(arg1, arg2, arg3, x);
 }
 
-void test___localtime64_s__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _localtime64_s(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbsncpy_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _mbsncpy_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___localtime64_s__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _localtime64_s(p, arg2);
-    // cppcheck-suppress memleak
+void test___mbsncpy_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _mbsncpy_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test___localtime64_s__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _localtime64_s(NULL, arg2);
+void test___mbsncpy_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsncpy_l(NULL, arg2, arg3, arg4);
 }
 
-void test___localtime64_s__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    _localtime64_s(arg1, NULL);
+void test___mbsncpy_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsncpy_l(arg1, NULL, arg3, arg4);
 }
 
-void test__CreateDirectory__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateDirectory(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___mbsncpy_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsncpy_l(arg1, x, arg3, arg4);
 }
 
-void test__CreateDirectory__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    CreateDirectory(p, arg2);
-    // cppcheck-suppress memleak
+void test___mbsncpy_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _mbsncpy_l(arg1, arg2, !x, arg4);
 }
 
-void test__CreateDirectory__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateDirectory(x, arg2);
+void test___mbsncpy_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbsncpy_l(arg1, arg2, x, arg4);
 }
 
-void test__CreateDirectory__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateDirectory(arg1, x);
-}
-
-void test__CreateDirectoryA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateDirectoryA(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test___mbsncpy_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbsncpy_l(arg1, arg2, arg3, x);
+}
 
-void test__CreateDirectoryA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    CreateDirectoryA(p, arg2);
-    // cppcheck-suppress memleak
+void test___tcsncpy_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _tcsncpy_l(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateDirectoryA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateDirectoryA(x, arg2);
-}
-
-void test__CreateDirectoryA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateDirectoryA(arg1, x);
-}
-
-void test__CreateDirectoryW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateDirectoryW(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
+void test___tcsncpy_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  _tcsncpy_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
 
-void test__CreateDirectoryW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    CreateDirectoryW(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__CreateDirectoryW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateDirectoryW(x, arg2);
-}
-
-void test__CreateDirectoryW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateDirectoryW(arg1, x);
-}
-
-void test__RemoveDirectory__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RemoveDirectory(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__RemoveDirectory__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RemoveDirectory(p);
-    // cppcheck-suppress memleak
-}
-
-void test__RemoveDirectory__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RemoveDirectory(x);
-}
-
-void test__RemoveDirectoryA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RemoveDirectoryA(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__RemoveDirectoryA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RemoveDirectoryA(p);
-    // cppcheck-suppress memleak
-}
-
-void test__RemoveDirectoryA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RemoveDirectoryA(x);
-}
-
-void test__RemoveDirectoryW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        RemoveDirectoryW(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__RemoveDirectoryW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    RemoveDirectoryW(p);
-    // cppcheck-suppress memleak
-}
-
-void test__RemoveDirectoryW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    RemoveDirectoryW(x);
-}
-
-void test____isascii__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        __isascii(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test____isascii__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    __isascii(p);
-    // cppcheck-suppress memleak
-}
-
-void test____isascii__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    __isascii(x);
-}
-
-void test__iswascii__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        iswascii(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__iswascii__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    iswascii(p);
-    // cppcheck-suppress memleak
-}
-
-void test__iswascii__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    iswascii(x);
-}
-
-void test___getchar__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _getchar();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test___getchar__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _getchar();
-    // cppcheck-suppress memleak
-}
-
-void test___getch_nolock__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _getch_nolock();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test___getch_nolock__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _getch_nolock();
-    // cppcheck-suppress memleak
-}
-
-void test___getwch__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _getwch();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test___getwch__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _getwch();
-    // cppcheck-suppress memleak
-}
-
-void test___getwch_nolock__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _getwch_nolock();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test___getwch_nolock__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    _getwch_nolock();
-    // cppcheck-suppress memleak
-}
-
-void test__Sleep__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        Sleep(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__Sleep__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    Sleep(p);
-    // cppcheck-suppress memleak
-}
-
-void test__Sleep__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    Sleep(!x);
-}
-
-void test__Sleep__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    Sleep(x);
-}
-
-void test__SleepEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SleepEx(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__SleepEx__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SleepEx(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__SleepEx__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    SleepEx(!x, arg2);
-}
-
-void test__SleepEx__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SleepEx(x, arg2);
-}
-
-void test__SleepEx__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SleepEx(arg1, x);
+void test___tcsncpy_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsncpy_l(NULL, arg2, arg3, arg4);
 }
 
-void test__LoadLibrary__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        LoadLibrary(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__LoadLibrary__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    LoadLibrary(NULL);
+void test___tcsncpy_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsncpy_l(arg1, NULL, arg3, arg4);
 }
 
-void test__LoadLibrary__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    LoadLibrary(x);
+void test___tcsncpy_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsncpy_l(arg1, x, arg3, arg4);
 }
 
-void test__LoadLibraryA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        LoadLibraryA(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tcsncpy_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _tcsncpy_l(arg1, arg2, !x, arg4);
 }
 
-void test__LoadLibraryA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    LoadLibraryA(NULL);
+void test___tcsncpy_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcsncpy_l(arg1, arg2, x, arg4);
 }
 
-void test__LoadLibraryA__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    LoadLibraryA(x);
+void test___tcsncpy_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcsncpy_l(arg1, arg2, arg3, x);
 }
 
-void test__LoadLibraryW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        LoadLibraryW(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___localtime32_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _localtime32_s(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__LoadLibraryW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    LoadLibraryW(NULL);
+void test___localtime32_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  _localtime32_s(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__LoadLibraryW__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    LoadLibraryW(x);
+void test___localtime32_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _localtime32_s(NULL, arg2);
 }
 
-void test__LoadLibraryEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        LoadLibraryEx(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___localtime32_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _localtime32_s(arg1, NULL);
 }
 
-void test__LoadLibraryEx__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    LoadLibraryEx(x, arg2, arg3);
-}
+void test___localtime64_s__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _localtime64_s(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__LoadLibraryEx__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    LoadLibraryEx(arg1, arg2, x);
+void test___localtime64_s__leakignore() {
+  char *p = malloc(10); *p=0;
+  _localtime64_s(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__LoadLibraryExA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        LoadLibraryExA(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___localtime64_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _localtime64_s(NULL, arg2);
 }
 
-void test__LoadLibraryExA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    LoadLibraryExA(x, arg2, arg3);
+void test___localtime64_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _localtime64_s(arg1, NULL);
 }
 
-void test__LoadLibraryExA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    LoadLibraryExA(arg1, arg2, x);
-}
+void test__CreateDirectory__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateDirectory(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__LoadLibraryExW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        LoadLibraryExW(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateDirectory__leakignore() {
+  char *p = malloc(10); *p=0;
+  CreateDirectory(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__LoadLibraryExW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    LoadLibraryExW(x, arg2, arg3);
+void test__CreateDirectory__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateDirectory(x, arg2);
 }
 
-void test__LoadLibraryExW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    LoadLibraryExW(arg1, arg2, x);
+void test__CreateDirectory__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateDirectory(arg1, x);
 }
 
-void test__GetModuleHandle__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = GetModuleHandle(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateDirectoryA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateDirectoryA(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetModuleHandle__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    GetModuleHandle(arg1);
+void test__CreateDirectoryA__leakignore() {
+  char *p = malloc(10); *p=0;
+  CreateDirectoryA(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__GetModuleHandle__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = GetModuleHandle(p);
-    // cppcheck-suppress memleak
+void test__CreateDirectoryA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateDirectoryA(x, arg2);
 }
-
-void test__GetModuleHandle__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = GetModuleHandle(x);
+
+void test__CreateDirectoryA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateDirectoryA(arg1, x);
+}
+
+void test__CreateDirectoryW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateDirectoryW(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateDirectoryW__leakignore() {
+  char *p = malloc(10); *p=0;
+  CreateDirectoryW(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__GetModuleHandleA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = GetModuleHandleA(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateDirectoryW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateDirectoryW(x, arg2);
 }
-
-void test__GetModuleHandleA__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    GetModuleHandleA(arg1);
+
+void test__CreateDirectoryW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateDirectoryW(arg1, x);
 }
 
-void test__GetModuleHandleA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = GetModuleHandleA(p);
-    // cppcheck-suppress memleak
+void test__RemoveDirectory__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RemoveDirectory(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetModuleHandleA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = GetModuleHandleA(x);
+void test__RemoveDirectory__leakignore() {
+  char *p = malloc(10); *p=0;
+  RemoveDirectory(p);
+  // cppcheck-suppress memleak
 }
 
-void test__GetModuleHandleW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = GetModuleHandleW(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RemoveDirectory__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RemoveDirectory(x);
 }
 
-void test__GetModuleHandleW__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    GetModuleHandleW(arg1);
+void test__RemoveDirectoryA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RemoveDirectoryA(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetModuleHandleW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = GetModuleHandleW(p);
-    // cppcheck-suppress memleak
+void test__RemoveDirectoryA__leakignore() {
+  char *p = malloc(10); *p=0;
+  RemoveDirectoryA(p);
+  // cppcheck-suppress memleak
 }
 
-void test__GetModuleHandleW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = GetModuleHandleW(x);
+void test__RemoveDirectoryA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RemoveDirectoryA(x);
 }
 
-void test__GetModuleHandleEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetModuleHandleEx(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__RemoveDirectoryW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; RemoveDirectoryW(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetModuleHandleEx__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetModuleHandleEx(x, arg2, arg3);
+void test__RemoveDirectoryW__leakignore() {
+  char *p = malloc(10); *p=0;
+  RemoveDirectoryW(p);
+  // cppcheck-suppress memleak
 }
 
-void test__GetModuleHandleEx__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetModuleHandleEx(arg1, x, arg3);
+void test__RemoveDirectoryW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RemoveDirectoryW(x);
 }
 
-void test__GetModuleHandleEx__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetModuleHandleEx(arg1, arg2, NULL);
+void test____isascii__noreturn() {
+  int x = 1;
+  if (cond) { x=100; __isascii(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetModuleHandleExA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetModuleHandleExA(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test____isascii__leakignore() {
+  char *p = malloc(10); *p=0;
+  __isascii(p);
+  // cppcheck-suppress memleak
 }
 
-void test__GetModuleHandleExA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetModuleHandleExA(x, arg2, arg3);
+void test____isascii__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  __isascii(x);
 }
 
-void test__GetModuleHandleExA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetModuleHandleExA(arg1, x, arg3);
+void test__iswascii__noreturn() {
+  int x = 1;
+  if (cond) { x=100; iswascii(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetModuleHandleExA__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetModuleHandleExA(arg1, arg2, NULL);
+void test__iswascii__leakignore() {
+  char *p = malloc(10); *p=0;
+  iswascii(p);
+  // cppcheck-suppress memleak
 }
 
-void test__GetModuleHandleExW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetModuleHandleExW(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__iswascii__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  iswascii(x);
 }
 
-void test__GetModuleHandleExW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetModuleHandleExW(x, arg2, arg3);
+void test___getchar__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _getchar(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetModuleHandleExW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetModuleHandleExW(arg1, x, arg3);
+void test___getchar__leakignore() {
+  char *p = malloc(10); *p=0;
+  _getchar();
+  // cppcheck-suppress memleak
 }
 
-void test__GetModuleHandleExW__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetModuleHandleExW(arg1, arg2, NULL);
+void test___getch_nolock__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _getch_nolock(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__FreeLibrary__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        FreeLibrary(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___getch_nolock__leakignore() {
+  char *p = malloc(10); *p=0;
+  _getch_nolock();
+  // cppcheck-suppress memleak
 }
 
-void test__FreeLibrary__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    FreeLibrary(!x);
+void test___getwch__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _getwch(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__FreeLibrary__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    FreeLibrary(x);
+void test___getwch__leakignore() {
+  char *p = malloc(10); *p=0;
+  _getwch();
+  // cppcheck-suppress memleak
 }
 
-void test__FreeLibraryAndExitThread__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        FreeLibraryAndExitThread(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___getwch_nolock__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _getwch_nolock(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__FreeLibraryAndExitThread__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    FreeLibraryAndExitThread(!x, arg2);
+void test___getwch_nolock__leakignore() {
+  char *p = malloc(10); *p=0;
+  _getwch_nolock();
+  // cppcheck-suppress memleak
 }
 
-void test__FreeLibraryAndExitThread__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    FreeLibraryAndExitThread(x, arg2);
+void test__Sleep__noreturn() {
+  int x = 1;
+  if (cond) { x=100; Sleep(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__FreeLibraryAndExitThread__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    FreeLibraryAndExitThread(arg1, !x);
+void test__Sleep__leakignore() {
+  char *p = malloc(10); *p=0;
+  Sleep(p);
+  // cppcheck-suppress memleak
 }
 
-void test__FreeLibraryAndExitThread__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    FreeLibraryAndExitThread(arg1, x);
+void test__Sleep__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  Sleep(!x);
 }
 
-void test__GetProcAddress__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = GetProcAddress(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__Sleep__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  Sleep(x);
 }
 
-void test__GetProcAddress__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    GetProcAddress(arg1, arg2);
+void test__SleepEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SleepEx(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetProcAddress__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = GetProcAddress(p, arg2);
-    // cppcheck-suppress memleak
+void test__SleepEx__leakignore() {
+  char *p = malloc(10); *p=0;
+  SleepEx(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__GetProcAddress__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = GetProcAddress(!x, arg2);
+void test__SleepEx__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  SleepEx(!x, arg2);
 }
 
-void test__GetProcAddress__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = GetProcAddress(NULL, arg2);
+void test__SleepEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SleepEx(x, arg2);
 }
 
-void test__GetProcAddress__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = GetProcAddress(x, arg2);
+void test__SleepEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SleepEx(arg1, x);
 }
 
-void test__GetProcAddress__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = GetProcAddress(arg1, x);
+void test__LoadLibrary__noreturn() {
+  int x = 1;
+  if (cond) { x=100; LoadLibrary(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateEvent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateEvent(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__LoadLibrary__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  LoadLibrary(NULL);
 }
 
-void test__CreateEvent__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEvent(!x, arg2, arg3, arg4);
+void test__LoadLibrary__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  LoadLibrary(x);
 }
 
-void test__CreateEvent__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEvent(x, arg2, arg3, arg4);
+void test__LoadLibraryA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; LoadLibraryA(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateEvent__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEvent(arg1, x, arg3, arg4);
+void test__LoadLibraryA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  LoadLibraryA(NULL);
 }
 
-void test__CreateEvent__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEvent(arg1, arg2, x, arg4);
+void test__LoadLibraryA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  LoadLibraryA(x);
 }
 
-void test__CreateEvent__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEvent(arg1, arg2, arg3, !x);
+void test__LoadLibraryW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; LoadLibraryW(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateEvent__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEvent(arg1, arg2, arg3, x);
+void test__LoadLibraryW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  LoadLibraryW(NULL);
 }
 
-void test__CreateEventA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateEventA(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__LoadLibraryW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  LoadLibraryW(x);
 }
 
-void test__CreateEventA__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventA(!x, arg2, arg3, arg4);
+void test__LoadLibraryEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; LoadLibraryEx(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateEventA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventA(x, arg2, arg3, arg4);
+void test__LoadLibraryEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  LoadLibraryEx(x, arg2, arg3);
 }
 
-void test__CreateEventA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventA(arg1, x, arg3, arg4);
+void test__LoadLibraryEx__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  LoadLibraryEx(arg1, arg2, x);
 }
 
-void test__CreateEventA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventA(arg1, arg2, x, arg4);
+void test__LoadLibraryExA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; LoadLibraryExA(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateEventA__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventA(arg1, arg2, arg3, !x);
+void test__LoadLibraryExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  LoadLibraryExA(x, arg2, arg3);
 }
 
-void test__CreateEventA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventA(arg1, arg2, arg3, x);
+void test__LoadLibraryExA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  LoadLibraryExA(arg1, arg2, x);
 }
 
-void test__CreateEventW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateEventW(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__LoadLibraryExW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; LoadLibraryExW(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateEventW__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventW(!x, arg2, arg3, arg4);
+void test__LoadLibraryExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  LoadLibraryExW(x, arg2, arg3);
 }
 
-void test__CreateEventW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventW(x, arg2, arg3, arg4);
+void test__LoadLibraryExW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  LoadLibraryExW(arg1, arg2, x);
 }
 
-void test__CreateEventW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventW(arg1, x, arg3, arg4);
+void test__GetModuleHandle__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = GetModuleHandle(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateEventW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventW(arg1, arg2, x, arg4);
+void test__GetModuleHandle__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetModuleHandle(arg1);
 }
 
-void test__CreateEventW__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventW(arg1, arg2, arg3, !x);
+void test__GetModuleHandle__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = GetModuleHandle(p);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateEventW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventW(arg1, arg2, arg3, x);
+void test__GetModuleHandle__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetModuleHandle(x);
 }
 
-void test__CreateEventEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateEventEx(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetModuleHandleA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = GetModuleHandleA(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateEventEx__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventEx(!x, arg2, arg3, arg4);
+void test__GetModuleHandleA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetModuleHandleA(arg1);
 }
 
-void test__CreateEventEx__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventEx(x, arg2, arg3, arg4);
+void test__GetModuleHandleA__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = GetModuleHandleA(p);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateEventEx__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventEx(arg1, !x, arg3, arg4);
+void test__GetModuleHandleA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetModuleHandleA(x);
 }
 
-void test__CreateEventEx__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventEx(arg1, x, arg3, arg4);
+void test__GetModuleHandleW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = GetModuleHandleW(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateEventEx__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventEx(arg1, arg2, !x, arg4);
+void test__GetModuleHandleW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetModuleHandleW(arg1);
 }
 
-void test__CreateEventEx__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventEx(arg1, arg2, x, arg4);
+void test__GetModuleHandleW__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = GetModuleHandleW(p);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateEventEx__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventEx(arg1, arg2, arg3, !x);
+void test__GetModuleHandleW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetModuleHandleW(x);
 }
 
-void test__CreateEventEx__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventEx(arg1, arg2, arg3, x);
+void test__GetModuleHandleEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetModuleHandleEx(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateEventExA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateEventExA(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetModuleHandleEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetModuleHandleEx(x, arg2, arg3);
 }
 
-void test__CreateEventExA__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventExA(!x, arg2, arg3, arg4);
+void test__GetModuleHandleEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetModuleHandleEx(arg1, x, arg3);
 }
 
-void test__CreateEventExA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventExA(x, arg2, arg3, arg4);
+void test__GetModuleHandleEx__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetModuleHandleEx(arg1, arg2, NULL);
 }
 
-void test__CreateEventExA__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventExA(arg1, !x, arg3, arg4);
+void test__GetModuleHandleExA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetModuleHandleExA(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateEventExA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventExA(arg1, x, arg3, arg4);
+void test__GetModuleHandleExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetModuleHandleExA(x, arg2, arg3);
 }
 
-void test__CreateEventExA__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventExA(arg1, arg2, !x, arg4);
+void test__GetModuleHandleExA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetModuleHandleExA(arg1, x, arg3);
 }
 
-void test__CreateEventExA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventExA(arg1, arg2, x, arg4);
+void test__GetModuleHandleExA__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetModuleHandleExA(arg1, arg2, NULL);
 }
 
-void test__CreateEventExA__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventExA(arg1, arg2, arg3, !x);
+void test__GetModuleHandleExW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetModuleHandleExW(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateEventExA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventExA(arg1, arg2, arg3, x);
+void test__GetModuleHandleExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetModuleHandleExW(x, arg2, arg3);
 }
 
-void test__CreateEventExW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateEventExW(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetModuleHandleExW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetModuleHandleExW(arg1, x, arg3);
 }
 
-void test__CreateEventExW__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventExW(!x, arg2, arg3, arg4);
+void test__GetModuleHandleExW__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetModuleHandleExW(arg1, arg2, NULL);
 }
 
-void test__CreateEventExW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventExW(x, arg2, arg3, arg4);
+void test__FreeLibrary__noreturn() {
+  int x = 1;
+  if (cond) { x=100; FreeLibrary(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateEventExW__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventExW(arg1, !x, arg3, arg4);
+void test__FreeLibrary__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  FreeLibrary(!x);
 }
 
-void test__CreateEventExW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventExW(arg1, x, arg3, arg4);
+void test__FreeLibrary__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  FreeLibrary(x);
 }
 
-void test__CreateEventExW__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventExW(arg1, arg2, !x, arg4);
+void test__FreeLibraryAndExitThread__noreturn() {
+  int x = 1;
+  if (cond) { x=100; FreeLibraryAndExitThread(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateEventExW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventExW(arg1, arg2, x, arg4);
+void test__FreeLibraryAndExitThread__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  FreeLibraryAndExitThread(!x, arg2);
 }
 
-void test__CreateEventExW__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateEventExW(arg1, arg2, arg3, !x);
+void test__FreeLibraryAndExitThread__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  FreeLibraryAndExitThread(x, arg2);
 }
 
-void test__CreateEventExW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateEventExW(arg1, arg2, arg3, x);
+void test__FreeLibraryAndExitThread__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  FreeLibraryAndExitThread(arg1, !x);
 }
 
-void test__OpenEvent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        OpenEvent(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__FreeLibraryAndExitThread__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  FreeLibraryAndExitThread(arg1, x);
 }
 
-void test__OpenEvent__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    OpenEvent(!x, arg2, arg3);
+void test__GetProcAddress__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = GetProcAddress(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__OpenEvent__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenEvent(x, arg2, arg3);
+void test__GetProcAddress__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetProcAddress(arg1, arg2);
 }
 
-void test__OpenEvent__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenEvent(arg1, x, arg3);
+void test__GetProcAddress__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = GetProcAddress(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__OpenEvent__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    OpenEvent(arg1, arg2, NULL);
+void test__GetProcAddress__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = GetProcAddress(!x, arg2);
 }
 
-void test__OpenEvent__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    OpenEvent(arg1, arg2, x);
+void test__GetProcAddress__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetProcAddress(NULL, arg2);
 }
 
-void test__OpenEventA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        OpenEventA(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetProcAddress__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetProcAddress(x, arg2);
 }
 
-void test__OpenEventA__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    OpenEventA(!x, arg2, arg3);
+void test__GetProcAddress__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetProcAddress(arg1, x);
 }
 
-void test__OpenEventA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenEventA(x, arg2, arg3);
+void test__CreateEvent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateEvent(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__OpenEventA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenEventA(arg1, x, arg3);
+void test__CreateEvent__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEvent(!x, arg2, arg3, arg4);
 }
 
-void test__OpenEventA__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    OpenEventA(arg1, arg2, NULL);
+void test__CreateEvent__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEvent(x, arg2, arg3, arg4);
 }
 
-void test__OpenEventA__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    OpenEventA(arg1, arg2, x);
+void test__CreateEvent__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEvent(arg1, x, arg3, arg4);
 }
 
-void test__OpenEventW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        OpenEventW(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateEvent__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEvent(arg1, arg2, x, arg4);
 }
 
-void test__OpenEventW__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    OpenEventW(!x, arg2, arg3);
+void test__CreateEvent__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEvent(arg1, arg2, arg3, !x);
 }
 
-void test__OpenEventW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenEventW(x, arg2, arg3);
+void test__CreateEvent__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEvent(arg1, arg2, arg3, x);
 }
 
-void test__OpenEventW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenEventW(arg1, x, arg3);
+void test__CreateEventA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateEventA(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__OpenEventW__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    OpenEventW(arg1, arg2, NULL);
+void test__CreateEventA__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventA(!x, arg2, arg3, arg4);
 }
 
-void test__OpenEventW__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    OpenEventW(arg1, arg2, x);
+void test__CreateEventA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventA(x, arg2, arg3, arg4);
 }
 
-void test__PulseEvent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        PulseEvent(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateEventA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventA(arg1, x, arg3, arg4);
 }
 
-void test__PulseEvent__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    PulseEvent(p);
-    // cppcheck-suppress memleak
+void test__CreateEventA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventA(arg1, arg2, x, arg4);
 }
 
-void test__PulseEvent__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    PulseEvent(NULL);
+void test__CreateEventA__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventA(arg1, arg2, arg3, !x);
 }
 
-void test__PulseEvent__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    PulseEvent(x);
+void test__CreateEventA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventA(arg1, arg2, arg3, x);
 }
 
-void test__ResetEvent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ResetEvent(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateEventW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateEventW(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ResetEvent__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ResetEvent(p);
-    // cppcheck-suppress memleak
+void test__CreateEventW__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventW(!x, arg2, arg3, arg4);
 }
 
-void test__ResetEvent__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ResetEvent(NULL);
+void test__CreateEventW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventW(x, arg2, arg3, arg4);
 }
 
-void test__ResetEvent__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    ResetEvent(x);
+void test__CreateEventW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventW(arg1, x, arg3, arg4);
 }
 
-void test__SetEvent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetEvent(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateEventW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventW(arg1, arg2, x, arg4);
 }
 
-void test__SetEvent__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetEvent(p);
-    // cppcheck-suppress memleak
+void test__CreateEventW__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventW(arg1, arg2, arg3, !x);
 }
 
-void test__SetEvent__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SetEvent(NULL);
+void test__CreateEventW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventW(arg1, arg2, arg3, x);
 }
 
-void test__SetEvent__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    SetEvent(x);
+void test__CreateEventEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateEventEx(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__InitializeCriticalSection__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        InitializeCriticalSection(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateEventEx__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventEx(!x, arg2, arg3, arg4);
 }
 
-void test__InitializeCriticalSection__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    InitializeCriticalSection(!x);
+void test__CreateEventEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventEx(x, arg2, arg3, arg4);
 }
 
-void test__InitializeCriticalSection__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    InitializeCriticalSection(NULL);
+void test__CreateEventEx__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventEx(arg1, !x, arg3, arg4);
 }
 
-void test__InitializeCriticalSectionAndSpinCount__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        InitializeCriticalSectionAndSpinCount(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateEventEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventEx(arg1, x, arg3, arg4);
 }
 
-void test__InitializeCriticalSectionAndSpinCount__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    InitializeCriticalSectionAndSpinCount(!x, arg2);
+void test__CreateEventEx__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventEx(arg1, arg2, !x, arg4);
 }
 
-void test__InitializeCriticalSectionAndSpinCount__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    InitializeCriticalSectionAndSpinCount(NULL, arg2);
+void test__CreateEventEx__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventEx(arg1, arg2, x, arg4);
 }
 
-void test__InitializeCriticalSectionAndSpinCount__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    InitializeCriticalSectionAndSpinCount(arg1, !x);
+void test__CreateEventEx__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventEx(arg1, arg2, arg3, !x);
 }
 
-void test__InitializeCriticalSectionAndSpinCount__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    InitializeCriticalSectionAndSpinCount(arg1, x);
+void test__CreateEventEx__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventEx(arg1, arg2, arg3, x);
 }
 
-void test__InitializeCriticalSectionEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        InitializeCriticalSectionEx(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateEventExA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateEventExA(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__InitializeCriticalSectionEx__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    InitializeCriticalSectionEx(!x, arg2, arg3);
+void test__CreateEventExA__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExA(!x, arg2, arg3, arg4);
 }
 
-void test__InitializeCriticalSectionEx__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    InitializeCriticalSectionEx(NULL, arg2, arg3);
+void test__CreateEventExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExA(x, arg2, arg3, arg4);
 }
 
-void test__InitializeCriticalSectionEx__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    InitializeCriticalSectionEx(arg1, !x, arg3);
+void test__CreateEventExA__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExA(arg1, !x, arg3, arg4);
 }
 
-void test__InitializeCriticalSectionEx__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    InitializeCriticalSectionEx(arg1, x, arg3);
+void test__CreateEventExA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExA(arg1, x, arg3, arg4);
 }
 
-void test__InitializeCriticalSectionEx__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    InitializeCriticalSectionEx(arg1, arg2, !x);
+void test__CreateEventExA__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExA(arg1, arg2, !x, arg4);
 }
 
-void test__InitializeCriticalSectionEx__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    InitializeCriticalSectionEx(arg1, arg2, x);
+void test__CreateEventExA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExA(arg1, arg2, x, arg4);
 }
 
-void test__SetCriticalSectionSpinCount__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetCriticalSectionSpinCount(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateEventExA__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExA(arg1, arg2, arg3, !x);
 }
 
-void test__SetCriticalSectionSpinCount__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetCriticalSectionSpinCount(p, arg2);
-    // cppcheck-suppress memleak
+void test__CreateEventExA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExA(arg1, arg2, arg3, x);
 }
 
-void test__SetCriticalSectionSpinCount__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    SetCriticalSectionSpinCount(!x, arg2);
+void test__CreateEventExW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateEventExW(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__SetCriticalSectionSpinCount__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    SetCriticalSectionSpinCount(NULL, arg2);
+void test__CreateEventExW__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExW(!x, arg2, arg3, arg4);
 }
 
-void test__SetCriticalSectionSpinCount__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    SetCriticalSectionSpinCount(arg1, !x);
+void test__CreateEventExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExW(x, arg2, arg3, arg4);
 }
 
-void test__SetCriticalSectionSpinCount__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetCriticalSectionSpinCount(arg1, x);
+void test__CreateEventExW__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExW(arg1, !x, arg3, arg4);
 }
 
-void test__DeleteCriticalSection__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        DeleteCriticalSection(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateEventExW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExW(arg1, x, arg3, arg4);
 }
 
-void test__DeleteCriticalSection__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    DeleteCriticalSection(!x);
+void test__CreateEventExW__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExW(arg1, arg2, !x, arg4);
 }
 
-void test__DeleteCriticalSection__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    DeleteCriticalSection(NULL);
+void test__CreateEventExW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExW(arg1, arg2, x, arg4);
 }
 
-void test__DeleteCriticalSection__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    DeleteCriticalSection(x);
+void test__CreateEventExW__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExW(arg1, arg2, arg3, !x);
 }
 
-void test__EnterCriticalSection__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        EnterCriticalSection(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateEventExW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExW(arg1, arg2, arg3, x);
 }
 
-void test__EnterCriticalSection__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    EnterCriticalSection(p);
-    // cppcheck-suppress memleak
+void test__OpenEvent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; OpenEvent(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__EnterCriticalSection__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    EnterCriticalSection(!x);
+void test__OpenEvent__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenEvent(!x, arg2, arg3);
 }
 
-void test__EnterCriticalSection__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    EnterCriticalSection(NULL);
+void test__OpenEvent__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenEvent(x, arg2, arg3);
 }
 
-void test__EnterCriticalSection__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    EnterCriticalSection(x);
+void test__OpenEvent__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenEvent(arg1, x, arg3);
 }
 
-void test__TryEnterCriticalSection__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        TryEnterCriticalSection(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__OpenEvent__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenEvent(arg1, arg2, NULL);
 }
 
-void test__TryEnterCriticalSection__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    TryEnterCriticalSection(p);
-    // cppcheck-suppress memleak
+void test__OpenEvent__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenEvent(arg1, arg2, x);
 }
 
-void test__TryEnterCriticalSection__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    TryEnterCriticalSection(!x);
+void test__OpenEventA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; OpenEventA(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__TryEnterCriticalSection__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    TryEnterCriticalSection(NULL);
+void test__OpenEventA__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenEventA(!x, arg2, arg3);
 }
 
-void test__TryEnterCriticalSection__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    TryEnterCriticalSection(x);
+void test__OpenEventA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenEventA(x, arg2, arg3);
 }
 
-void test__LeaveCriticalSection__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        LeaveCriticalSection(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__OpenEventA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenEventA(arg1, x, arg3);
 }
 
-void test__LeaveCriticalSection__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    LeaveCriticalSection(p);
-    // cppcheck-suppress memleak
+void test__OpenEventA__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenEventA(arg1, arg2, NULL);
 }
 
-void test__LeaveCriticalSection__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    LeaveCriticalSection(!x);
+void test__OpenEventA__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenEventA(arg1, arg2, x);
 }
 
-void test__LeaveCriticalSection__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    LeaveCriticalSection(NULL);
+void test__OpenEventW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; OpenEventW(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__LeaveCriticalSection__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    LeaveCriticalSection(x);
+void test__OpenEventW__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenEventW(!x, arg2, arg3);
 }
 
-void test__lstrcat__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        lstrcat(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__OpenEventW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenEventW(x, arg2, arg3);
 }
 
-void test__lstrcat__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    lstrcat(p, arg2);
-    // cppcheck-suppress memleak
+void test__OpenEventW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenEventW(arg1, x, arg3);
 }
 
-void test__lstrcat__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    lstrcat(NULL, arg2);
+void test__OpenEventW__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenEventW(arg1, arg2, NULL);
 }
 
-void test__lstrcat__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    lstrcat(x, arg2);
+void test__OpenEventW__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenEventW(arg1, arg2, x);
 }
 
-void test__lstrcat__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    lstrcat(arg1, NULL);
+void test__PulseEvent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; PulseEvent(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__lstrcat__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    lstrcat(arg1, x);
+void test__PulseEvent__leakignore() {
+  char *p = malloc(10); *p=0;
+  PulseEvent(p);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateSemaphore__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateSemaphore(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__PulseEvent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  PulseEvent(NULL);
 }
 
-void test__CreateSemaphore__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphore(x, arg2, arg3, arg4);
+void test__PulseEvent__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  PulseEvent(x);
 }
 
-void test__CreateSemaphore__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphore(arg1, x, arg3, arg4);
+void test__ResetEvent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ResetEvent(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateSemaphore__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphore(arg1, arg2, x, arg4);
+void test__ResetEvent__leakignore() {
+  char *p = malloc(10); *p=0;
+  ResetEvent(p);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateSemaphore__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateSemaphore(arg1, arg2, arg3, !x);
+void test__ResetEvent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  ResetEvent(NULL);
 }
 
-void test__CreateSemaphore__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphore(arg1, arg2, arg3, x);
+void test__ResetEvent__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ResetEvent(x);
 }
 
-void test__CreateSemaphoreA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateSemaphoreA(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SetEvent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetEvent(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateSemaphoreA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreA(x, arg2, arg3, arg4);
+void test__SetEvent__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetEvent(p);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateSemaphoreA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreA(arg1, x, arg3, arg4);
+void test__SetEvent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SetEvent(NULL);
 }
 
-void test__CreateSemaphoreA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreA(arg1, arg2, x, arg4);
+void test__SetEvent__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetEvent(x);
 }
 
-void test__CreateSemaphoreA__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateSemaphoreA(arg1, arg2, arg3, !x);
+void test__InitializeCriticalSection__noreturn() {
+  int x = 1;
+  if (cond) { x=100; InitializeCriticalSection(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateSemaphoreA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreA(arg1, arg2, arg3, x);
+void test__InitializeCriticalSection__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  InitializeCriticalSection(!x);
 }
 
-void test__CreateSemaphoreW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateSemaphoreW(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__InitializeCriticalSection__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  InitializeCriticalSection(NULL);
 }
 
-void test__CreateSemaphoreW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreW(x, arg2, arg3, arg4);
+void test__InitializeCriticalSectionAndSpinCount__noreturn() {
+  int x = 1;
+  if (cond) { x=100; InitializeCriticalSectionAndSpinCount(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateSemaphoreW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreW(arg1, x, arg3, arg4);
+void test__InitializeCriticalSectionAndSpinCount__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  InitializeCriticalSectionAndSpinCount(!x, arg2);
 }
 
-void test__CreateSemaphoreW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreW(arg1, arg2, x, arg4);
+void test__InitializeCriticalSectionAndSpinCount__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  InitializeCriticalSectionAndSpinCount(NULL, arg2);
 }
 
-void test__CreateSemaphoreW__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateSemaphoreW(arg1, arg2, arg3, !x);
+void test__InitializeCriticalSectionAndSpinCount__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  InitializeCriticalSectionAndSpinCount(arg1, !x);
 }
 
-void test__CreateSemaphoreW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreW(arg1, arg2, arg3, x);
+void test__InitializeCriticalSectionAndSpinCount__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  InitializeCriticalSectionAndSpinCount(arg1, x);
 }
 
-void test__CreateSemaphoreEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateSemaphoreEx(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__InitializeCriticalSectionEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; InitializeCriticalSectionEx(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateSemaphoreEx__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreEx(x, arg2, arg3, arg4, arg5, arg6);
+void test__InitializeCriticalSectionEx__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  InitializeCriticalSectionEx(!x, arg2, arg3);
 }
 
-void test__CreateSemaphoreEx__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreEx(arg1, x, arg3, arg4, arg5, arg6);
+void test__InitializeCriticalSectionEx__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  InitializeCriticalSectionEx(NULL, arg2, arg3);
 }
 
-void test__CreateSemaphoreEx__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreEx(arg1, arg2, x, arg4, arg5, arg6);
+void test__InitializeCriticalSectionEx__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  InitializeCriticalSectionEx(arg1, !x, arg3);
 }
 
-void test__CreateSemaphoreEx__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateSemaphoreEx(arg1, arg2, arg3, !x, arg5, arg6);
+void test__InitializeCriticalSectionEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  InitializeCriticalSectionEx(arg1, x, arg3);
 }
 
-void test__CreateSemaphoreEx__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreEx(arg1, arg2, arg3, x, arg5, arg6);
+void test__InitializeCriticalSectionEx__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  InitializeCriticalSectionEx(arg1, arg2, !x);
 }
 
-void test__CreateSemaphoreEx__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreEx(arg1, arg2, arg3, arg4, x, arg6);
+void test__InitializeCriticalSectionEx__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  InitializeCriticalSectionEx(arg1, arg2, x);
 }
 
-void test__CreateSemaphoreEx__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreEx(arg1, arg2, arg3, arg4, arg5, x);
+void test__SetCriticalSectionSpinCount__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetCriticalSectionSpinCount(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateSemaphoreExA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateSemaphoreExA(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SetCriticalSectionSpinCount__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetCriticalSectionSpinCount(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateSemaphoreExA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreExA(x, arg2, arg3, arg4, arg5, arg6);
+void test__SetCriticalSectionSpinCount__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  SetCriticalSectionSpinCount(!x, arg2);
 }
 
-void test__CreateSemaphoreExA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreExA(arg1, x, arg3, arg4, arg5, arg6);
+void test__SetCriticalSectionSpinCount__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SetCriticalSectionSpinCount(NULL, arg2);
 }
 
-void test__CreateSemaphoreExA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreExA(arg1, arg2, x, arg4, arg5, arg6);
+void test__SetCriticalSectionSpinCount__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  SetCriticalSectionSpinCount(arg1, !x);
 }
 
-void test__CreateSemaphoreExA__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateSemaphoreExA(arg1, arg2, arg3, !x, arg5, arg6);
+void test__SetCriticalSectionSpinCount__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetCriticalSectionSpinCount(arg1, x);
 }
 
-void test__CreateSemaphoreExA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreExA(arg1, arg2, arg3, x, arg5, arg6);
+void test__DeleteCriticalSection__noreturn() {
+  int x = 1;
+  if (cond) { x=100; DeleteCriticalSection(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateSemaphoreExA__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreExA(arg1, arg2, arg3, arg4, x, arg6);
+void test__DeleteCriticalSection__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  DeleteCriticalSection(!x);
 }
 
-void test__CreateSemaphoreExA__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreExA(arg1, arg2, arg3, arg4, arg5, x);
+void test__DeleteCriticalSection__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DeleteCriticalSection(NULL);
 }
 
-void test__CreateSemaphoreExW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateSemaphoreExW(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__DeleteCriticalSection__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DeleteCriticalSection(x);
 }
 
-void test__CreateSemaphoreExW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreExW(x, arg2, arg3, arg4, arg5, arg6);
+void test__EnterCriticalSection__noreturn() {
+  int x = 1;
+  if (cond) { x=100; EnterCriticalSection(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateSemaphoreExW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreExW(arg1, x, arg3, arg4, arg5, arg6);
+void test__EnterCriticalSection__leakignore() {
+  char *p = malloc(10); *p=0;
+  EnterCriticalSection(p);
+  // cppcheck-suppress memleak
 }
 
-void test__CreateSemaphoreExW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreExW(arg1, arg2, x, arg4, arg5, arg6);
+void test__EnterCriticalSection__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  EnterCriticalSection(!x);
 }
 
-void test__CreateSemaphoreExW__arg4__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateSemaphoreExW(arg1, arg2, arg3, !x, arg5, arg6);
+void test__EnterCriticalSection__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  EnterCriticalSection(NULL);
 }
 
-void test__CreateSemaphoreExW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreExW(arg1, arg2, arg3, x, arg5, arg6);
+void test__EnterCriticalSection__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  EnterCriticalSection(x);
 }
 
-void test__CreateSemaphoreExW__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreExW(arg1, arg2, arg3, arg4, x, arg6);
+void test__TryEnterCriticalSection__noreturn() {
+  int x = 1;
+  if (cond) { x=100; TryEnterCriticalSection(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateSemaphoreExW__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateSemaphoreExW(arg1, arg2, arg3, arg4, arg5, x);
+void test__TryEnterCriticalSection__leakignore() {
+  char *p = malloc(10); *p=0;
+  TryEnterCriticalSection(p);
+  // cppcheck-suppress memleak
 }
 
-void test__OpenSemaphore__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        OpenSemaphore(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__TryEnterCriticalSection__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  TryEnterCriticalSection(!x);
 }
 
-void test__OpenSemaphore__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenSemaphore(x, arg2, arg3);
+void test__TryEnterCriticalSection__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  TryEnterCriticalSection(NULL);
 }
 
-void test__OpenSemaphore__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenSemaphore(arg1, x, arg3);
+void test__TryEnterCriticalSection__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  TryEnterCriticalSection(x);
 }
 
-void test__OpenSemaphore__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    OpenSemaphore(arg1, arg2, !x);
+void test__LeaveCriticalSection__noreturn() {
+  int x = 1;
+  if (cond) { x=100; LeaveCriticalSection(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__OpenSemaphore__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    OpenSemaphore(arg1, arg2, NULL);
+void test__LeaveCriticalSection__leakignore() {
+  char *p = malloc(10); *p=0;
+  LeaveCriticalSection(p);
+  // cppcheck-suppress memleak
 }
 
-void test__OpenSemaphore__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    OpenSemaphore(arg1, arg2, x);
+void test__LeaveCriticalSection__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  LeaveCriticalSection(!x);
 }
 
-void test__OpenSemaphoreA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        OpenSemaphoreA(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__LeaveCriticalSection__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  LeaveCriticalSection(NULL);
 }
 
-void test__OpenSemaphoreA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenSemaphoreA(x, arg2, arg3);
+void test__LeaveCriticalSection__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  LeaveCriticalSection(x);
 }
 
-void test__OpenSemaphoreA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenSemaphoreA(arg1, x, arg3);
+void test__lstrcat__noreturn() {
+  int x = 1;
+  if (cond) { x=100; lstrcat(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__OpenSemaphoreA__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    OpenSemaphoreA(arg1, arg2, !x);
+void test__lstrcat__leakignore() {
+  char *p = malloc(10); *p=0;
+  lstrcat(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__OpenSemaphoreA__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    OpenSemaphoreA(arg1, arg2, NULL);
+void test__lstrcat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  lstrcat(NULL, arg2);
 }
 
-void test__OpenSemaphoreA__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    OpenSemaphoreA(arg1, arg2, x);
+void test__lstrcat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  lstrcat(x, arg2);
 }
 
-void test__OpenSemaphoreW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        OpenSemaphoreW(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__lstrcat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  lstrcat(arg1, NULL);
 }
 
-void test__OpenSemaphoreW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenSemaphoreW(x, arg2, arg3);
+void test__lstrcat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  lstrcat(arg1, x);
 }
 
-void test__OpenSemaphoreW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenSemaphoreW(arg1, x, arg3);
+void test__CreateSemaphore__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateSemaphore(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__OpenSemaphoreW__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    OpenSemaphoreW(arg1, arg2, !x);
+void test__CreateSemaphore__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphore(x, arg2, arg3, arg4);
 }
 
-void test__OpenSemaphoreW__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    OpenSemaphoreW(arg1, arg2, NULL);
+void test__CreateSemaphore__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphore(arg1, x, arg3, arg4);
 }
 
-void test__OpenSemaphoreW__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    OpenSemaphoreW(arg1, arg2, x);
+void test__CreateSemaphore__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphore(arg1, arg2, x, arg4);
 }
 
-void test__ReleaseSemaphore__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ReleaseSemaphore(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateSemaphore__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateSemaphore(arg1, arg2, arg3, !x);
 }
 
-void test__ReleaseSemaphore__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    ReleaseSemaphore(!x, arg2, arg3);
+void test__CreateSemaphore__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphore(arg1, arg2, arg3, x);
 }
 
-void test__ReleaseSemaphore__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ReleaseSemaphore(x, arg2, arg3);
+void test__CreateSemaphoreA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateSemaphoreA(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ReleaseSemaphore__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    ReleaseSemaphore(arg1, !x, arg3);
+void test__CreateSemaphoreA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreA(x, arg2, arg3, arg4);
 }
 
-void test__ReleaseSemaphore__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ReleaseSemaphore(arg1, x, arg3);
+void test__CreateSemaphoreA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreA(arg1, x, arg3, arg4);
 }
 
-void test__ReleaseSemaphore__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    ReleaseSemaphore(arg1, arg2, !x);
+void test__CreateSemaphoreA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreA(arg1, arg2, x, arg4);
 }
 
-void test__ReleaseSemaphore__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ReleaseSemaphore(arg1, arg2, x);
+void test__CreateSemaphoreA__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateSemaphoreA(arg1, arg2, arg3, !x);
 }
 
-void test__CreateMutex__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateMutex(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateSemaphoreA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreA(arg1, arg2, arg3, x);
 }
 
-void test__CreateMutex__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateMutex(!x, arg2, arg3);
+void test__CreateSemaphoreW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateSemaphoreW(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateMutex__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutex(x, arg2, arg3);
+void test__CreateSemaphoreW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreW(x, arg2, arg3, arg4);
 }
 
-void test__CreateMutex__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutex(arg1, x, arg3);
+void test__CreateSemaphoreW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreW(arg1, x, arg3, arg4);
 }
 
-void test__CreateMutex__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateMutex(arg1, arg2, !x);
+void test__CreateSemaphoreW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreW(arg1, arg2, x, arg4);
 }
 
-void test__CreateMutex__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutex(arg1, arg2, x);
+void test__CreateSemaphoreW__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateSemaphoreW(arg1, arg2, arg3, !x);
 }
 
-void test__CreateMutexA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateMutexA(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateSemaphoreW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreW(arg1, arg2, arg3, x);
 }
 
-void test__CreateMutexA__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateMutexA(!x, arg2, arg3);
+void test__CreateSemaphoreEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateSemaphoreEx(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateMutexA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexA(x, arg2, arg3);
+void test__CreateSemaphoreEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreEx(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__CreateMutexA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexA(arg1, x, arg3);
+void test__CreateSemaphoreEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreEx(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__CreateMutexA__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateMutexA(arg1, arg2, !x);
+void test__CreateSemaphoreEx__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreEx(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__CreateMutexA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexA(arg1, arg2, x);
+void test__CreateSemaphoreEx__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateSemaphoreEx(arg1, arg2, arg3, !x, arg5, arg6);
 }
 
-void test__CreateMutexW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateMutexW(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateSemaphoreEx__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreEx(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__CreateMutexW__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateMutexW(!x, arg2, arg3);
+void test__CreateSemaphoreEx__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreEx(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__CreateMutexW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexW(x, arg2, arg3);
+void test__CreateSemaphoreEx__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreEx(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__CreateMutexW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexW(arg1, x, arg3);
+void test__CreateSemaphoreExA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateSemaphoreExA(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateMutexW__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateMutexW(arg1, arg2, !x);
+void test__CreateSemaphoreExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExA(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__CreateMutexW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexW(arg1, arg2, x);
+void test__CreateSemaphoreExA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExA(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__CreateMutexEx__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateMutexEx(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateSemaphoreExA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExA(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__CreateMutexEx__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateMutexEx(!x, arg2, arg3, arg4);
+void test__CreateSemaphoreExA__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateSemaphoreExA(arg1, arg2, arg3, !x, arg5, arg6);
 }
 
-void test__CreateMutexEx__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexEx(x, arg2, arg3, arg4);
+void test__CreateSemaphoreExA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExA(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__CreateMutexEx__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateMutexEx(arg1, !x, arg3, arg4);
+void test__CreateSemaphoreExA__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExA(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__CreateMutexEx__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexEx(arg1, x, arg3, arg4);
+void test__CreateSemaphoreExA__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExA(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__CreateMutexEx__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexEx(arg1, arg2, x, arg4);
+void test__CreateSemaphoreExW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateSemaphoreExW(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateMutexEx__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexEx(arg1, arg2, arg3, x);
+void test__CreateSemaphoreExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExW(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__CreateMutexExA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateMutexExA(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateSemaphoreExW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExW(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__CreateMutexExA__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateMutexExA(!x, arg2, arg3, arg4);
+void test__CreateSemaphoreExW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExW(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__CreateMutexExA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexExA(x, arg2, arg3, arg4);
+void test__CreateSemaphoreExW__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateSemaphoreExW(arg1, arg2, arg3, !x, arg5, arg6);
 }
 
-void test__CreateMutexExA__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateMutexExA(arg1, !x, arg3, arg4);
+void test__CreateSemaphoreExW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExW(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__CreateMutexExA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexExA(arg1, x, arg3, arg4);
+void test__CreateSemaphoreExW__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExW(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__CreateMutexExA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexExA(arg1, arg2, x, arg4);
+void test__CreateSemaphoreExW__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExW(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__CreateMutexExA__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexExA(arg1, arg2, arg3, x);
+void test__OpenSemaphore__noreturn() {
+  int x = 1;
+  if (cond) { x=100; OpenSemaphore(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateMutexExW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        CreateMutexExW(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__OpenSemaphore__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenSemaphore(x, arg2, arg3);
 }
 
-void test__CreateMutexExW__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateMutexExW(!x, arg2, arg3, arg4);
+void test__OpenSemaphore__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenSemaphore(arg1, x, arg3);
 }
 
-void test__CreateMutexExW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexExW(x, arg2, arg3, arg4);
+void test__OpenSemaphore__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenSemaphore(arg1, arg2, !x);
 }
 
-void test__CreateMutexExW__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    CreateMutexExW(arg1, !x, arg3, arg4);
+void test__OpenSemaphore__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenSemaphore(arg1, arg2, NULL);
 }
 
-void test__CreateMutexExW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexExW(arg1, x, arg3, arg4);
+void test__OpenSemaphore__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenSemaphore(arg1, arg2, x);
 }
 
-void test__CreateMutexExW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexExW(arg1, arg2, x, arg4);
+void test__OpenSemaphoreA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; OpenSemaphoreA(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__CreateMutexExW__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    CreateMutexExW(arg1, arg2, arg3, x);
+void test__OpenSemaphoreA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenSemaphoreA(x, arg2, arg3);
 }
 
-void test__OpenMutex__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        OpenMutex(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__OpenSemaphoreA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenSemaphoreA(arg1, x, arg3);
 }
 
-void test__OpenMutex__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenMutex(x, arg2, arg3);
+void test__OpenSemaphoreA__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenSemaphoreA(arg1, arg2, !x);
 }
 
-void test__OpenMutex__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenMutex(arg1, x, arg3);
+void test__OpenSemaphoreA__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenSemaphoreA(arg1, arg2, NULL);
 }
 
-void test__OpenMutex__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    OpenMutex(arg1, arg2, !x);
+void test__OpenSemaphoreA__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenSemaphoreA(arg1, arg2, x);
 }
 
-void test__OpenMutex__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    OpenMutex(arg1, arg2, NULL);
+void test__OpenSemaphoreW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; OpenSemaphoreW(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__OpenMutex__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    OpenMutex(arg1, arg2, x);
+void test__OpenSemaphoreW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenSemaphoreW(x, arg2, arg3);
 }
 
-void test__OpenMutexA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        OpenMutexA(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__OpenSemaphoreW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenSemaphoreW(arg1, x, arg3);
 }
 
-void test__OpenMutexA__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenMutexA(x, arg2, arg3);
+void test__OpenSemaphoreW__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenSemaphoreW(arg1, arg2, !x);
 }
 
-void test__OpenMutexA__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenMutexA(arg1, x, arg3);
+void test__OpenSemaphoreW__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenSemaphoreW(arg1, arg2, NULL);
 }
 
-void test__OpenMutexA__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    OpenMutexA(arg1, arg2, !x);
+void test__OpenSemaphoreW__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenSemaphoreW(arg1, arg2, x);
 }
 
-void test__OpenMutexA__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    OpenMutexA(arg1, arg2, NULL);
+void test__ReleaseSemaphore__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ReleaseSemaphore(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__OpenMutexA__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    OpenMutexA(arg1, arg2, x);
+void test__ReleaseSemaphore__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  ReleaseSemaphore(!x, arg2, arg3);
 }
 
-void test__OpenMutexW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        OpenMutexW(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ReleaseSemaphore__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ReleaseSemaphore(x, arg2, arg3);
 }
 
-void test__OpenMutexW__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenMutexW(x, arg2, arg3);
+void test__ReleaseSemaphore__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  ReleaseSemaphore(arg1, !x, arg3);
 }
 
-void test__OpenMutexW__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    OpenMutexW(arg1, x, arg3);
+void test__ReleaseSemaphore__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ReleaseSemaphore(arg1, x, arg3);
 }
 
-void test__OpenMutexW__arg3__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    OpenMutexW(arg1, arg2, !x);
+void test__ReleaseSemaphore__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  ReleaseSemaphore(arg1, arg2, !x);
 }
 
-void test__OpenMutexW__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    OpenMutexW(arg1, arg2, NULL);
+void test__ReleaseSemaphore__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ReleaseSemaphore(arg1, arg2, x);
 }
 
-void test__OpenMutexW__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    OpenMutexW(arg1, arg2, x);
+void test__CreateMutex__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateMutex(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ReleaseMutex__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ReleaseMutex(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateMutex__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutex(!x, arg2, arg3);
 }
 
-void test__ReleaseMutex__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ReleaseMutex(p);
-    // cppcheck-suppress memleak
+void test__CreateMutex__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutex(x, arg2, arg3);
 }
 
-void test__ReleaseMutex__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    ReleaseMutex(!x);
+void test__CreateMutex__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutex(arg1, x, arg3);
 }
 
-void test__ReleaseMutex__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ReleaseMutex(x);
+void test__CreateMutex__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutex(arg1, arg2, !x);
 }
 
-void test___malloca__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _malloca(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateMutex__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutex(arg1, arg2, x);
 }
 
-void test___malloca__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _malloca(x);
-}
-
-void test___alloca__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _alloca(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateMutexA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateMutexA(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___alloca__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _alloca(arg1);
+void test__CreateMutexA__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexA(!x, arg2, arg3);
 }
 
-void test___alloca__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _alloca(x);
+void test__CreateMutexA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexA(x, arg2, arg3);
 }
-
-void test___freea__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        _freea(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__CreateMutexA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexA(arg1, x, arg3);
 }
 
-void test___freea__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    _freea(x);
+void test__CreateMutexA__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexA(arg1, arg2, !x);
 }
 
-void test__strlwr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strlwr(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__strlwr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strlwr(NULL);
+void test__CreateMutexA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexA(arg1, arg2, x);
 }
 
-void test__strlwr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strlwr(x);
-}
-
-void test__strupr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        strupr(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__strupr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    strupr(NULL);
-}
-
-void test__strupr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    strupr(x);
-}
-
-void test__GetLocalTime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetLocalTime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__GetLocalTime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetLocalTime(p);
-    // cppcheck-suppress memleak
+void test__CreateMutexW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateMutexW(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetLocalTime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetLocalTime(NULL);
-}
-
-void test__GetSystemTime__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetSystemTime(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__GetSystemTime__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetSystemTime(p);
-    // cppcheck-suppress memleak
-}
-
-void test__GetSystemTime__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetSystemTime(NULL);
-}
-
-void test__GetLastError__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = GetLastError();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateMutexW__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexW(!x, arg2, arg3);
 }
 
-void test__GetLastError__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    GetLastError();
+void test__CreateMutexW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexW(x, arg2, arg3);
 }
 
-void test__SetLastError__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        SetLastError(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__SetLastError__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    SetLastError(p);
-    // cppcheck-suppress memleak
+void test__CreateMutexW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexW(arg1, x, arg3);
 }
 
-void test__SetLastError__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    SetLastError(x);
-}
-
-void test__AllocateAndInitializeSid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        AllocateAndInitializeSid(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateMutexW__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexW(arg1, arg2, !x);
 }
 
-void test__AllocateAndInitializeSid__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    AllocateAndInitializeSid(NULL);
+void test__CreateMutexW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexW(arg1, arg2, x);
 }
 
-void test__AllocateAndInitializeSid__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    AllocateAndInitializeSid(NULL);
+void test__CreateMutexEx__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateMutexEx(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__FreeSid__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        FreeSid(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__FreeSid__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    FreeSid(x);
+void test__CreateMutexEx__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexEx(!x, arg2, arg3, arg4);
 }
 
-void test__HeapAlloc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        HeapAlloc(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateMutexEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexEx(x, arg2, arg3, arg4);
 }
 
-void test__HeapAlloc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    HeapAlloc(x, arg2, arg3);
+void test__CreateMutexEx__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexEx(arg1, !x, arg3, arg4);
 }
 
-void test__HeapAlloc__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    HeapAlloc(arg1, x, arg3);
+void test__CreateMutexEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexEx(arg1, x, arg3, arg4);
 }
 
-void test__HeapAlloc__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    HeapAlloc(arg1, arg2, x);
+void test__CreateMutexEx__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexEx(arg1, arg2, x, arg4);
 }
 
-void test__HeapReAlloc__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        HeapReAlloc(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateMutexEx__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexEx(arg1, arg2, arg3, x);
 }
 
-void test__HeapReAlloc__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    HeapReAlloc(x, arg2, arg3, arg4);
+void test__CreateMutexExA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateMutexExA(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__HeapReAlloc__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    HeapReAlloc(arg1, x, arg3, arg4);
+void test__CreateMutexExA__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexExA(!x, arg2, arg3, arg4);
 }
 
-void test__HeapReAlloc__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    HeapReAlloc(arg1, arg2, NULL, arg4);
+void test__CreateMutexExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExA(x, arg2, arg3, arg4);
 }
 
-void test__HeapReAlloc__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    HeapReAlloc(arg1, arg2, x, arg4);
+void test__CreateMutexExA__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexExA(arg1, !x, arg3, arg4);
 }
 
-void test__HeapReAlloc__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    HeapReAlloc(arg1, arg2, arg3, x);
+void test__CreateMutexExA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExA(arg1, x, arg3, arg4);
 }
 
-void test__HeapFree__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        HeapFree(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateMutexExA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExA(arg1, arg2, x, arg4);
 }
 
-void test__HeapFree__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    HeapFree(x, arg2, arg3);
+void test__CreateMutexExA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExA(arg1, arg2, arg3, x);
 }
 
-void test__HeapFree__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    HeapFree(arg1, x, arg3);
+void test__CreateMutexExW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; CreateMutexExW(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__HeapFree__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    HeapFree(arg1, arg2, NULL);
+void test__CreateMutexExW__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexExW(!x, arg2, arg3, arg4);
 }
 
-void test__HeapFree__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    HeapFree(arg1, arg2, x);
+void test__CreateMutexExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExW(x, arg2, arg3, arg4);
 }
 
-void test__HeapSize__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = HeapSize(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__CreateMutexExW__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexExW(arg1, !x, arg3, arg4);
 }
 
-void test__HeapSize__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    HeapSize(arg1, arg2, arg3);
+void test__CreateMutexExW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExW(arg1, x, arg3, arg4);
 }
 
-void test__HeapSize__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = HeapSize(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__CreateMutexExW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExW(arg1, arg2, x, arg4);
 }
 
-void test__HeapSize__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = HeapSize(x, arg2, arg3);
+void test__CreateMutexExW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExW(arg1, arg2, arg3, x);
 }
 
-void test__HeapSize__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = HeapSize(arg1, x, arg3);
+void test__OpenMutex__noreturn() {
+  int x = 1;
+  if (cond) { x=100; OpenMutex(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__HeapSize__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = HeapSize(arg1, arg2, x);
+void test__OpenMutex__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenMutex(x, arg2, arg3);
 }
 
-void test__HeapValidate__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        HeapValidate(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__OpenMutex__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenMutex(arg1, x, arg3);
 }
 
-void test__HeapValidate__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    HeapValidate(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__OpenMutex__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenMutex(arg1, arg2, !x);
 }
 
-void test__HeapValidate__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    HeapValidate(x, arg2, arg3);
+void test__OpenMutex__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenMutex(arg1, arg2, NULL);
 }
 
-void test__HeapValidate__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    HeapValidate(arg1, x, arg3);
+void test__OpenMutex__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenMutex(arg1, arg2, x);
 }
 
-void test__HeapValidate__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    HeapValidate(arg1, arg2, x);
+void test__OpenMutexA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; OpenMutexA(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetProcessHeap__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = GetProcessHeap();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__OpenMutexA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenMutexA(x, arg2, arg3);
 }
 
-void test__GetProcessHeap__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    GetProcessHeap();
+void test__OpenMutexA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenMutexA(arg1, x, arg3);
 }
 
-void test__GetUserName__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetUserName(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__OpenMutexA__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenMutexA(arg1, arg2, !x);
 }
 
-void test__GetUserName__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetUserName(p, arg2);
-    // cppcheck-suppress memleak
+void test__OpenMutexA__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenMutexA(arg1, arg2, NULL);
 }
 
-void test__GetUserName__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetUserName(arg1, NULL);
+void test__OpenMutexA__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenMutexA(arg1, arg2, x);
 }
 
-void test__GetUserName__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetUserName(arg1, x);
+void test__OpenMutexW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; OpenMutexW(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetUserNameA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetUserNameA(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__OpenMutexW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenMutexW(x, arg2, arg3);
 }
-
-void test__GetUserNameA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetUserNameA(p, arg2);
-    // cppcheck-suppress memleak
+
+void test__OpenMutexW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenMutexW(arg1, x, arg3);
+}
+
+void test__OpenMutexW__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenMutexW(arg1, arg2, !x);
 }
 
-void test__GetUserNameA__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetUserNameA(arg1, NULL);
+void test__OpenMutexW__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenMutexW(arg1, arg2, NULL);
 }
 
-void test__GetUserNameA__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetUserNameA(arg1, x);
+void test__OpenMutexW__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenMutexW(arg1, arg2, x);
 }
 
-void test__GetUserNameW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetUserNameW(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__ReleaseMutex__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ReleaseMutex(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetUserNameW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetUserNameW(p, arg2);
-    // cppcheck-suppress memleak
+void test__ReleaseMutex__leakignore() {
+  char *p = malloc(10); *p=0;
+  ReleaseMutex(p);
+  // cppcheck-suppress memleak
 }
 
-void test__GetUserNameW__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetUserNameW(arg1, NULL);
+void test__ReleaseMutex__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  ReleaseMutex(!x);
 }
 
-void test__GetUserNameW__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    GetUserNameW(arg1, x);
+void test__ReleaseMutex__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ReleaseMutex(x);
 }
 
-void test__GetWindowText__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetWindowText(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___malloca__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _malloca(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetWindowText__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetWindowText(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___malloca__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _malloca(x);
 }
 
-void test__GetWindowText__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetWindowText(NULL, arg2, arg3);
+void test___alloca__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _alloca(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetWindowText__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetWindowText(arg1, NULL, arg3);
+void test___alloca__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _alloca(arg1);
 }
 
-void test__GetWindowText__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetWindowText(arg1, arg2, x);
+void test___alloca__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _alloca(x);
 }
 
-void test__GetWindowTextA__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetWindowTextA(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___freea__noreturn() {
+  int x = 1;
+  if (cond) { x=100; _freea(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetWindowTextA__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetWindowTextA(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test___freea__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _freea(x);
 }
 
-void test__GetWindowTextA__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetWindowTextA(NULL, arg2, arg3);
+void test__strlwr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strlwr(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetWindowTextA__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetWindowTextA(arg1, NULL, arg3);
+void test__strlwr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strlwr(NULL);
 }
 
-void test__GetWindowTextA__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetWindowTextA(arg1, arg2, x);
+void test__strlwr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strlwr(x);
 }
 
-void test__GetWindowTextW__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        GetWindowTextW(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__strupr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; strupr(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetWindowTextW__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    GetWindowTextW(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__strupr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strupr(NULL);
 }
 
-void test__GetWindowTextW__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetWindowTextW(NULL, arg2, arg3);
+void test__strupr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strupr(x);
 }
 
-void test__GetWindowTextW__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    GetWindowTextW(arg1, NULL, arg3);
+void test__GetLocalTime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetLocalTime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__GetWindowTextW__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    GetWindowTextW(arg1, arg2, x);
+void test__GetLocalTime__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetLocalTime(p);
+  // cppcheck-suppress memleak
 }
 
-void test__socket__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        socket(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetLocalTime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetLocalTime(NULL);
 }
 
-void test__socket__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    socket(x, arg2, arg3);
+void test__GetSystemTime__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetSystemTime(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__socket__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    socket(arg1, x, arg3);
+void test__GetSystemTime__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetSystemTime(p);
+  // cppcheck-suppress memleak
 }
 
-void test__socket__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    socket(arg1, arg2, x);
+void test__GetSystemTime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetSystemTime(NULL);
 }
 
-void test__closesocket__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        closesocket(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetLastError__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = GetLastError(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__closesocket__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    closesocket(x);
+void test__GetLastError__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetLastError();
 }
 
-void test__accept__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        accept(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__SetLastError__noreturn() {
+  int x = 1;
+  if (cond) { x=100; SetLastError(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__accept__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    accept(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__SetLastError__leakignore() {
+  char *p = malloc(10); *p=0;
+  SetLastError(p);
+  // cppcheck-suppress memleak
 }
 
-void test__accept__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    accept(x, arg2, arg3);
+void test__SetLastError__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetLastError(x);
 }
 
-void test__accept__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    accept(arg1, x, arg3);
+void test__AllocateAndInitializeSid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; AllocateAndInitializeSid(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__accept__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    accept(arg1, arg2, x);
+void test__AllocateAndInitializeSid__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  AllocateAndInitializeSid(NULL);
 }
 
-void test__bind__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        bind(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__AllocateAndInitializeSid__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  AllocateAndInitializeSid(NULL);
 }
 
-void test__bind__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    bind(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__FreeSid__noreturn() {
+  int x = 1;
+  if (cond) { x=100; FreeSid(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__bind__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    bind(x, arg2, arg3);
+void test__FreeSid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  FreeSid(x);
 }
 
-void test__bind__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    bind(arg1, NULL, arg3);
+void test__HeapAlloc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; HeapAlloc(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__bind__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    bind(arg1, arg2, x);
+void test__HeapAlloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapAlloc(x, arg2, arg3);
 }
 
-void test__connect__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        connect(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__HeapAlloc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapAlloc(arg1, x, arg3);
 }
 
-void test__connect__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    connect(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__HeapAlloc__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapAlloc(arg1, arg2, x);
 }
 
-void test__connect__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    connect(x, arg2, arg3);
+void test__HeapReAlloc__noreturn() {
+  int x = 1;
+  if (cond) { x=100; HeapReAlloc(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__connect__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    connect(arg1, NULL, arg3);
+void test__HeapReAlloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapReAlloc(x, arg2, arg3, arg4);
 }
 
-void test__connect__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    connect(arg1, arg2, x);
+void test__HeapReAlloc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapReAlloc(arg1, x, arg3, arg4);
 }
 
-void test__getpeername__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getpeername(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__HeapReAlloc__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  HeapReAlloc(arg1, arg2, NULL, arg4);
 }
 
-void test__getpeername__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getpeername(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__HeapReAlloc__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  HeapReAlloc(arg1, arg2, x, arg4);
 }
 
-void test__getpeername__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getpeername(x, arg2, arg3);
+void test__HeapReAlloc__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapReAlloc(arg1, arg2, arg3, x);
 }
 
-void test__getpeername__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getpeername(arg1, NULL, arg3);
+void test__HeapFree__noreturn() {
+  int x = 1;
+  if (cond) { x=100; HeapFree(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getpeername__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getpeername(arg1, arg2, NULL);
+void test__HeapFree__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapFree(x, arg2, arg3);
 }
 
-void test__getpeername__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    getpeername(arg1, arg2, x);
+void test__HeapFree__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapFree(arg1, x, arg3);
 }
 
-void test__getsockname__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getsockname(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__HeapFree__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  HeapFree(arg1, arg2, NULL);
 }
 
-void test__getsockname__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getsockname(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__HeapFree__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  HeapFree(arg1, arg2, x);
 }
 
-void test__getsockname__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getsockname(x, arg2, arg3);
+void test__HeapSize__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = HeapSize(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getsockname__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getsockname(arg1, NULL, arg3);
+void test__HeapSize__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  HeapSize(arg1, arg2, arg3);
 }
 
-void test__getsockname__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getsockname(arg1, arg2, NULL);
+void test__HeapSize__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = HeapSize(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__getsockname__arg3__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    getsockname(arg1, arg2, x);
+void test__HeapSize__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = HeapSize(x, arg2, arg3);
 }
 
-void test__getsockopt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        getsockopt(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__HeapSize__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = HeapSize(arg1, x, arg3);
 }
 
-void test__getsockopt__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    getsockopt(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test__HeapSize__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = HeapSize(arg1, arg2, x);
 }
 
-void test__getsockopt__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getsockopt(x, arg2, arg3, arg4, arg5);
+void test__HeapValidate__noreturn() {
+  int x = 1;
+  if (cond) { x=100; HeapValidate(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__getsockopt__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getsockopt(arg1, x, arg3, arg4, arg5);
+void test__HeapValidate__leakignore() {
+  char *p = malloc(10); *p=0;
+  HeapValidate(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__getsockopt__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    getsockopt(arg1, arg2, x, arg4, arg5);
+void test__HeapValidate__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapValidate(x, arg2, arg3);
 }
 
-void test__getsockopt__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getsockopt(arg1, arg2, arg3, NULL, arg5);
+void test__HeapValidate__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapValidate(arg1, x, arg3);
 }
 
-void test__getsockopt__arg5__notnull()
-{
-    // cppcheck-suppress nullPointer
-    getsockopt(arg1, arg2, arg3, arg4, NULL);
+void test__HeapValidate__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapValidate(arg1, arg2, x);
 }
 
-void test__getsockopt__arg5__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    getsockopt(arg1, arg2, arg3, arg4, x);
+void test__GetProcessHeap__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = GetProcessHeap(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__htonl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = htonl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetProcessHeap__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetProcessHeap();
 }
 
-void test__htonl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    htonl(arg1);
+void test__GetUserName__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetUserName(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__htonl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = htonl(p);
-    // cppcheck-suppress memleak
+void test__GetUserName__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetUserName(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__htonl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = htonl(x);
+void test__GetUserName__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetUserName(arg1, NULL);
 }
 
-void test__htons__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = htons(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetUserName__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetUserName(arg1, x);
 }
 
-void test__htons__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    htons(arg1);
+void test__GetUserNameA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetUserNameA(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__htons__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = htons(p);
-    // cppcheck-suppress memleak
+void test__GetUserNameA__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetUserNameA(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__htons__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = htons(x);
+void test__GetUserNameA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetUserNameA(arg1, NULL);
 }
 
-void test__inet_addr__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = inet_addr(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetUserNameA__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetUserNameA(arg1, x);
 }
 
-void test__inet_addr__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    inet_addr(arg1);
+void test__GetUserNameW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetUserNameW(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__inet_addr__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = inet_addr(p);
-    // cppcheck-suppress memleak
+void test__GetUserNameW__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetUserNameW(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__inet_addr__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = inet_addr(NULL);
+void test__GetUserNameW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetUserNameW(arg1, NULL);
 }
 
-void test__inet_addr__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = inet_addr(x);
+void test__GetUserNameW__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetUserNameW(arg1, x);
 }
 
-void test__inet_ntoa__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = inet_ntoa(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetWindowText__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetWindowText(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__inet_ntoa__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    inet_ntoa(arg1);
+void test__GetWindowText__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetWindowText(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__inet_ntoa__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = inet_ntoa(p);
-    // cppcheck-suppress memleak
+void test__GetWindowText__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetWindowText(NULL, arg2, arg3);
 }
 
-void test__inet_ntoa__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = inet_ntoa(x);
+void test__GetWindowText__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetWindowText(arg1, NULL, arg3);
 }
 
-void test__ioctlsocket__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        ioctlsocket(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetWindowText__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetWindowText(arg1, arg2, x);
 }
 
-void test__ioctlsocket__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    ioctlsocket(p, arg2, arg3);
-    // cppcheck-suppress memleak
+void test__GetWindowTextA__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetWindowTextA(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ioctlsocket__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ioctlsocket(x, arg2, arg3);
+void test__GetWindowTextA__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetWindowTextA(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__ioctlsocket__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    ioctlsocket(arg1, x, arg3);
+void test__GetWindowTextA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetWindowTextA(NULL, arg2, arg3);
 }
 
-void test__ioctlsocket__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    ioctlsocket(arg1, arg2, NULL);
+void test__GetWindowTextA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetWindowTextA(arg1, NULL, arg3);
 }
 
-void test__listen__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        listen(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetWindowTextA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetWindowTextA(arg1, arg2, x);
 }
 
-void test__listen__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    listen(p, arg2);
-    // cppcheck-suppress memleak
+void test__GetWindowTextW__noreturn() {
+  int x = 1;
+  if (cond) { x=100; GetWindowTextW(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__listen__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    listen(x, arg2);
+void test__GetWindowTextW__leakignore() {
+  char *p = malloc(10); *p=0;
+  GetWindowTextW(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__listen__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    listen(arg1, x);
+void test__GetWindowTextW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetWindowTextW(NULL, arg2, arg3);
 }
 
-void test__ntohl__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ntohl(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__GetWindowTextW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetWindowTextW(arg1, NULL, arg3);
 }
 
-void test__ntohl__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ntohl(arg1);
+void test__GetWindowTextW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetWindowTextW(arg1, arg2, x);
 }
 
-void test__ntohl__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ntohl(p);
-    // cppcheck-suppress memleak
+void test__socket__noreturn() {
+  int x = 1;
+  if (cond) { x=100; socket(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ntohl__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ntohl(x);
+void test__socket__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  socket(x, arg2, arg3);
 }
 
-void test__ntohs__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = ntohs(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__socket__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  socket(arg1, x, arg3);
 }
 
-void test__ntohs__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    ntohs(arg1);
+void test__socket__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  socket(arg1, arg2, x);
 }
 
-void test__ntohs__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = ntohs(p);
-    // cppcheck-suppress memleak
+void test__closesocket__noreturn() {
+  int x = 1;
+  if (cond) { x=100; closesocket(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__ntohs__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = ntohs(x);
+void test__closesocket__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  closesocket(x);
 }
 
-void test__recv__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        recv(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__accept__noreturn() {
+  int x = 1;
+  if (cond) { x=100; accept(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__recv__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    recv(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__accept__leakignore() {
+  char *p = malloc(10); *p=0;
+  accept(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__recv__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    recv(x, arg2, arg3, arg4);
+void test__accept__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  accept(x, arg2, arg3);
 }
 
-void test__recv__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    recv(arg1, NULL, arg3, arg4);
+void test__accept__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  accept(arg1, x, arg3);
 }
 
-void test__recv__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    recv(arg1, arg2, x, arg4);
+void test__accept__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  accept(arg1, arg2, x);
 }
 
-void test__recv__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    recv(arg1, arg2, arg3, x);
+void test__bind__noreturn() {
+  int x = 1;
+  if (cond) { x=100; bind(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__recvfrom__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__bind__leakignore() {
+  char *p = malloc(10); *p=0;
+  bind(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__recvfrom__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    recvfrom(p, arg2, arg3, arg4, arg5, arg6);
-    // cppcheck-suppress memleak
+void test__bind__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  bind(x, arg2, arg3);
 }
 
-void test__recvfrom__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    recvfrom(x, arg2, arg3, arg4, arg5, arg6);
+void test__bind__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  bind(arg1, NULL, arg3);
 }
 
-void test__recvfrom__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    recvfrom(arg1, NULL, arg3, arg4, arg5, arg6);
+void test__bind__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  bind(arg1, arg2, x);
 }
 
-void test__recvfrom__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    recvfrom(arg1, arg2, x, arg4, arg5, arg6);
+void test__connect__noreturn() {
+  int x = 1;
+  if (cond) { x=100; connect(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__recvfrom__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    recvfrom(arg1, arg2, arg3, x, arg5, arg6);
+void test__connect__leakignore() {
+  char *p = malloc(10); *p=0;
+  connect(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__select__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        select(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__connect__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  connect(x, arg2, arg3);
 }
 
-void test__select__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    select(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test__connect__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  connect(arg1, NULL, arg3);
 }
 
-void test__select__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    select(arg1, arg2, arg3, arg4, x);
+void test__connect__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  connect(arg1, arg2, x);
 }
 
-void test__send__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        send(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getpeername__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getpeername(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__send__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    send(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__getpeername__leakignore() {
+  char *p = malloc(10); *p=0;
+  getpeername(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__send__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    send(x, arg2, arg3, arg4);
+void test__getpeername__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getpeername(x, arg2, arg3);
 }
 
-void test__send__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    send(arg1, NULL, arg3, arg4);
+void test__getpeername__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getpeername(arg1, NULL, arg3);
 }
 
-void test__send__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    send(arg1, arg2, x, arg4);
+void test__getpeername__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  getpeername(arg1, arg2, NULL);
 }
 
-void test__send__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    send(arg1, arg2, arg3, x);
+void test__getpeername__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getpeername(arg1, arg2, x);
 }
 
-void test__sendto__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        sendto(arg1, arg2, arg3, arg4, arg5, arg6);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getsockname__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getsockname(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sendto__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    sendto(p, arg2, arg3, arg4, arg5, arg6);
-    // cppcheck-suppress memleak
+void test__getsockname__leakignore() {
+  char *p = malloc(10); *p=0;
+  getsockname(p, arg2, arg3);
+  // cppcheck-suppress memleak
 }
 
-void test__sendto__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sendto(x, arg2, arg3, arg4, arg5, arg6);
+void test__getsockname__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getsockname(x, arg2, arg3);
 }
 
-void test__sendto__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    sendto(arg1, NULL, arg3, arg4, arg5, arg6);
+void test__getsockname__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getsockname(arg1, NULL, arg3);
 }
 
-void test__sendto__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sendto(arg1, arg2, x, arg4, arg5, arg6);
+void test__getsockname__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  getsockname(arg1, arg2, NULL);
 }
 
-void test__sendto__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sendto(arg1, arg2, arg3, x, arg5, arg6);
+void test__getsockname__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getsockname(arg1, arg2, x);
 }
 
-void test__sendto__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sendto(arg1, arg2, arg3, arg4, x, arg6);
+void test__getsockopt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; getsockopt(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__sendto__arg6__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    sendto(arg1, arg2, arg3, arg4, arg5, x);
+void test__getsockopt__leakignore() {
+  char *p = malloc(10); *p=0;
+  getsockopt(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
 }
 
-void test__setsockopt__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        setsockopt(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__getsockopt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getsockopt(x, arg2, arg3, arg4, arg5);
 }
 
-void test__setsockopt__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    setsockopt(p, arg2, arg3, arg4, arg5);
-    // cppcheck-suppress memleak
+void test__getsockopt__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getsockopt(arg1, x, arg3, arg4, arg5);
 }
 
-void test__setsockopt__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setsockopt(x, arg2, arg3, arg4, arg5);
+void test__getsockopt__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getsockopt(arg1, arg2, x, arg4, arg5);
 }
 
-void test__setsockopt__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setsockopt(arg1, x, arg3, arg4, arg5);
+void test__getsockopt__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  getsockopt(arg1, arg2, arg3, NULL, arg5);
 }
 
-void test__setsockopt__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setsockopt(arg1, arg2, x, arg4, arg5);
+void test__getsockopt__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  getsockopt(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test__setsockopt__arg4__notnull()
-{
-    // cppcheck-suppress nullPointer
-    setsockopt(arg1, arg2, arg3, NULL, arg5);
+void test__getsockopt__arg5__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getsockopt(arg1, arg2, arg3, arg4, x);
 }
 
-void test__setsockopt__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    setsockopt(arg1, arg2, arg3, arg4, x);
+void test__htonl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = htonl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__shutdown__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        shutdown(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__htonl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  htonl(arg1);
 }
 
-void test__shutdown__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    shutdown(p, arg2);
-    // cppcheck-suppress memleak
+void test__htonl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = htonl(p);
+  // cppcheck-suppress memleak
 }
 
-void test__shutdown__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    shutdown(x, arg2);
+void test__htonl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = htonl(x);
 }
-
-void test__shutdown__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    shutdown(arg1, x);
-}
-
-void test__WSAStartup__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        WSAStartup(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__htons__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = htons(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__htons__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  htons(arg1);
+}
+
+void test__htons__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = htons(p);
+  // cppcheck-suppress memleak
+}
+
+void test__htons__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = htons(x);
+}
+
+void test__inet_addr__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = inet_addr(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__WSAStartup__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    WSAStartup(p, arg2);
-    // cppcheck-suppress memleak
+void test__inet_addr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  inet_addr(arg1);
 }
 
-void test__WSAStartup__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    WSAStartup(x, arg2);
+void test__inet_addr__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = inet_addr(p);
+  // cppcheck-suppress memleak
 }
 
-void test__WSAStartup__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    WSAStartup(arg1, NULL);
+void test__inet_addr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = inet_addr(NULL);
 }
 
-void test__WSACleanup__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        WSACleanup();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__inet_addr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = inet_addr(x);
 }
 
-void test__WSAGetLastError__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = WSAGetLastError();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__inet_ntoa__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = inet_ntoa(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__WSAGetLastError__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    WSAGetLastError();
+void test__inet_ntoa__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  inet_ntoa(arg1);
 }
-
-void test__WSASetLastError__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        WSASetLastError(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__WSASetLastError__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    WSASetLastError(p);
-    // cppcheck-suppress memleak
+
+void test__inet_ntoa__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = inet_ntoa(p);
+  // cppcheck-suppress memleak
+}
+
+void test__inet_ntoa__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = inet_ntoa(x);
+}
+
+void test__ioctlsocket__noreturn() {
+  int x = 1;
+  if (cond) { x=100; ioctlsocket(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ioctlsocket__leakignore() {
+  char *p = malloc(10); *p=0;
+  ioctlsocket(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__ioctlsocket__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ioctlsocket(x, arg2, arg3);
+}
+
+void test__ioctlsocket__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ioctlsocket(arg1, x, arg3);
+}
+
+void test__ioctlsocket__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  ioctlsocket(arg1, arg2, NULL);
+}
+
+void test__listen__noreturn() {
+  int x = 1;
+  if (cond) { x=100; listen(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__listen__leakignore() {
+  char *p = malloc(10); *p=0;
+  listen(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__listen__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  listen(x, arg2);
+}
+
+void test__listen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  listen(arg1, x);
+}
+
+void test__ntohl__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ntohl(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ntohl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ntohl(arg1);
+}
+
+void test__ntohl__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ntohl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ntohl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ntohl(x);
+}
+
+void test__ntohs__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = ntohs(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ntohs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ntohs(arg1);
+}
+
+void test__ntohs__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = ntohs(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ntohs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ntohs(x);
+}
+
+void test__recv__noreturn() {
+  int x = 1;
+  if (cond) { x=100; recv(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__recv__leakignore() {
+  char *p = malloc(10); *p=0;
+  recv(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__recv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recv(x, arg2, arg3, arg4);
+}
+
+void test__recv__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  recv(arg1, NULL, arg3, arg4);
+}
+
+void test__recv__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recv(arg1, arg2, x, arg4);
+}
+
+void test__recv__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recv(arg1, arg2, arg3, x);
+}
+
+void test__recvfrom__noreturn() {
+  int x = 1;
+  if (cond) { x=100; recvfrom(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__recvfrom__leakignore() {
+  char *p = malloc(10); *p=0;
+  recvfrom(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__recvfrom__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recvfrom(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__recvfrom__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  recvfrom(arg1, NULL, arg3, arg4, arg5, arg6);
+}
+
+void test__recvfrom__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recvfrom(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__recvfrom__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recvfrom(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__select__noreturn() {
+  int x = 1;
+  if (cond) { x=100; select(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__select__leakignore() {
+  char *p = malloc(10); *p=0;
+  select(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__select__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  select(arg1, arg2, arg3, arg4, x);
+}
+
+void test__send__noreturn() {
+  int x = 1;
+  if (cond) { x=100; send(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__send__leakignore() {
+  char *p = malloc(10); *p=0;
+  send(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__send__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  send(x, arg2, arg3, arg4);
+}
+
+void test__send__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  send(arg1, NULL, arg3, arg4);
+}
+
+void test__send__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  send(arg1, arg2, x, arg4);
+}
+
+void test__send__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  send(arg1, arg2, arg3, x);
+}
+
+void test__sendto__noreturn() {
+  int x = 1;
+  if (cond) { x=100; sendto(arg1, arg2, arg3, arg4, arg5, arg6); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sendto__leakignore() {
+  char *p = malloc(10); *p=0;
+  sendto(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__sendto__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendto(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__sendto__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  sendto(arg1, NULL, arg3, arg4, arg5, arg6);
+}
+
+void test__sendto__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendto(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__sendto__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendto(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__sendto__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendto(arg1, arg2, arg3, arg4, x, arg6);
+}
+
+void test__sendto__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendto(arg1, arg2, arg3, arg4, arg5, x);
+}
+
+void test__setsockopt__noreturn() {
+  int x = 1;
+  if (cond) { x=100; setsockopt(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setsockopt__leakignore() {
+  char *p = malloc(10); *p=0;
+  setsockopt(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__setsockopt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setsockopt(x, arg2, arg3, arg4, arg5);
+}
+
+void test__setsockopt__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setsockopt(arg1, x, arg3, arg4, arg5);
+}
+
+void test__setsockopt__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setsockopt(arg1, arg2, x, arg4, arg5);
+}
+
+void test__setsockopt__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  setsockopt(arg1, arg2, arg3, NULL, arg5);
+}
+
+void test__setsockopt__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setsockopt(arg1, arg2, arg3, arg4, x);
+}
+
+void test__shutdown__noreturn() {
+  int x = 1;
+  if (cond) { x=100; shutdown(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__shutdown__leakignore() {
+  char *p = malloc(10); *p=0;
+  shutdown(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__shutdown__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  shutdown(x, arg2);
+}
+
+void test__shutdown__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  shutdown(arg1, x);
+}
+
+void test__WSAStartup__noreturn() {
+  int x = 1;
+  if (cond) { x=100; WSAStartup(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__WSAStartup__leakignore() {
+  char *p = malloc(10); *p=0;
+  WSAStartup(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__WSAStartup__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WSAStartup(x, arg2);
+}
+
+void test__WSAStartup__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  WSAStartup(arg1, NULL);
+}
+
+void test__WSACleanup__noreturn() {
+  int x = 1;
+  if (cond) { x=100; WSACleanup(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__WSAGetLastError__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = WSAGetLastError(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__WSAGetLastError__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  WSAGetLastError();
+}
+
+void test__WSASetLastError__noreturn() {
+  int x = 1;
+  if (cond) { x=100; WSASetLastError(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__WSASetLastError__leakignore() {
+  char *p = malloc(10); *p=0;
+  WSASetLastError(p);
+  // cppcheck-suppress memleak
+}
+
+void test__WSASetLastError__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WSASetLastError(x);
+}
+
+void test___fileno__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _fileno(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___fileno__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _fileno(arg1);
+}
+
+void test___fileno__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _fileno(p);
+  // cppcheck-suppress memleak
+}
+
+void test___fileno__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _fileno(!x);
+}
+
+void test___fileno__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _fileno(NULL);
+}
+
+void test___fileno__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _fileno(x);
+}
+
+void test___tolower__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _tolower(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tolower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tolower(arg1);
+}
+
+void test___tolower__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _tolower(p);
+  // cppcheck-suppress memleak
 }
 
-void test__WSASetLastError__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    WSASetLastError(x);
+void test___tolower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tolower(x);
 }
 
-void test___fileno__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _fileno(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___tolower_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _tolower_l(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___fileno__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _fileno(arg1);
+void test___tolower_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tolower_l(arg1, arg2);
 }
 
-void test___fileno__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _fileno(p);
-    // cppcheck-suppress memleak
+void test___tolower_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _tolower_l(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___fileno__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    result = _fileno(!x);
+void test___tolower_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tolower_l(x, arg2);
 }
 
-void test___fileno__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    result = _fileno(NULL);
+void test___tolower_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tolower_l(arg1, x);
 }
 
-void test___fileno__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    result = _fileno(x);
+void test___towlower_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _towlower_l(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tolower__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _tolower(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___towlower_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _towlower_l(arg1, arg2);
 }
 
-void test___tolower__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _tolower(arg1);
+void test___towlower_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _towlower_l(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___tolower__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _tolower(p);
-    // cppcheck-suppress memleak
+void test___towlower_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _towlower_l(x, arg2);
 }
 
-void test___tolower__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _tolower(x);
+void test___towlower_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _towlower_l(arg1, x);
 }
 
-void test___tolower_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _tolower_l(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___toupper__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _toupper(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___tolower_l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _tolower_l(arg1, arg2);
+void test___toupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _toupper(arg1);
 }
 
-void test___tolower_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _tolower_l(p, arg2);
-    // cppcheck-suppress memleak
+void test___toupper__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _toupper(p);
+  // cppcheck-suppress memleak
 }
 
-void test___tolower_l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _tolower_l(x, arg2);
+void test___toupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _toupper(x);
 }
 
-void test___tolower_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _tolower_l(arg1, x);
+void test___toupper_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _toupper_l(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___towlower_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _towlower_l(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___toupper_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _toupper_l(arg1, arg2);
 }
 
-void test___towlower_l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _towlower_l(arg1, arg2);
+void test___toupper_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _toupper_l(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___towlower_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _towlower_l(p, arg2);
-    // cppcheck-suppress memleak
+void test___toupper_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _toupper_l(x, arg2);
 }
 
-void test___towlower_l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _towlower_l(x, arg2);
+void test___toupper_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _toupper_l(arg1, x);
 }
 
-void test___towlower_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _towlower_l(arg1, x);
+void test___towupper_l__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = _towupper_l(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___toupper__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _toupper(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test___towupper_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _towupper_l(arg1, arg2);
 }
 
-void test___toupper__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _toupper(arg1);
+void test___towupper_l__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = _towupper_l(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test___toupper__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _toupper(p);
-    // cppcheck-suppress memleak
+void test___towupper_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _towupper_l(x, arg2);
 }
 
-void test___toupper__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _toupper(x);
+void test___towupper_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _towupper_l(arg1, x);
 }
 
-void test___toupper_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _toupper_l(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test___toupper_l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _toupper_l(arg1, arg2);
-}
-
-void test___toupper_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _toupper_l(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test___toupper_l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _toupper_l(x, arg2);
-}
-
-void test___toupper_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _toupper_l(arg1, x);
+void test____noop__noreturn() {
+  int x = 1;
+  if (cond) { x=100; __noop(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test___towupper_l__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = _towupper_l(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test___towupper_l__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    _towupper_l(arg1, arg2);
-}
-
-void test___towupper_l__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = _towupper_l(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test___towupper_l__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _towupper_l(x, arg2);
-}
-
-void test___towupper_l__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = _towupper_l(arg1, x);
+void test____noop__leakignore() {
+  char *p = malloc(10); *p=0;
+  __noop();
+  // cppcheck-suppress memleak
 }
 
-void test____noop__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        __noop();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test____noop__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    __noop();
-    // cppcheck-suppress memleak
-}
-
-void test____nop__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        __nop();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test____nop__noreturn() {
+  int x = 1;
+  if (cond) { x=100; __nop(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
diff --git a/test/cfg/generated-cfg-tests-wxwidgets.cpp b/test/cfg/generated-cfg-tests-wxwidgets.cpp
index 78abb97c8..99594933c 100644
--- a/test/cfg/generated-cfg-tests-wxwidgets.cpp
+++ b/test/cfg/generated-cfg-tests-wxwidgets.cpp
@@ -8,3056 +8,2241 @@
 // => 'unmatched suppression' warnings are false negatives.
 //
 
-void test__wxString__Format__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxString::Format(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxString__Format__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxString::Format(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxString__Format__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wxString::Format(!x);
-}
-
-void test__wxString__Format__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxString::Format(NULL);
+void test__wxString__Format__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxString::Format(!x);
 }
 
-void test__wxString__Format__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxString::Format(x);
+void test__wxString__Format__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxString::Format(NULL);
 }
 
-void test__wxString__Printf__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxString::Printf(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxString__Printf__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wxString::Printf(!x);
+void test__wxString__Format__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxString::Format(x);
 }
 
-void test__wxString__Printf__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxString::Printf(NULL);
-}
-
-void test__wxString__Printf__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxString::Printf(x);
-}
-
-void test__wxString__IsEmpty__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxString::IsEmpty();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxString__IsEmpty__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxString::IsEmpty();
-}
-
-void test__wxString__IsNull__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxString::IsNull();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxString__IsNull__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxString::IsNull();
-}
-
-void test__wxString__IsNumber__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxString::IsNumber();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxString__IsNumber__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxString::IsNumber();
+void test__wxString__Printf__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxString::Printf(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__wxString__IsAscii__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxString::IsAscii();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxString__IsAscii__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxString::IsAscii();
-}
-
-void test__wxString__IsWord__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxString::IsWord();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxString__IsWord__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxString::IsWord();
-}
-
-void test__wxString__Len__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxString::Len();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxString__Len__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxString::Len();
-}
-
-void test__wxString__length__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxString::length();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxString__length__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxString::length();
-}
-
-void test__wxString__Length__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxString::Length();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxString__Length__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxString::Length();
-}
-
-void test__wxString__Lower__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxString::Lower();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxString__Lower__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxString::Lower();
-}
-
-void test__wxString__MakeCapitalized__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxString::MakeCapitalized();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxString__MakeCapitalized__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxString::MakeCapitalized();
-}
-
-void test__wxString__MakeLower__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxString::MakeLower();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxString__MakeLower__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxString::MakeLower();
-}
-
-void test__wxString__MakeUpper__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxString::MakeUpper();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxString__MakeUpper__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxString::MakeUpper();
-}
-
-void test__wxString__Matches__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxString::Matches(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxString__Matches__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxString::Matches(arg1);
-}
-
-void test__wxString__Matches__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wxString::Matches(x);
+
+void test__wxString__Printf__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxString::Printf(!x);
+}
+
+void test__wxString__Printf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxString::Printf(NULL);
+}
+
+void test__wxString__Printf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxString::Printf(x);
+}
+
+void test__wxString__IsEmpty__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxString::IsEmpty(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__IsEmpty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::IsEmpty();
+}
+
+void test__wxString__IsNull__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxString::IsNull(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__IsNull__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::IsNull();
+}
+
+void test__wxString__IsNumber__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxString::IsNumber(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__IsNumber__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::IsNumber();
+}
+
+void test__wxString__IsAscii__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxString::IsAscii(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__IsAscii__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::IsAscii();
+}
+
+void test__wxString__IsWord__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxString::IsWord(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__IsWord__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::IsWord();
+}
+
+void test__wxString__Len__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxString::Len(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__Len__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::Len();
+}
+
+void test__wxString__length__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxString::length(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__length__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::length();
+}
+
+void test__wxString__Length__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxString::Length(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__Length__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::Length();
+}
+
+void test__wxString__Lower__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxString::Lower(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__Lower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::Lower();
+}
+
+void test__wxString__MakeCapitalized__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxString::MakeCapitalized(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__MakeCapitalized__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::MakeCapitalized();
+}
+
+void test__wxString__MakeLower__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxString::MakeLower(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__MakeLower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::MakeLower();
+}
+
+void test__wxString__MakeUpper__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxString::MakeUpper(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__MakeUpper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::MakeUpper();
+}
+
+void test__wxString__Matches__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxString::Matches(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__Matches__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::Matches(arg1);
+}
+
+void test__wxString__Matches__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxString::Matches(x);
+}
+
+void test__wxString__LowerCase__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxString::LowerCase(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSysErrorCode__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSysErrorCode(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSysErrorCode__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSysErrorCode();
+}
+
+void test__wxLogMessage__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxLogMessage(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogMessage__leakignore() {
+  char *p = malloc(10); *p=0;
+  wxLogMessage(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogMessage__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogMessage(!x);
+}
+
+void test__wxLogMessage__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogMessage(NULL);
+}
+
+void test__wxLogMessage__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogMessage(x);
+}
+
+void test__wxLogVerbose__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxLogVerbose(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogVerbose__leakignore() {
+  char *p = malloc(10); *p=0;
+  wxLogVerbose(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogVerbose__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogVerbose(!x);
+}
+
+void test__wxLogVerbose__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogVerbose(NULL);
+}
+
+void test__wxLogVerbose__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogVerbose(x);
+}
+
+void test__wxLogWarning__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxLogWarning(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogWarning__leakignore() {
+  char *p = malloc(10); *p=0;
+  wxLogWarning(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogWarning__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogWarning(!x);
+}
+
+void test__wxLogWarning__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogWarning(NULL);
+}
+
+void test__wxLogWarning__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogWarning(x);
+}
+
+void test__wxLogFatalError__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxLogFatalError(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogFatalError__leakignore() {
+  char *p = malloc(10); *p=0;
+  wxLogFatalError(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogFatalError__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogFatalError(!x);
+}
+
+void test__wxLogFatalError__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogFatalError(NULL);
+}
+
+void test__wxLogFatalError__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogFatalError(x);
+}
+
+void test__wxLogError__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxLogError(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogError__leakignore() {
+  char *p = malloc(10); *p=0;
+  wxLogError(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogError__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogError(!x);
+}
+
+void test__wxLogError__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogError(NULL);
+}
+
+void test__wxLogError__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogError(x);
+}
+
+void test__wxLogTrace__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxLogTrace(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogTrace__leakignore() {
+  char *p = malloc(10); *p=0;
+  wxLogTrace(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogTrace__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogTrace(arg1, !x);
+}
+
+void test__wxLogTrace__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogTrace(arg1, NULL);
+}
+
+void test__wxLogTrace__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogTrace(arg1, x);
+}
+
+void test__wxLogDebug__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxLogDebug(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogDebug__leakignore() {
+  char *p = malloc(10); *p=0;
+  wxLogDebug(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogDebug__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogDebug(!x);
+}
+
+void test__wxLogDebug__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogDebug(NULL);
+}
+
+void test__wxLogDebug__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogDebug(x);
+}
+
+void test__wxLogSysError__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxLogSysError(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogSysError__leakignore() {
+  char *p = malloc(10); *p=0;
+  wxLogSysError(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogSysError__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogSysError(!x);
+}
+
+void test__wxLogSysError__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogSysError(NULL);
+}
+
+void test__wxLogSysError__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogSysError(x);
+}
+
+void test__wxLogGeneric__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxLogGeneric(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogGeneric__leakignore() {
+  char *p = malloc(10); *p=0;
+  wxLogGeneric(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogGeneric__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxLogGeneric(x, arg2);
+}
+
+void test__wxLogGeneric__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogGeneric(arg1, !x);
+}
+
+void test__wxLogGeneric__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogGeneric(arg1, NULL);
+}
+
+void test__wxLogGeneric__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogGeneric(arg1, x);
+}
+
+void test__wxLogInfo__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxLogInfo(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogInfo__leakignore() {
+  char *p = malloc(10); *p=0;
+  wxLogInfo(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogInfo__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogInfo(!x);
+}
+
+void test__wxLogInfo__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogInfo(NULL);
+}
+
+void test__wxLogInfo__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogInfo(x);
+}
+
+void test__wxSpinCtrl__GetMax__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSpinCtrl::GetMax(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrl__GetMax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrl::GetMax();
+}
+
+void test__wxSpinCtrl__GetMin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSpinCtrl::GetMin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrl__GetMin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrl::GetMin();
+}
+
+void test__wxSpinCtrl__GetBase__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSpinCtrl::GetBase(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrl__GetBase__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrl::GetBase();
+}
+
+void test__wxSpinCtrl__GetValue__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSpinCtrl::GetValue(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrl__GetValue__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrl::GetValue();
+}
+
+void test__wxSpinCtrl__SetBase__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxSpinCtrl::SetBase(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrl__SetBase__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wxSpinCtrl::SetBase(arg1) > 10) || (wxSpinCtrl::SetBase(arg1) < 100)) {}
+}
+
+void test__wxSpinCtrl__SetBase__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxSpinCtrl::SetBase(!x);
+}
+
+void test__wxSpinCtrl__SetBase__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxSpinCtrl::SetBase(x);
+}
+
+void test__wxSpinCtrlDouble__GetDigits__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSpinCtrlDouble::GetDigits(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__GetDigits__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrlDouble::GetDigits();
+}
+
+void test__wxSpinCtrlDouble__GetIncrement__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSpinCtrlDouble::GetIncrement(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__GetIncrement__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrlDouble::GetIncrement();
+}
+
+void test__wxSpinCtrlDouble__GetMax__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSpinCtrlDouble::GetMax(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__GetMax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrlDouble::GetMax();
+}
+
+void test__wxSpinCtrlDouble__GetMin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSpinCtrlDouble::GetMin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__GetMin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrlDouble::GetMin();
+}
+
+void test__wxSpinCtrlDouble__GetValue__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSpinCtrlDouble::GetValue(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__GetValue__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrlDouble::GetValue();
+}
+
+void test__wxSpinCtrlDouble__SetDigits__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxSpinCtrlDouble::SetDigits(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__SetDigits__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxSpinCtrlDouble::SetDigits(x);
+}
+
+void test__wxSpinCtrlDouble__SetIncrement__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxSpinCtrlDouble::SetIncrement(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__SetIncrement__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxSpinCtrlDouble::SetIncrement(x);
+}
+
+void test__wxSpinCtrlDouble__SetRange__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxSpinCtrlDouble::SetRange(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__SetRange__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxSpinCtrlDouble::SetRange(x, arg2);
+}
+
+void test__wxSpinCtrlDouble__SetRange__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxSpinCtrlDouble::SetRange(arg1, x);
+}
+
+void test__wxSpinCtrlDouble__SetValue__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxSpinCtrlDouble::SetValue(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__SetValue__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxSpinCtrlDouble::SetValue(x);
+}
+
+void test__wxSlider__GetLineSize__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSlider::GetLineSize(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetLineSize__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetLineSize();
+}
+
+void test__wxSlider__GetMax__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSlider::GetMax(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetMax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetMax();
+}
+
+void test__wxSlider__GetMin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSlider::GetMin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetMin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetMin();
+}
+
+void test__wxSlider__GetPageSize__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSlider::GetPageSize(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetPageSize__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetPageSize();
+}
+
+void test__wxSlider__GetSelEnd__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSlider::GetSelEnd(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetSelEnd__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetSelEnd();
+}
+
+void test__wxSlider__GetSelStart__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSlider::GetSelStart(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetSelStart__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetSelStart();
+}
+
+void test__wxSlider__GetThumbLength__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSlider::GetThumbLength(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetThumbLength__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetThumbLength();
+}
+
+void test__wxSlider__GetTickFreq__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSlider::GetTickFreq(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetTickFreq__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetTickFreq();
+}
+
+void test__wxSlider__GetValue__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxSlider::GetValue(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetValue__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetValue();
+}
+
+void test__wxTimer__GetId__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTimer::GetId(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__GetId__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTimer::GetId();
+}
+
+void test__wxTimer__GetInterval__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTimer::GetInterval(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__GetInterval__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTimer::GetInterval();
+}
+
+void test__wxTimer__GetOwner__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTimer::GetOwner(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__GetOwner__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTimer::GetOwner();
+}
+
+void test__wxTimer__IsOneShot__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTimer::IsOneShot(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__IsOneShot__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTimer::IsOneShot();
+}
+
+void test__wxTimer__IsRunning__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTimer::IsRunning(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__IsRunning__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTimer::IsRunning();
+}
+
+void test__wxTimer__Notify__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxTimer::Notify(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__SetOwner__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxTimer::SetOwner(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__SetOwner__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxTimer::SetOwner(NULL, arg2);
+}
+
+void test__wxTimer__SetOwner__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxTimer::SetOwner(x, arg2);
+}
+
+void test__wxTimer__SetOwner__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTimer::SetOwner(arg1, x);
+}
+
+void test__wxTimer__Start__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxTimer::Start(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__Start__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTimer::Start(x, arg2);
+}
+
+void test__wxTimer__Start__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTimer::Start(arg1, x);
+}
+
+void test__wxTimer__StartOnce__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxTimer::StartOnce(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__StartOnce__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTimer::StartOnce(x);
+}
+
+void test__wxTimer__Stop__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxTimer::Stop(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__Enable__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxRadioBox::Enable(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__Enable__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRadioBox::Enable(x, arg2);
+}
+
+void test__wxRadioBox__Enable__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRadioBox::Enable(arg1, x);
+}
+
+void test__wxRadioBox__FindString__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxRadioBox::FindString(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__FindString__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRadioBox::FindString(x, arg2);
+}
+
+void test__wxRadioBox__FindString__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRadioBox::FindString(arg1, x);
+}
+
+void test__wxRadioBox__GetColumnCount__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxRadioBox::GetColumnCount(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__GetColumnCount__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxRadioBox::GetColumnCount();
+}
+
+void test__wxRadioBox__GetItemFromPoint__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxRadioBox::GetItemFromPoint(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__GetItemFromPoint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxRadioBox::GetItemFromPoint(arg1);
+}
+
+void test__wxRadioBox__GetItemFromPoint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxRadioBox::GetItemFromPoint(x);
+}
+
+void test__wxRadioBox__GetItemHelpText__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxRadioBox::GetItemHelpText(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__GetItemHelpText__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxRadioBox::GetItemHelpText(arg1);
+}
+
+void test__wxRadioBox__GetItemHelpText__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxRadioBox::GetItemHelpText(x);
+}
+
+void test__wxRadioBox__GetItemToolTip__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxRadioBox::GetItemToolTip(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__GetItemToolTip__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxRadioBox::GetItemToolTip(arg1);
+}
+
+void test__wxRadioBox__GetItemToolTip__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxRadioBox::GetItemToolTip(x);
+}
+
+void test__wxRadioBox__GetRowCount__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxRadioBox::GetRowCount(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__IsItemEnabled__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxRadioBox::IsItemEnabled(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__IsItemEnabled__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxRadioBox::IsItemEnabled(arg1);
+}
+
+void test__wxRadioBox__IsItemEnabled__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxRadioBox::IsItemEnabled(x);
+}
+
+void test__wxRadioBox__IsItemShown__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxRadioBox::IsItemShown(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__IsItemShown__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxRadioBox::IsItemShown(arg1);
+}
+
+void test__wxRadioBox__IsItemShown__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxRadioBox::IsItemShown(x);
+}
+
+void test__wxRadioBox__SetItemHelpText__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxRadioBox::SetItemHelpText(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__SetItemHelpText__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRadioBox::SetItemHelpText(x, arg2);
+}
+
+void test__wxRadioBox__SetItemHelpText__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRadioBox::SetItemHelpText(arg1, x);
+}
+
+void test__wxRadioBox__SetItemToolTip__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxRadioBox::SetItemToolTip(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__SetItemToolTip__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRadioBox::SetItemToolTip(x, arg2);
+}
+
+void test__wxRadioBox__SetItemToolTip__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRadioBox::SetItemToolTip(arg1, x);
+}
+
+void test__wxRadioBox__SetSelection__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxRadioBox::SetSelection(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__SetSelection__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRadioBox::SetSelection(x);
+}
+
+void test__wxRadioBox__Show__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxRadioBox::Show(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__Show__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRadioBox::Show(x, arg2);
+}
+
+void test__wxRadioBox__Show__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRadioBox::Show(arg1, x);
+}
+
+void test__wxRadioBox__GetCount__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxRadioBox::GetCount(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__GetCount__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxRadioBox::GetCount();
+}
+
+void test__wxRadioBox__GetString__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxRadioBox::GetString(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__GetString__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxRadioBox::GetString(arg1);
+}
+
+void test__wxRadioBox__GetString__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxRadioBox::GetString(x);
+}
+
+void test__wxRadioBox__SetString__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxRadioBox::SetString(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__SetString__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRadioBox::SetString(x, arg2);
+}
+
+void test__wxRadioBox__SetString__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRadioBox::SetString(arg1, x);
+}
+
+void test__wxRadioBox__GetSelection__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxRadioBox::GetSelection(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__GetSelection__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxRadioBox::GetSelection();
+}
+
+void test__wxButton__GetAuthNeeded__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxButton::GetAuthNeeded(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxButton__GetAuthNeeded__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxButton::GetAuthNeeded();
+}
+
+void test__wxButton__GetLabel__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxButton::GetLabel(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxButton__GetLabel__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxButton::GetLabel();
+}
+
+void test__wxButton__SetAuthNeeded__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxButton::SetAuthNeeded(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxButton__SetAuthNeeded__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxButton::SetAuthNeeded(x);
+}
+
+void test__wxButton__SetDefault__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxButton::SetDefault(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxButton__SetLabel__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxButton::SetLabel(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxButton__SetLabel__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxButton::SetLabel(x);
+}
+
+void test__wxColour__Alpha__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxColour::Alpha(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxColour__Alpha__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxColour::Alpha();
+}
+
+void test__wxColour__Blue__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxColour::Blue(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxColour__Blue__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxColour::Blue();
+}
+
+void test__wxColour__Green__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxColour::Green(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxColour__Green__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxColour::Green();
+}
+
+void test__wxColour__Red__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxColour::Red(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxColour__Red__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxColour::Red();
+}
+
+void test__wxTextFile__AddLine__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxTextFile::AddLine(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__AddLine__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTextFile::AddLine(x, arg2);
+}
+
+void test__wxTextFile__AddLine__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTextFile::AddLine(arg1, x);
+}
+
+void test__wxTextFile__Clear__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxTextFile::Clear(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__Close__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxTextFile::Close(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__Create__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxTextFile::Create(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__Create__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTextFile::Create(x);
+}
+
+void test__wxTextFile__Eof__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTextFile::Eof(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__Eof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::Eof();
+}
+
+void test__wxTextFile__Exists__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTextFile::Exists(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__Exists__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::Exists();
+}
+
+void test__wxTextFile__GetCurrentLine__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTextFile::GetCurrentLine(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetCurrentLine__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetCurrentLine();
+}
+
+void test__wxTextFile__GetFirstLine__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTextFile::GetFirstLine(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetFirstLine__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetFirstLine();
+}
+
+void test__wxTextFile__GetLastLine__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTextFile::GetLastLine(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetLastLine__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetLastLine();
+}
+
+void test__wxTextFile__GetLineCount__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTextFile::GetLineCount(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetLineCount__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetLineCount();
+}
+
+void test__wxTextFile__GetLineType__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTextFile::GetLineType(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetLineType__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetLineType();
+}
+
+void test__wxTextFile__GetName__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTextFile::GetName(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetName__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetName();
+}
+
+void test__wxTextFile__GetNextLine__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTextFile::GetNextLine(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetNextLine__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetNextLine();
+}
+
+void test__wxTextFile__GetPrevLine__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTextFile::GetPrevLine(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetPrevLine__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetPrevLine();
+}
+
+void test__wxTextFile__GoToLine__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxTextFile::GoToLine(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GoToLine__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTextFile::GoToLine(x);
+}
+
+void test__wxTextFile__GuessType__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTextFile::GuessType(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GuessType__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GuessType();
+}
+
+void test__wxTextFile__InsertLine__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxTextFile::InsertLine(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__InsertLine__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTextFile::InsertLine(x, arg2, arg3);
+}
+
+void test__wxTextFile__InsertLine__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTextFile::InsertLine(arg1, x, arg3);
+}
+
+void test__wxTextFile__InsertLine__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTextFile::InsertLine(arg1, arg2, x);
+}
+
+void test__wxTextFile__IsOpened__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTextFile::IsOpened(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__IsOpened__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::IsOpened();
+}
+
+void test__wxTextFile__RemoveLine__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxTextFile::RemoveLine(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__RemoveLine__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTextFile::RemoveLine(x);
+}
+
+void test__wxTextFile__GetLine__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxTextFile::GetLine(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxString__LowerCase__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxString::LowerCase();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSysErrorCode__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSysErrorCode();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSysErrorCode__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSysErrorCode();
-}
-
-void test__wxLogMessage__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxLogMessage(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxTextFile__GetLine__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetLine(arg1);
 }
 
-void test__wxLogMessage__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wxLogMessage(p);
-    // cppcheck-suppress memleak
+void test__wxTextFile__GetLine__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxTextFile::GetLine(x);
 }
 
-void test__wxLogMessage__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wxLogMessage(!x);
+void test__wxSizer__AddSpacer__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxSizer::AddSpacer(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogMessage__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxLogMessage(NULL);
+void test__wxSizer__AddSpacer__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxSizer::AddSpacer(x);
 }
-
-void test__wxLogMessage__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxLogMessage(x);
+
+void test__wxBoxSizer__AddSpacer__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxBoxSizer::AddSpacer(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogVerbose__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxLogVerbose(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxBoxSizer__AddSpacer__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxBoxSizer::AddSpacer(x);
 }
 
-void test__wxLogVerbose__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wxLogVerbose(p);
-    // cppcheck-suppress memleak
+void test__wxBoxSizer__CalcMin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxBoxSizer::CalcMin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogVerbose__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wxLogVerbose(!x);
+void test__wxBoxSizer__GetOrientation__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxBoxSizer::GetOrientation(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogVerbose__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxLogVerbose(NULL);
+void test__wxBoxSizer__GetOrientation__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxBoxSizer::GetOrientation();
 }
 
-void test__wxLogVerbose__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxLogVerbose(x);
+void test__wxBoxSizer__RecalcSizes__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxBoxSizer::RecalcSizes(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogWarning__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxLogWarning(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxBoxSizer__SetOrientation__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxBoxSizer::SetOrientation(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogWarning__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wxLogWarning(p);
-    // cppcheck-suppress memleak
+void test__wxBoxSizer__SetOrientation__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxBoxSizer::SetOrientation(x);
 }
 
-void test__wxLogWarning__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wxLogWarning(!x);
+void test__wxStaticBoxSizer__CalcMin__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxStaticBoxSizer::CalcMin(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogWarning__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxLogWarning(NULL);
+void test__wxStaticBoxSizer__GetStaticBox__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxStaticBoxSizer::GetStaticBox(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogWarning__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxLogWarning(x);
+void test__wxStaticBoxSizer__GetStaticBox__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxStaticBoxSizer::GetStaticBox();
 }
 
-void test__wxLogFatalError__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxLogFatalError(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxStaticBoxSizer__RecalcSizes__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxStaticBoxSizer::RecalcSizes(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogFatalError__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wxLogFatalError(p);
-    // cppcheck-suppress memleak
+void test__wxMenu__Append__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxMenu::Append(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogFatalError__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wxLogFatalError(!x);
+void test__wxMenu__Append__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxMenu::Append(x, arg2, arg3, arg4);
 }
 
-void test__wxLogFatalError__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxLogFatalError(NULL);
+void test__wxMenu__Append__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxMenu::Append(arg1, arg2, arg3, x);
 }
 
-void test__wxLogFatalError__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxLogFatalError(x);
+void test__wxLaunchDefaultBrowser__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxLaunchDefaultBrowser(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogError__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxLogError(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxLaunchDefaultBrowser__leakignore() {
+  char *p = malloc(10); *p=0;
+  wxLaunchDefaultBrowser(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__wxLogError__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wxLogError(p);
-    // cppcheck-suppress memleak
+void test__wxLaunchDefaultBrowser__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxLaunchDefaultBrowser(x, arg2);
 }
 
-void test__wxLogError__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wxLogError(!x);
+void test__wxLaunchDefaultBrowser__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxLaunchDefaultBrowser(arg1, x);
 }
 
-void test__wxLogError__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxLogError(NULL);
+void test__wxDirExists__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxDirExists(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogError__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxLogError(x);
+void test__wxDirExists__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxDirExists(arg1);
 }
 
-void test__wxLogTrace__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxLogTrace(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxDirExists__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wxDirExists(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wxLogTrace__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wxLogTrace(p, arg2);
-    // cppcheck-suppress memleak
+void test__wxDirExists__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxDirExists(x);
 }
 
-void test__wxLogTrace__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wxLogTrace(arg1, !x);
+void test__wxFileExists__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxFileExists(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogTrace__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxLogTrace(arg1, NULL);
+void test__wxFileExists__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxFileExists(arg1);
 }
 
-void test__wxLogTrace__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxLogTrace(arg1, x);
+void test__wxFileExists__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wxFileExists(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wxLogDebug__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxLogDebug(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxFileExists__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxFileExists(x);
 }
 
-void test__wxLogDebug__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wxLogDebug(p);
-    // cppcheck-suppress memleak
+void test__wxGetWorkingDirectory__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxGetWorkingDirectory(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogDebug__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wxLogDebug(!x);
+void test__wxGetWorkingDirectory__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxGetWorkingDirectory(arg1, x);
 }
 
-void test__wxLogDebug__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxLogDebug(NULL);
+void test__wxGetCwd__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxGetCwd(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogDebug__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxLogDebug(x);
+void test__wxGetCwd__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxGetCwd();
 }
 
-void test__wxLogSysError__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxLogSysError(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxSetWorkingDirectory__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxSetWorkingDirectory(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogSysError__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wxLogSysError(p);
-    // cppcheck-suppress memleak
+void test__wxSetWorkingDirectory__leakignore() {
+  char *p = malloc(10); *p=0;
+  wxSetWorkingDirectory(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wxLogSysError__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wxLogSysError(!x);
+void test__wxSetWorkingDirectory__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxSetWorkingDirectory(x);
 }
 
-void test__wxLogSysError__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxLogSysError(NULL);
+void test__wxMkdir__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxMkdir(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogSysError__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxLogSysError(x);
+void test__wxMkdir__leakignore() {
+  char *p = malloc(10); *p=0;
+  wxMkdir(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__wxLogGeneric__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxLogGeneric(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxMkdir__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxMkdir(x, arg2);
 }
 
-void test__wxLogGeneric__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wxLogGeneric(p, arg2);
-    // cppcheck-suppress memleak
+void test__wxMkdir__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxMkdir(arg1, x);
 }
 
-void test__wxLogGeneric__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxLogGeneric(x, arg2);
+void test__wxRmdir__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxRmdir(arg1, arg2); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogGeneric__arg2__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wxLogGeneric(arg1, !x);
+void test__wxRmdir__leakignore() {
+  char *p = malloc(10); *p=0;
+  wxRmdir(p, arg2);
+  // cppcheck-suppress memleak
 }
 
-void test__wxLogGeneric__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxLogGeneric(arg1, NULL);
+void test__wxRmdir__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRmdir(x, arg2);
 }
 
-void test__wxLogGeneric__arg2__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxLogGeneric(arg1, x);
+void test__wxRmdir__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRmdir(arg1, x);
 }
 
-void test__wxLogInfo__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxLogInfo(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxGetTranslation__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxGetTranslation(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxLogInfo__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wxLogInfo(p);
-    // cppcheck-suppress memleak
+void test__wxGetTranslation__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxGetTranslation(arg1, arg2, arg3, arg4);
 }
 
-void test__wxLogInfo__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wxLogInfo(!x);
+void test__wxGetTranslation__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wxGetTranslation(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
 }
 
-void test__wxLogInfo__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxLogInfo(NULL);
+void test__wxGetTranslation__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxGetTranslation(x, arg2, arg3, arg4);
 }
 
-void test__wxLogInfo__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxLogInfo(x);
+void test__wxGetTranslation__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxGetTranslation(arg1, x, arg3, arg4);
 }
 
-void test__wxSpinCtrl__GetMax__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSpinCtrl::GetMax();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxGetTranslation__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxGetTranslation(arg1, arg2, x, arg4);
 }
 
-void test__wxSpinCtrl__GetMax__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSpinCtrl::GetMax();
+void test__wxGetTranslation__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxGetTranslation(arg1, arg2, arg3, x);
 }
 
-void test__wxSpinCtrl__GetMin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSpinCtrl::GetMin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxApp__MacOpenFile__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxApp::MacOpenFile(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxSpinCtrl__GetMin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSpinCtrl::GetMin();
+void test__wxApp__MacOpenFile__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxApp::MacOpenFile(x);
 }
 
-void test__wxSpinCtrl__GetBase__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSpinCtrl::GetBase();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxArtProvider__Insert__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxArtProvider::Insert(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxSpinCtrl__GetBase__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSpinCtrl::GetBase();
+void test__wxArtProvider__Insert__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxArtProvider::Insert(NULL);
 }
 
-void test__wxSpinCtrl__GetValue__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSpinCtrl::GetValue();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxArtProvider__Insert__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxArtProvider::Insert(x);
 }
-
-void test__wxSpinCtrl__GetValue__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSpinCtrl::GetValue();
+
+void test__wxCalendarCtrl__EnableYearChange__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxCalendarCtrl::EnableYearChange(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxSpinCtrl__SetBase__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxSpinCtrl::SetBase(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxCalendarCtrl__EnableYearChange__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxCalendarCtrl::EnableYearChange(x);
 }
 
-void test__wxSpinCtrl__SetBase__pure(int arg1)
-{
-    // cppcheck-suppress incorrectLogicOperator
-    if ((wxSpinCtrl::SetBase(arg1) > 10) || (wxSpinCtrl::SetBase(arg1) < 100)) {}
+void test__wxComboCtrl__GetTextIndent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxComboCtrl::GetTextIndent(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxSpinCtrl__SetBase__arg1__notbool()
-{
-    // cppcheck-suppress invalidFunctionArgBool
-    wxSpinCtrl::SetBase(!x);
-}
-
-void test__wxSpinCtrl__SetBase__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxSpinCtrl::SetBase(x);
-}
-
-void test__wxSpinCtrlDouble__GetDigits__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSpinCtrlDouble::GetDigits();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSpinCtrlDouble__GetDigits__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSpinCtrlDouble::GetDigits();
-}
-
-void test__wxSpinCtrlDouble__GetIncrement__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSpinCtrlDouble::GetIncrement();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSpinCtrlDouble__GetIncrement__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSpinCtrlDouble::GetIncrement();
-}
-
-void test__wxSpinCtrlDouble__GetMax__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSpinCtrlDouble::GetMax();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSpinCtrlDouble__GetMax__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSpinCtrlDouble::GetMax();
-}
-
-void test__wxSpinCtrlDouble__GetMin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSpinCtrlDouble::GetMin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSpinCtrlDouble__GetMin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSpinCtrlDouble::GetMin();
-}
-
-void test__wxSpinCtrlDouble__GetValue__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSpinCtrlDouble::GetValue();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSpinCtrlDouble__GetValue__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSpinCtrlDouble::GetValue();
-}
-
-void test__wxSpinCtrlDouble__SetDigits__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxSpinCtrlDouble::SetDigits(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSpinCtrlDouble__SetDigits__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxSpinCtrlDouble::SetDigits(x);
-}
-
-void test__wxSpinCtrlDouble__SetIncrement__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxSpinCtrlDouble::SetIncrement(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSpinCtrlDouble__SetIncrement__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxSpinCtrlDouble::SetIncrement(x);
-}
-
-void test__wxSpinCtrlDouble__SetRange__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxSpinCtrlDouble::SetRange(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSpinCtrlDouble__SetRange__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxSpinCtrlDouble::SetRange(x, arg2);
-}
-
-void test__wxSpinCtrlDouble__SetRange__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxSpinCtrlDouble::SetRange(arg1, x);
-}
-
-void test__wxSpinCtrlDouble__SetValue__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxSpinCtrlDouble::SetValue(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSpinCtrlDouble__SetValue__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxSpinCtrlDouble::SetValue(x);
-}
-
-void test__wxSlider__GetLineSize__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSlider::GetLineSize();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSlider__GetLineSize__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSlider::GetLineSize();
-}
-
-void test__wxSlider__GetMax__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSlider::GetMax();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSlider__GetMax__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSlider::GetMax();
-}
-
-void test__wxSlider__GetMin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSlider::GetMin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSlider__GetMin__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSlider::GetMin();
-}
-
-void test__wxSlider__GetPageSize__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSlider::GetPageSize();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSlider__GetPageSize__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSlider::GetPageSize();
-}
-
-void test__wxSlider__GetSelEnd__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSlider::GetSelEnd();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSlider__GetSelEnd__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSlider::GetSelEnd();
-}
-
-void test__wxSlider__GetSelStart__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSlider::GetSelStart();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSlider__GetSelStart__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSlider::GetSelStart();
-}
-
-void test__wxSlider__GetThumbLength__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSlider::GetThumbLength();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSlider__GetThumbLength__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSlider::GetThumbLength();
-}
-
-void test__wxSlider__GetTickFreq__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSlider::GetTickFreq();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSlider__GetTickFreq__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSlider::GetTickFreq();
-}
-
-void test__wxSlider__GetValue__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxSlider::GetValue();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSlider__GetValue__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxSlider::GetValue();
-}
-
-void test__wxTimer__GetId__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTimer::GetId();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTimer__GetId__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTimer::GetId();
-}
-
-void test__wxTimer__GetInterval__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTimer::GetInterval();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTimer__GetInterval__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTimer::GetInterval();
-}
-
-void test__wxTimer__GetOwner__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTimer::GetOwner();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTimer__GetOwner__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTimer::GetOwner();
-}
-
-void test__wxTimer__IsOneShot__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTimer::IsOneShot();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTimer__IsOneShot__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTimer::IsOneShot();
-}
-
-void test__wxTimer__IsRunning__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTimer::IsRunning();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTimer__IsRunning__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTimer::IsRunning();
-}
-
-void test__wxTimer__Notify__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxTimer::Notify();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTimer__SetOwner__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxTimer::SetOwner(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTimer__SetOwner__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxTimer::SetOwner(NULL, arg2);
-}
-
-void test__wxTimer__SetOwner__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxTimer::SetOwner(x, arg2);
-}
-
-void test__wxTimer__SetOwner__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxTimer::SetOwner(arg1, x);
-}
-
-void test__wxTimer__Start__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxTimer::Start(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTimer__Start__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxTimer::Start(x, arg2);
-}
-
-void test__wxTimer__Start__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxTimer::Start(arg1, x);
-}
-
-void test__wxTimer__StartOnce__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxTimer::StartOnce(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTimer__StartOnce__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxTimer::StartOnce(x);
-}
-
-void test__wxTimer__Stop__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxTimer::Stop();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRadioBox__Enable__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxRadioBox::Enable(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRadioBox__Enable__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxRadioBox::Enable(x, arg2);
-}
-
-void test__wxRadioBox__Enable__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxRadioBox::Enable(arg1, x);
-}
-
-void test__wxRadioBox__FindString__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxRadioBox::FindString(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRadioBox__FindString__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxRadioBox::FindString(x, arg2);
-}
-
-void test__wxRadioBox__FindString__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxRadioBox::FindString(arg1, x);
-}
-
-void test__wxRadioBox__GetColumnCount__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxRadioBox::GetColumnCount();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRadioBox__GetColumnCount__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxRadioBox::GetColumnCount();
-}
-
-void test__wxRadioBox__GetItemFromPoint__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxRadioBox::GetItemFromPoint(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRadioBox__GetItemFromPoint__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxRadioBox::GetItemFromPoint(arg1);
-}
-
-void test__wxRadioBox__GetItemFromPoint__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wxRadioBox::GetItemFromPoint(x);
-}
-
-void test__wxRadioBox__GetItemHelpText__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxRadioBox::GetItemHelpText(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRadioBox__GetItemHelpText__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxRadioBox::GetItemHelpText(arg1);
-}
-
-void test__wxRadioBox__GetItemHelpText__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wxRadioBox::GetItemHelpText(x);
-}
-
-void test__wxRadioBox__GetItemToolTip__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxRadioBox::GetItemToolTip(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRadioBox__GetItemToolTip__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxRadioBox::GetItemToolTip(arg1);
-}
-
-void test__wxRadioBox__GetItemToolTip__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wxRadioBox::GetItemToolTip(x);
-}
-
-void test__wxRadioBox__GetRowCount__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxRadioBox::GetRowCount();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxComboCtrl__GetTextIndent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxComboCtrl::GetTextIndent();
 }
-
-void test__wxRadioBox__IsItemEnabled__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxRadioBox::IsItemEnabled(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__wxComboCtrl__HidePopup__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxComboCtrl::HidePopup(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
-
-void test__wxRadioBox__IsItemEnabled__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxRadioBox::IsItemEnabled(arg1);
+
+void test__wxComboCtrl__HidePopup__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxComboCtrl::HidePopup(x);
 }
-
-void test__wxRadioBox__IsItemEnabled__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wxRadioBox::IsItemEnabled(x);
-}
-
-void test__wxRadioBox__IsItemShown__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxRadioBox::IsItemShown(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRadioBox__IsItemShown__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxRadioBox::IsItemShown(arg1);
-}
-
-void test__wxRadioBox__IsItemShown__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wxRadioBox::IsItemShown(x);
-}
-
-void test__wxRadioBox__SetItemHelpText__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxRadioBox::SetItemHelpText(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRadioBox__SetItemHelpText__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxRadioBox::SetItemHelpText(x, arg2);
-}
-
-void test__wxRadioBox__SetItemHelpText__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxRadioBox::SetItemHelpText(arg1, x);
-}
-
-void test__wxRadioBox__SetItemToolTip__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxRadioBox::SetItemToolTip(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRadioBox__SetItemToolTip__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxRadioBox::SetItemToolTip(x, arg2);
-}
-
-void test__wxRadioBox__SetItemToolTip__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxRadioBox::SetItemToolTip(arg1, x);
-}
-
-void test__wxRadioBox__SetSelection__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxRadioBox::SetSelection(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__wxComboCtrl__ShowPopup__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxComboCtrl::ShowPopup(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxRadioBox__SetSelection__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxRadioBox::SetSelection(x);
-}
-
-void test__wxRadioBox__Show__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxRadioBox::Show(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRadioBox__Show__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxRadioBox::Show(x, arg2);
-}
-
-void test__wxRadioBox__Show__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxRadioBox::Show(arg1, x);
-}
-
-void test__wxRadioBox__GetCount__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxRadioBox::GetCount();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRadioBox__GetCount__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxRadioBox::GetCount();
-}
+void test__wxComboCtrl__SetTextIndent__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxComboCtrl::SetTextIndent(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
 
-void test__wxRadioBox__GetString__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxRadioBox::GetString(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRadioBox__GetString__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxRadioBox::GetString(arg1);
-}
-
-void test__wxRadioBox__GetString__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wxRadioBox::GetString(x);
-}
-
-void test__wxRadioBox__SetString__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxRadioBox::SetString(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRadioBox__SetString__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxRadioBox::SetString(x, arg2);
-}
-
-void test__wxRadioBox__SetString__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxRadioBox::SetString(arg1, x);
-}
-
-void test__wxRadioBox__GetSelection__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxRadioBox::GetSelection();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRadioBox__GetSelection__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxRadioBox::GetSelection();
-}
-
-void test__wxButton__GetAuthNeeded__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxButton::GetAuthNeeded();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxButton__GetAuthNeeded__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxButton::GetAuthNeeded();
-}
-
-void test__wxButton__GetLabel__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxButton::GetLabel();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxButton__GetLabel__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxButton::GetLabel();
-}
-
-void test__wxButton__SetAuthNeeded__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxButton::SetAuthNeeded(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxButton__SetAuthNeeded__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxButton::SetAuthNeeded(x);
-}
-
-void test__wxButton__SetDefault__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxButton::SetDefault();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxButton__SetLabel__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxButton::SetLabel(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxButton__SetLabel__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxButton::SetLabel(x);
-}
-
-void test__wxColour__Alpha__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxColour::Alpha();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxColour__Alpha__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxColour::Alpha();
-}
-
-void test__wxColour__Blue__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxColour::Blue();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxColour__Blue__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxColour::Blue();
-}
-
-void test__wxColour__Green__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxColour::Green();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxColour__Green__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxColour::Green();
-}
-
-void test__wxColour__Red__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxColour::Red();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxColour__Red__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxColour::Red();
-}
-
-void test__wxTextFile__AddLine__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxTextFile::AddLine(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__AddLine__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxTextFile::AddLine(x, arg2);
-}
-
-void test__wxTextFile__AddLine__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxTextFile::AddLine(arg1, x);
-}
-
-void test__wxTextFile__Clear__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxTextFile::Clear();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__Close__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxTextFile::Close();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__Create__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxTextFile::Create(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__Create__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxTextFile::Create(x);
-}
-
-void test__wxTextFile__Eof__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTextFile::Eof();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__Eof__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTextFile::Eof();
-}
-
-void test__wxTextFile__Exists__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTextFile::Exists();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__Exists__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTextFile::Exists();
-}
-
-void test__wxTextFile__GetCurrentLine__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTextFile::GetCurrentLine();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__GetCurrentLine__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTextFile::GetCurrentLine();
-}
-
-void test__wxTextFile__GetFirstLine__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTextFile::GetFirstLine();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__GetFirstLine__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTextFile::GetFirstLine();
-}
-
-void test__wxTextFile__GetLastLine__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTextFile::GetLastLine();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__GetLastLine__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTextFile::GetLastLine();
-}
-
-void test__wxTextFile__GetLineCount__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTextFile::GetLineCount();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__GetLineCount__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTextFile::GetLineCount();
-}
-
-void test__wxTextFile__GetLineType__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTextFile::GetLineType();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__GetLineType__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTextFile::GetLineType();
-}
-
-void test__wxTextFile__GetName__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTextFile::GetName();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__GetName__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTextFile::GetName();
-}
-
-void test__wxTextFile__GetNextLine__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTextFile::GetNextLine();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__GetNextLine__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTextFile::GetNextLine();
-}
-
-void test__wxTextFile__GetPrevLine__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTextFile::GetPrevLine();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__GetPrevLine__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTextFile::GetPrevLine();
-}
-
-void test__wxTextFile__GoToLine__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxTextFile::GoToLine(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__GoToLine__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxTextFile::GoToLine(x);
-}
-
-void test__wxTextFile__GuessType__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTextFile::GuessType();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__GuessType__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTextFile::GuessType();
-}
-
-void test__wxTextFile__InsertLine__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxTextFile::InsertLine(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__InsertLine__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxTextFile::InsertLine(x, arg2, arg3);
-}
-
-void test__wxTextFile__InsertLine__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxTextFile::InsertLine(arg1, x, arg3);
-}
-
-void test__wxTextFile__InsertLine__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxTextFile::InsertLine(arg1, arg2, x);
-}
-
-void test__wxTextFile__IsOpened__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTextFile::IsOpened();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__IsOpened__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTextFile::IsOpened();
-}
-
-void test__wxTextFile__RemoveLine__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxTextFile::RemoveLine(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__RemoveLine__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxTextFile::RemoveLine(x);
-}
-
-void test__wxTextFile__GetLine__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxTextFile::GetLine(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxTextFile__GetLine__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxTextFile::GetLine(arg1);
-}
-
-void test__wxTextFile__GetLine__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wxTextFile::GetLine(x);
-}
-
-void test__wxSizer__AddSpacer__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxSizer::AddSpacer(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxSizer__AddSpacer__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxSizer::AddSpacer(x);
-}
-
-void test__wxBoxSizer__AddSpacer__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxBoxSizer::AddSpacer(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxBoxSizer__AddSpacer__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxBoxSizer::AddSpacer(x);
-}
-
-void test__wxBoxSizer__CalcMin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxBoxSizer::CalcMin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxBoxSizer__GetOrientation__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxBoxSizer::GetOrientation();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxBoxSizer__GetOrientation__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxBoxSizer::GetOrientation();
-}
-
-void test__wxBoxSizer__RecalcSizes__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxBoxSizer::RecalcSizes();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxBoxSizer__SetOrientation__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxBoxSizer::SetOrientation(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxBoxSizer__SetOrientation__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxBoxSizer::SetOrientation(x);
-}
-
-void test__wxStaticBoxSizer__CalcMin__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxStaticBoxSizer::CalcMin();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxStaticBoxSizer__GetStaticBox__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxStaticBoxSizer::GetStaticBox();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxStaticBoxSizer__GetStaticBox__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxStaticBoxSizer::GetStaticBox();
-}
-
-void test__wxStaticBoxSizer__RecalcSizes__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxStaticBoxSizer::RecalcSizes();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxMenu__Append__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxMenu::Append(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxMenu__Append__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxMenu::Append(x, arg2, arg3, arg4);
-}
-
-void test__wxMenu__Append__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxMenu::Append(arg1, arg2, arg3, x);
-}
-
-void test__wxLaunchDefaultBrowser__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxLaunchDefaultBrowser(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxLaunchDefaultBrowser__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wxLaunchDefaultBrowser(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__wxLaunchDefaultBrowser__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxLaunchDefaultBrowser(x, arg2);
-}
-
-void test__wxLaunchDefaultBrowser__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxLaunchDefaultBrowser(arg1, x);
-}
-
-void test__wxDirExists__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxDirExists(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxDirExists__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxDirExists(arg1);
-}
-
-void test__wxDirExists__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wxDirExists(p);
-    // cppcheck-suppress memleak
-}
-
-void test__wxDirExists__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wxDirExists(x);
-}
-
-void test__wxFileExists__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxFileExists(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxFileExists__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxFileExists(arg1);
-}
-
-void test__wxFileExists__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wxFileExists(p);
-    // cppcheck-suppress memleak
-}
-
-void test__wxFileExists__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wxFileExists(x);
-}
-
-void test__wxGetWorkingDirectory__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxGetWorkingDirectory(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxGetWorkingDirectory__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxGetWorkingDirectory(arg1, x);
-}
-
-void test__wxGetCwd__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxGetCwd();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxComboCtrl__SetTextIndent__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxComboCtrl::SetTextIndent(x);
 }
-
-void test__wxGetCwd__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxGetCwd();
-}
-
-void test__wxSetWorkingDirectory__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxSetWorkingDirectory(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__wxDataViewCustomRenderer__Activate__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxDataViewCustomRenderer::Activate(arg1, arg2, arg3, arg4); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxSetWorkingDirectory__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wxSetWorkingDirectory(p);
-    // cppcheck-suppress memleak
-}
-
-void test__wxSetWorkingDirectory__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxSetWorkingDirectory(x);
+void test__wxDataViewCustomRenderer__Activate__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxDataViewCustomRenderer::Activate(x, arg2, arg3, arg4);
 }
-
-void test__wxMkdir__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxMkdir(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxMkdir__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wxMkdir(p, arg2);
-    // cppcheck-suppress memleak
+
+void test__wxDataViewCustomRenderer__Activate__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wxDataViewCustomRenderer::Activate(arg1, NULL, arg3, arg4);
 }
 
-void test__wxMkdir__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxMkdir(x, arg2);
-}
-
-void test__wxMkdir__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxMkdir(arg1, x);
-}
-
-void test__wxRmdir__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxRmdir(arg1, arg2);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxRmdir__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wxRmdir(p, arg2);
-    // cppcheck-suppress memleak
-}
-
-void test__wxRmdir__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxRmdir(x, arg2);
-}
-
-void test__wxRmdir__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxRmdir(arg1, x);
+void test__wxDataViewCustomRenderer__Activate__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxDataViewCustomRenderer::Activate(arg1, arg2, x, arg4);
 }
 
-void test__wxGetTranslation__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxGetTranslation(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxGetTranslation__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxGetTranslation(arg1, arg2, arg3, arg4);
+void test__wxDataViewCustomRenderer__Activate__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxDataViewCustomRenderer::Activate(arg1, arg2, arg3, x);
 }
 
-void test__wxGetTranslation__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wxGetTranslation(p, arg2, arg3, arg4);
-    // cppcheck-suppress memleak
+void test__wxDataViewCustomRenderer__LeftClick__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, arg4, arg5); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxGetTranslation__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wxGetTranslation(x, arg2, arg3, arg4);
+void test__wxDataViewCustomRenderer__LeftClick__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxDataViewCustomRenderer::LeftClick(x, arg2, arg3, arg4, arg5);
 }
 
-void test__wxGetTranslation__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wxGetTranslation(arg1, x, arg3, arg4);
-}
-
-void test__wxGetTranslation__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wxGetTranslation(arg1, arg2, x, arg4);
-}
-
-void test__wxGetTranslation__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wxGetTranslation(arg1, arg2, arg3, x);
-}
-
-void test__wxApp__MacOpenFile__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxApp::MacOpenFile(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxApp__MacOpenFile__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxApp::MacOpenFile(x);
-}
-
-void test__wxArtProvider__Insert__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxArtProvider::Insert(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxArtProvider__Insert__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxArtProvider::Insert(NULL);
-}
-
-void test__wxArtProvider__Insert__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxArtProvider::Insert(x);
-}
-
-void test__wxCalendarCtrl__EnableYearChange__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxCalendarCtrl::EnableYearChange(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxCalendarCtrl__EnableYearChange__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxCalendarCtrl::EnableYearChange(x);
-}
-
-void test__wxComboCtrl__GetTextIndent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxComboCtrl::GetTextIndent();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxComboCtrl__GetTextIndent__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxComboCtrl::GetTextIndent();
-}
-
-void test__wxComboCtrl__HidePopup__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxComboCtrl::HidePopup(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxComboCtrl__HidePopup__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxComboCtrl::HidePopup(x);
-}
-
-void test__wxComboCtrl__ShowPopup__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxComboCtrl::ShowPopup();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxComboCtrl__SetTextIndent__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxComboCtrl::SetTextIndent(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxComboCtrl__SetTextIndent__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxComboCtrl::SetTextIndent(x);
+void test__wxDataViewCustomRenderer__LeftClick__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxDataViewCustomRenderer::LeftClick(arg1, x, arg3, arg4, arg5);
 }
 
-void test__wxDataViewCustomRenderer__Activate__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxDataViewCustomRenderer::Activate(arg1, arg2, arg3, arg4);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxDataViewCustomRenderer__Activate__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxDataViewCustomRenderer::Activate(x, arg2, arg3, arg4);
-}
-
-void test__wxDataViewCustomRenderer__Activate__arg2__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxDataViewCustomRenderer::Activate(arg1, NULL, arg3, arg4);
-}
-
-void test__wxDataViewCustomRenderer__Activate__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxDataViewCustomRenderer::Activate(arg1, arg2, x, arg4);
-}
-
-void test__wxDataViewCustomRenderer__Activate__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxDataViewCustomRenderer::Activate(arg1, arg2, arg3, x);
-}
-
-void test__wxDataViewCustomRenderer__LeftClick__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, arg4, arg5);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
-}
-
-void test__wxDataViewCustomRenderer__LeftClick__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxDataViewCustomRenderer::LeftClick(x, arg2, arg3, arg4, arg5);
-}
-
-void test__wxDataViewCustomRenderer__LeftClick__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxDataViewCustomRenderer::LeftClick(arg1, x, arg3, arg4, arg5);
+void test__wxDataViewCustomRenderer__LeftClick__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  wxDataViewCustomRenderer::LeftClick(arg1, arg2, NULL, arg4, arg5);
 }
 
-void test__wxDataViewCustomRenderer__LeftClick__arg3__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxDataViewCustomRenderer::LeftClick(arg1, arg2, NULL, arg4, arg5);
+void test__wxDataViewCustomRenderer__LeftClick__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, x, arg5);
 }
 
-void test__wxDataViewCustomRenderer__LeftClick__arg4__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, x, arg5);
+void test__wxDataViewCustomRenderer__LeftClick__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, arg4, x);
 }
 
-void test__wxDataViewCustomRenderer__LeftClick__arg5__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, arg4, x);
+void test__wxDebugContext__GetLevel__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxDebugContext::GetLevel(); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxDebugContext__GetLevel__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxDebugContext::GetLevel();
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxDebugContext__GetLevel__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxDebugContext::GetLevel();
 }
 
-void test__wxDebugContext__GetLevel__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxDebugContext::GetLevel();
+void test__wxDebugContext__SetLevel__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxDebugContext::SetLevel(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxDebugContext__SetLevel__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxDebugContext::SetLevel(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxDebugContext__SetLevel__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxDebugContext::SetLevel(x);
 }
 
-void test__wxDebugContext__SetLevel__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxDebugContext::SetLevel(x);
+void test__wxDos2UnixFilename__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxDos2UnixFilename(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxDos2UnixFilename__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxDos2UnixFilename(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxDos2UnixFilename__leakignore() {
+  char *p = malloc(10); *p=0;
+  wxDos2UnixFilename(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wxDos2UnixFilename__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    wxDos2UnixFilename(p);
-    // cppcheck-suppress memleak
+void test__wxDos2UnixFilename__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxDos2UnixFilename(NULL);
 }
 
-void test__wxDos2UnixFilename__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxDos2UnixFilename(NULL);
+void test__wxDos2UnixFilename__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxDos2UnixFilename(x);
 }
 
-void test__wxDos2UnixFilename__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxDos2UnixFilename(x);
+void test__wxFileNameFromPath__noreturn() {
+  int x = 1;
+  if (cond) { x=100; result = wxFileNameFromPath(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxFileNameFromPath__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        result = wxFileNameFromPath(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxFileNameFromPath__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxFileNameFromPath(arg1);
 }
 
-void test__wxFileNameFromPath__useretval()
-{
-    // cppcheck-suppress ignoredReturnValue
-    wxFileNameFromPath(arg1);
+void test__wxFileNameFromPath__leakignore() {
+  char *p = malloc(10); *p=0;
+  result = wxFileNameFromPath(p);
+  // cppcheck-suppress memleak
 }
 
-void test__wxFileNameFromPath__leakignore()
-{
-    char *p = malloc(10);
-    *p=0;
-    result = wxFileNameFromPath(p);
-    // cppcheck-suppress memleak
+void test__wxFileNameFromPath__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxFileNameFromPath(x);
 }
 
-void test__wxFileNameFromPath__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    result = wxFileNameFromPath(x);
+void test__wxSizerItem__SetWindow__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxSizerItem::SetWindow(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxSizerItem__SetWindow__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxSizerItem::SetWindow(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxSizerItem__SetWindow__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxSizerItem::SetWindow(NULL);
 }
 
-void test__wxSizerItem__SetWindow__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxSizerItem::SetWindow(NULL);
+void test__wxSizerItem__SetWindow__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxSizerItem::SetWindow(x);
 }
 
-void test__wxSizerItem__SetWindow__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxSizerItem::SetWindow(x);
+void test__wxSizerItem__SetSizer__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxSizerItem::SetSizer(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxSizerItem__SetSizer__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxSizerItem::SetSizer(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxSizerItem__SetSizer__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxSizerItem::SetSizer(NULL);
 }
 
-void test__wxSizerItem__SetSizer__arg1__notnull()
-{
-    // cppcheck-suppress nullPointer
-    wxSizerItem::SetSizer(NULL);
-}
-
-void test__wxSizerItem__SetSizer__arg1__notuninit()
-{
-    int x[10];
-    // cppcheck-suppress uninitvar
-    wxSizerItem::SetSizer(x);
+void test__wxSizerItem__SetSizer__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxSizerItem::SetSizer(x);
 }
-
-void test__wxSizerItem__SetSpacer__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxSizerItem::SetSpacer(arg1);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+
+void test__wxSizerItem__SetSpacer__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxSizerItem::SetSpacer(arg1); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxSizerItem__SetSpacer__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxSizerItem::SetSpacer(x);
-}
+void test__wxSizerItem__SetSpacer__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxSizerItem::SetSpacer(x);
+}
 
-void test__wxGrid__SetCellAlignment__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxGrid::SetCellAlignment(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxGrid__SetCellAlignment__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxGrid::SetCellAlignment(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxGrid__SetCellAlignment__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxGrid::SetCellAlignment(x, arg2, arg3);
+void test__wxGrid__SetCellAlignment__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxGrid::SetCellAlignment(x, arg2, arg3);
 }
 
-void test__wxGrid__SetCellAlignment__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxGrid::SetCellAlignment(arg1, x, arg3);
+void test__wxGrid__SetCellAlignment__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxGrid::SetCellAlignment(arg1, x, arg3);
 }
 
-void test__wxGrid__SetCellAlignment__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxGrid::SetCellAlignment(arg1, arg2, x);
-}
+void test__wxGrid__SetCellAlignment__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxGrid::SetCellAlignment(arg1, arg2, x);
+}
 
-void test__wxGrid__SetCellTextColour__noreturn()
-{
-    int x = 1;
-    if (cond) {
-        x=100;
-        wxGrid::SetCellTextColour(arg1, arg2, arg3);
-    }
-    // cppcheck-suppress shiftTooManyBits
-    x = 1 << x;
+void test__wxGrid__SetCellTextColour__noreturn() {
+  int x = 1;
+  if (cond) { x=100; wxGrid::SetCellTextColour(arg1, arg2, arg3); }
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
 }
 
-void test__wxGrid__SetCellTextColour__arg1__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxGrid::SetCellTextColour(x, arg2, arg3);
+void test__wxGrid__SetCellTextColour__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxGrid::SetCellTextColour(x, arg2, arg3);
 }
 
-void test__wxGrid__SetCellTextColour__arg2__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxGrid::SetCellTextColour(arg1, x, arg3);
+void test__wxGrid__SetCellTextColour__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxGrid::SetCellTextColour(arg1, x, arg3);
 }
 
-void test__wxGrid__SetCellTextColour__arg3__notuninit()
-{
-    int x;
-    // cppcheck-suppress uninitvar
-    wxGrid::SetCellTextColour(arg1, arg2, x);
+void test__wxGrid__SetCellTextColour__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxGrid::SetCellTextColour(arg1, arg2, x);
 }