diff --git a/test/cfg/generated-cfg-tests-avr.cpp b/test/cfg/generated-cfg-tests-avr.cpp
index 2ffd75ba3..701887680 100644
--- a/test/cfg/generated-cfg-tests-avr.cpp
+++ b/test/cfg/generated-cfg-tests-avr.cpp
@@ -8,616 +8,800 @@
 // => '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__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__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__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__vfprintf_P__leakignore() {
-  char *p = malloc(10); *p=0;
-  vfprintf_P(p, arg2);
-  // cppcheck-suppress memleak
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vfprintf_P(p, arg2);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  vfprintf_P(x, arg2);
+void test__puts_P__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    puts_P(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        scanf_P(arg1, arg2);
+    }
+    // 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__scanf_P__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    scanf_P(p, arg2);
+    // cppcheck-suppress memleak
+}
 
-void test__sprintf_P__leakignore() {
-  char *p = malloc(10); *p=0;
-  sprintf_P(p, arg2);
-  // cppcheck-suppress memleak
+void test__scanf_P__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    scanf_P(x, arg2);
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fscanf_P(arg1, arg2);
+    }
+    // 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__fscanf_P__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fscanf_P(p, arg2);
+    // 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__fscanf_P__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fscanf_P(x, arg2);
 }
 
-void test__vsprintf_P__leakignore() {
-  char *p = malloc(10); *p=0;
-  vsprintf_P(p, arg2);
-  // cppcheck-suppress memleak
+void test__sscanf_P__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        sscanf_P(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__sscanf_P__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    sscanf_P(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__vsnprintf_P__leakignore() {
-  char *p = malloc(10); *p=0;
-  vsnprintf_P(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__fdevopen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fdevopen(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fdevopen(NULL, arg2);
 }
 
-void test__fprintf_P__leakignore() {
-  char *p = malloc(10); *p=0;
-  fprintf_P(p, arg2);
-  // cppcheck-suppress memleak
+void test__fdevopen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fdevopen(x, arg2);
 }
 
-void test__fprintf_P__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fprintf_P(p, arg2);
+void test__fdevopen__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fdevopen(arg1, NULL);
 }
 
-void test__fprintf_P__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fprintf_P(x, arg2);
+void test__fdevopen__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fdevopen(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        ltoa(arg1, arg2, arg3);
+    }
+    // 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__ltoa__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    ltoa(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__fputs_P__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fputs_P(p, arg2);
+void test__ltoa__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ltoa(x, arg2, arg3);
 }
 
-void test__fputs_P__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fputs_P(x, arg2);
+void test__ltoa__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    ltoa(arg1, NULL, arg3);
 }
 
-void test__fputs_P__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fputs_P(arg1, p);
+void test__ltoa__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    ltoa(arg1, x, arg3);
 }
 
-void test__fputs_P__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fputs_P(arg1, x);
+void test__ltoa__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    ltoa(arg1, arg2, NULL);
 }
 
-void test__puts_P__noreturn() {
-  int x = 1;
-  if (cond) { x=100; puts_P(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ltoa__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    ltoa(arg1, arg2, x);
 }
 
-void test__puts_P__leakignore() {
-  char *p = malloc(10); *p=0;
-  puts_P(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__puts_P__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  puts_P(!x);
+void test__utoa__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    utoa(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__puts_P__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  puts_P(p);
+void test__utoa__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    utoa(x, arg2, arg3);
 }
 
-void test__puts_P__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  puts_P(x);
+void test__utoa__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    utoa(arg1, NULL, 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__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    utoa(arg1, x, arg3);
 }
 
-void test__scanf_P__leakignore() {
-  char *p = malloc(10); *p=0;
-  scanf_P(p, arg2);
-  // cppcheck-suppress memleak
+void test__utoa__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    utoa(arg1, arg2, NULL);
 }
 
-void test__scanf_P__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  scanf_P(x, arg2);
+void test__utoa__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    utoa(arg1, arg2, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        ultoa(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__ultoa__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    ultoa(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__fscanf_P__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fscanf_P(x, arg2);
+void test__ultoa__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ultoa(x, arg2, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    ultoa(arg1, NULL, arg3);
 }
 
-void test__sscanf_P__leakignore() {
-  char *p = malloc(10); *p=0;
-  sscanf_P(p, arg2);
-  // cppcheck-suppress memleak
+void test__ultoa__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    ultoa(arg1, x, arg3);
 }
 
-void test__fdevopen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fdevopen(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ultoa__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    ultoa(arg1, arg2, NULL);
 }
 
-void test__fdevopen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fdevopen(p, arg2);
+void test__ultoa__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    ultoa(arg1, arg2, x);
 }
 
-void test__fdevopen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fdevopen(x, arg2);
+void test__random__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        random();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fdevopen__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fdevopen(arg1, p);
+void test__random__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    random();
+    // cppcheck-suppress memleak
 }
 
-void test__fdevopen__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fdevopen(arg1, x);
+void test__random_r__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        random_r(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    random_r(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ltoa__leakignore() {
-  char *p = malloc(10); *p=0;
-  ltoa(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__random_r__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    random_r(NULL);
 }
 
-void test__ltoa__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ltoa(x, arg2, arg3);
+void test__srandom__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        srandom(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ltoa__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ltoa(arg1, p, arg3);
+void test__srandom__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    srandom(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ltoa__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  ltoa(arg1, x, arg3);
+void test__srandom__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    srandom(x);
 }
 
-void test__ltoa__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ltoa(arg1, arg2, p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  ltoa(arg1, arg2, x);
+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__utoa__noreturn() {
-  int x = 1;
-  if (cond) { x=100; utoa(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ffs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    ffs(p);
+    // cppcheck-suppress memleak
 }
 
-void test__utoa__leakignore() {
-  char *p = malloc(10); *p=0;
-  utoa(p, arg2, arg3);
-  // 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__utoa__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  utoa(x, arg2, arg3);
+void test__ffsl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    ffsl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__utoa__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  utoa(arg1, p, arg3);
-}
-
-void test__utoa__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  utoa(arg1, x, arg3);
-}
-
-void test__utoa__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  utoa(arg1, arg2, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ultoa(arg1, p, arg3);
-}
-
-void test__ultoa__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  ultoa(arg1, x, arg3);
-}
-
-void test__ultoa__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ultoa(arg1, arg2, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  random_r(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  dtostre(arg1, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  dtostrf(arg1, arg2, arg3, p);
-}
-
-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__ffsl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ffsl(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        ffsll(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__ffsll__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    ffsll(p);
+    // cppcheck-suppress memleak
 }
 
-void test__memccpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  memccpy(p, arg2, arg3, arg4);
+void test__ffsll__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ffsll(x);
 }
 
-void test__memccpy__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  memccpy(arg1, x, 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__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 1a605ced5..352add36c 100644
--- a/test/cfg/generated-cfg-tests-bsd.cpp
+++ b/test/cfg/generated-cfg-tests-bsd.cpp
@@ -8,254 +8,324 @@
 // => '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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fts_open(arg1, arg2, p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fts_read(p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  readpassphrase(arg1, p, arg3, arg4);
+void test__readpassphrase__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    readpassphrase(arg1, NULL, arg3, arg4);
 }
 
-void test__readpassphrase__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  readpassphrase(arg1, arg2, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strtonum(p, 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 c33bfcb04..e19dd31a9 100644
--- a/test/cfg/generated-cfg-tests-gnu.cpp
+++ b/test/cfg/generated-cfg-tests-gnu.cpp
@@ -8,1549 +8,1915 @@
 // => '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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  accept(arg1, arg2, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = atoq(p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strndupa(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strsep(arg1, p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strdupa(p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  backtrace(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = backtrace_symbols(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  backtrace_symbols_fd(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ecvt(arg1, arg2, p, arg4);
+void test__ecvt__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    ecvt(arg1, arg2, NULL, arg4);
 }
 
-void test__ecvt__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ecvt(arg1, arg2, arg3, p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  qfcvt(arg1, arg2, p, arg4);
+void test__qfcvt__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    qfcvt(arg1, arg2, NULL, arg4);
 }
 
-void test__qfcvt__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  qfcvt(arg1, arg2, arg3, p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  qgcvt(arg1, arg2, p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ecvt_r(arg1, arg2, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ecvt_r(arg1, arg2, arg3, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ecvt_r(arg1, arg2, arg3, arg4, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fcvt_r(arg1, arg2, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fcvt_r(arg1, arg2, arg3, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fcvt_r(arg1, arg2, arg3, arg4, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  qecvt_r(arg1, arg2, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  qecvt_r(arg1, arg2, arg3, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  qecvt_r(arg1, arg2, arg3, arg4, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  qfcvt_r(arg1, arg2, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  qfcvt_r(arg1, arg2, arg3, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  qfcvt_r(arg1, arg2, arg3, arg4, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strcasestr(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strcasestr(arg1, p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getresuid(p, arg2, arg3);
+void test__getresuid__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getresuid(NULL, arg2, arg3);
 }
 
-void test__getresuid__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getresuid(arg1, p, arg3);
+void test__getresuid__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getresuid(arg1, NULL, arg3);
 }
 
-void test__getresuid__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getresuid(arg1, arg2, p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getresgid(p, arg2, arg3);
+void test__getresgid__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getresgid(NULL, arg2, arg3);
 }
 
-void test__getresgid__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getresgid(arg1, p, arg3);
+void test__getresgid__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getresgid(arg1, NULL, arg3);
 }
 
-void test__getresgid__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getresgid(arg1, arg2, p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  inet_aton(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  inet_aton(arg1, p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  inet_addr(p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  inet_network(p);
-}
-
-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_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_makeaddr__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  inet_makeaddr(x, arg2);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  inet_makeaddr(arg1, x);
+void test__inet_makeaddr__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    inet_makeaddr(x, arg2);
 }
 
-void test__inet_lnaof__noreturn() {
-  int x = 1;
-  if (cond) { x=100; inet_lnaof(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__inet_makeaddr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    inet_makeaddr(arg1, x);
 }
 
-void test__inet_lnaof__leakignore() {
-  char *p = malloc(10); *p=0;
-  inet_lnaof(p);
-  // cppcheck-suppress memleak
+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__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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  inet_pton(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  inet_pton(arg1, arg2, p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  inet_ntop(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  inet_ntop(arg1, arg2, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = canonicalize_file_name(p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  execvpe(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mkostemp(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mkstemps(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mkostemps(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = memmem(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = memmem(arg1, arg2, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  memrchr(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  rawmemchr(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strchrnul(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  epoll_ctl(arg1, arg2, arg3, p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  epoll_wait(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  epoll_pwait(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  epoll_pwait(arg1, arg2, arg3, arg4, p);
+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 7dd36bd5f..5ed370baa 100644
--- a/test/cfg/generated-cfg-tests-motif.cpp
+++ b/test/cfg/generated-cfg-tests-motif.cpp
@@ -8,456 +8,614 @@
 // => '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__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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = XmStringCreateLocalized(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = XmStringCreateSimple(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  XtAsprintf(arg1, p);
-}
-
-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__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__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__XmFontListEntryFree__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    XmFontListEntryFree(x);
+}
 
-void test__XtGetSubvalues__leakignore() {
-  char *p = malloc(10); *p=0;
-  XtGetSubvalues(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
-}
+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__XtMalloc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = XtMalloc(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
-}
+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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  XtMalloc(arg1);
+void test__XmFontListAppendEntry__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = XmFontListAppendEntry(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__XtMalloc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = XtMalloc(x);
+void test__XmFontListAppendEntry__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    XmFontListAppendEntry(arg1, arg2);
 }
 
-void test__XtNew__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = XtNew(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__XmFontListAppendEntry__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = XmFontListAppendEntry(x, arg2);
 }
 
-void test__XtNew__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  XtNew(arg1);
+void test__XmFontListAppendEntry__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = XmFontListAppendEntry(arg1, x);
 }
 
-void test__XtNew__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = XtNew(x);
+void test__XmStringCreateLocalized__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = XmStringCreateLocalized(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__XtNewString__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = XtNewString(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__XmStringCreateLocalized__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    XmStringCreateLocalized(arg1);
 }
 
-void test__XtNewString__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  XtNewString(arg1);
+void test__XmStringCreateLocalized__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = XmStringCreateLocalized(p);
+    // cppcheck-suppress memleak
 }
 
-void test__XtNewString__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = XtNewString(x);
+void test__XmStringCreateLocalized__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = XmStringCreateLocalized(NULL);
 }
 
-void test__XtCalloc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = XtCalloc(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__XmStringCreateLocalized__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = XmStringCreateLocalized(x);
 }
 
-void test__XtCalloc__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  XtCalloc(arg1, arg2);
+void test__XmStringCreateSimple__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = XmStringCreateSimple(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__XtCalloc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = XtCalloc(x, arg2);
+void test__XmStringCreateSimple__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    XmStringCreateSimple(arg1);
 }
-
-void test__XtCalloc__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = XtCalloc(arg1, x);
+
+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__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__XmStringCreateSimple__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = XmStringCreateSimple(x);
 }
 
-void test__XtScreenDatabase__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  XtScreenDatabase(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__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);
 }
 
diff --git a/test/cfg/generated-cfg-tests-posix.cpp b/test/cfg/generated-cfg-tests-posix.cpp
index d8c3f2cdd..de9034513 100644
--- a/test/cfg/generated-cfg-tests-posix.cpp
+++ b/test/cfg/generated-cfg-tests-posix.cpp
@@ -8,7524 +8,9660 @@
 // => '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__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__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = a64l(p);
-  // cppcheck-suppress memleak
+void test__a64l__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = a64l(x);
 }
 
-void test__a64l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = a64l(p);
+void test__l64a__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = l64a(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__a64l__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = a64l(x);
+void test__l64a__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    l64a(arg1);
 }
 
-void test__l64a__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = l64a(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__l64a__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = l64a(p);
+    // cppcheck-suppress memleak
 }
 
-void test__l64a__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  l64a(arg1);
+void test__l64a__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = l64a(x);
 }
 
-void test__l64a__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = l64a(p);
-  // cppcheck-suppress memleak
+void test__accept__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        accept(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__l64a__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = l64a(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__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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = access(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  FD_CLR(arg1, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  FD_ISSET(arg1, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  FD_SET(arg1, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  FD_ZERO(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = fnmatch(p, arg2, arg3);
-}
-
-void test__fnmatch__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = fnmatch(x, arg2, arg3);
-}
-
-void test__fnmatch__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = fnmatch(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  truncate(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  symlink(p, arg2);
-}
-
-void test__symlink__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  symlink(x, arg2);
-}
-
-void test__symlink__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  symlink(arg1, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  open(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = creat(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  faccessat(arg1, p, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    accept(arg1, x, arg3);
 }
 
-void test__faccessat__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  faccessat(arg1, arg2, arg3, x);
+void test__accept__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    accept(arg1, arg2, x);
 }
 
-void test__acct__noreturn() {
-  int x = 1;
-  if (cond) { x=100; acct(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__leakignore() {
-  char *p = malloc(10); *p=0;
-  acct(p);
-  // cppcheck-suppress memleak
+void test__access__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    access(arg1, arg2);
 }
 
-void test__acct__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  acct(x);
+void test__access__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = access(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__alarm__noreturn() {
-  int x = 1;
-  if (cond) { x=100; alarm(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__leakignore() {
-  char *p = malloc(10); *p=0;
-  alarm(p);
-  // cppcheck-suppress memleak
+void test__access__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = access(arg1, x);
 }
-
-void test__alarm__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  alarm(x);
+
+void test__adjtime__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        adjtime(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getrpcent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getrpcent(); }
-  // 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__getrpcent__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getrpcent();
+
+void test__gettimeofday__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        gettimeofday(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getrpcent__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getrpcent();
-  // cppcheck-suppress memleak
+void test__gettimeofday__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    gettimeofday(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__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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getrpcbyname(arg1);
+void test__settimeofday__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    settimeofday(x, arg2);
 }
 
-void test__getrpcbyname__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getrpcbyname(p);
-  // cppcheck-suppress memleak
+void test__settimeofday__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    settimeofday(arg1, x);
 }
 
-void test__getrpcbyname__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = getrpcbyname(p);
-}
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = getrpcbyname(x);
-}
+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__getrpcbynumber__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getrpcbynumber(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
-}
+void test__FD_ISSET__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    FD_ISSET(arg1, NULL);
+}
 
-void test__getrpcbynumber__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getrpcbynumber(arg1);
+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__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getrpcbynumber(p);
-  // cppcheck-suppress memleak
+void test__FD_SET__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    FD_SET(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__getrpcbynumber__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getrpcbynumber(x);
+void test__FD_SET__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    FD_SET(x, arg2);
 }
 
-void test__getprotoent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getprotoent(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__FD_SET__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    FD_SET(arg1, NULL);
 }
 
-void test__getprotoent__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getprotoent();
+void test__FD_ZERO__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        FD_ZERO(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getprotoent__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getprotoent();
-  // cppcheck-suppress memleak
+void test__FD_ZERO__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    FD_ZERO(p);
+    // cppcheck-suppress memleak
 }
 
-void test__getprotobyname__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getprotobyname(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__FD_ZERO__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    FD_ZERO(NULL);
 }
 
-void test__getprotobyname__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getprotobyname(arg1);
+void test__fdatasync__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fdatasync(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__fdatasync__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fdatasync(p);
+    // cppcheck-suppress memleak
 }
 
-void test__getprotobyname__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = getprotobyname(p);
+void test__fdatasync__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fdatasync(x);
 }
 
-void test__getprotobyname__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = getprotobyname(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__getprotobynumber__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getprotobynumber(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fnmatch__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fnmatch(arg1, arg2, arg3);
 }
 
-void test__getprotobynumber__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getprotobynumber(arg1);
+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__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getprotobynumber(p);
-  // cppcheck-suppress memleak
+void test__fnmatch__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fnmatch(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__getprotobynumber__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getprotobynumber(x);
+void test__fnmatch__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = fnmatch(NULL, arg2, arg3);
 }
 
-void test__getservent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getservent(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fnmatch__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = fnmatch(x, arg2, arg3);
 }
 
-void test__getservent__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getservent();
+void test__fnmatch__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = fnmatch(arg1, NULL, arg3);
 }
 
-void test__getservent__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getservent();
-  // cppcheck-suppress memleak
+void test__fnmatch__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = fnmatch(arg1, x, arg3);
 }
 
-void test__getservbyname__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getservbyname(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fnmatch__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fnmatch(arg1, arg2, x);
 }
 
-void test__getservbyname__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getservbyname(arg1, arg2);
+void test__fsync__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fsync(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getservbyname__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getservbyname(p, arg2);
-  // cppcheck-suppress memleak
+void test__fsync__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fsync(p);
+    // cppcheck-suppress memleak
 }
 
-void test__getservbyname__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = getservbyname(p, arg2);
+void test__fsync__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fsync(x);
 }
 
-void test__getservbyname__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = getservbyname(x, arg2);
+void test__truncate__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        truncate(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getservbyname__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getservbyname(arg1, x);
+void test__truncate__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    truncate(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    truncate(NULL, arg2);
 }
 
-void test__getservbyport__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getservbyport(arg1, arg2);
+void test__truncate__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    truncate(x, arg2);
 }
 
-void test__getservbyport__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getservbyport(p, arg2);
-  // cppcheck-suppress memleak
+void test__truncate__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    truncate(arg1, x);
 }
 
-void test__getservbyport__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getservbyport(x, arg2);
+void test__ftruncate__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        ftruncate(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getservbyport__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getservbyport(arg1, x);
+void test__ftruncate__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    ftruncate(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__getnetent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getnetent(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ftruncate__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ftruncate(x, arg2);
 }
 
-void test__getnetent__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getnetent();
+void test__ftruncate__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ftruncate(arg1, x);
 }
 
-void test__getnetent__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getnetent();
-  // cppcheck-suppress memleak
+void test__flock__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        flock(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getnetbyname__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getnetbyname(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__flock__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    flock(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__getnetbyname__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getnetbyname(arg1);
+void test__flock__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    flock(x, arg2);
 }
 
-void test__getnetbyname__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getnetbyname(p);
-  // cppcheck-suppress memleak
+void test__flock__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    flock(arg1, x);
 }
 
-void test__getnetbyname__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = getnetbyname(p);
+void test__symlink__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        symlink(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getnetbyname__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = getnetbyname(x);
+void test__symlink__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    symlink(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    symlink(NULL, arg2);
 }
 
-void test__getnetbyaddr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getnetbyaddr(arg1, arg2);
+void test__symlink__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    symlink(x, arg2);
 }
 
-void test__getnetbyaddr__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getnetbyaddr(p, arg2);
-  // cppcheck-suppress memleak
+void test__symlink__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    symlink(arg1, NULL);
 }
 
-void test__getnetbyaddr__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getnetbyaddr(x, arg2);
+void test__symlink__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    symlink(arg1, x);
 }
 
-void test__getnetbyaddr__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getnetbyaddr(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__gethostent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = gethostent(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__open__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    open(NULL, arg2, arg3);
 }
 
-void test__gethostent__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  gethostent();
+void test__open__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    open(x, arg2, arg3);
 }
 
-void test__gethostent__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = gethostent();
-  // cppcheck-suppress memleak
+void test__open__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    open(arg1, x, arg3);
 }
 
-void test__gethostbyname__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = gethostbyname(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__open__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    open(arg1, arg2, x);
 }
 
-void test__gethostbyname__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  gethostbyname(arg1);
+void test__creat__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = creat(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__gethostbyname__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = gethostbyname(p);
-  // cppcheck-suppress memleak
+void test__creat__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    creat(arg1, arg2);
 }
 
-void test__gethostbyname__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = gethostbyname(p);
+void test__creat__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = creat(NULL, arg2);
 }
 
-void test__gethostbyname__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = gethostbyname(x);
+void test__creat__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = creat(x, arg2);
 }
 
-void test__gethostbyname2__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = gethostbyname2(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__creat__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = creat(arg1, x);
 }
 
-void test__gethostbyname2__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  gethostbyname2(arg1, arg2);
+void test__sleep__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        sleep(arg1);
+    }
+    // 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__sleep__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    sleep(p);
+    // cppcheck-suppress memleak
 }
 
-void test__gethostbyname2__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = gethostbyname2(p, arg2);
+void test__sleep__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    sleep(!x);
 }
 
-void test__gethostbyname2__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = gethostbyname2(x, arg2);
+void test__sleep__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sleep(x);
 }
 
-void test__gethostbyname2__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = gethostbyname2(arg1, x);
+void test__usleep__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        usleep(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    usleep(p);
+    // cppcheck-suppress memleak
 }
 
-void test__gethostbyaddr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  gethostbyaddr(arg1, arg2, arg3);
+void test__usleep__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    usleep(!x);
 }
 
-void test__gethostbyaddr__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = gethostbyaddr(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__gethostbyaddr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = gethostbyaddr(p, arg2, arg3);
+void test___exit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _exit(x);
 }
 
-void test__gethostbyaddr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = gethostbyaddr(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = gethostbyaddr(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = gethostbyaddr(arg1, arg2, x);
+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__brk__noreturn() {
-  int x = 1;
-  if (cond) { x=100; brk(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__acct__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    acct(p);
+    // cppcheck-suppress memleak
 }
 
-void test__brk__leakignore() {
-  char *p = malloc(10); *p=0;
-  brk(p);
-  // cppcheck-suppress memleak
-}
+void test__acct__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    acct(x);
+}
 
-void test__brk__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  brk(p);
+void test__alarm__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        alarm(arg1);
+    }
+    // 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__alarm__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    alarm(p);
+    // cppcheck-suppress memleak
 }
 
-void test__sbrk__leakignore() {
-  char *p = malloc(10); *p=0;
-  sbrk(p);
-  // cppcheck-suppress memleak
+void test__alarm__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    alarm(x);
 }
 
-void test__sbrk__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sbrk(x);
+void test__getrpcent__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getrpcent();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__closedir__noreturn() {
-  int x = 1;
-  if (cond) { x=100; closedir(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getrpcent__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getrpcent();
 }
 
-void test__closedir__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  closedir(!x);
+void test__getrpcent__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getrpcent();
+    // cppcheck-suppress memleak
 }
 
-void test__closedir__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  closedir(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  closedir(x);
+void test__getrpcbyname__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = getrpcbyname(x);
 }
 
-void test__strfry__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strfry(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getrpcbynumber__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getrpcbynumber(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strfry__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strfry(p);
+void test__getrpcbynumber__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getrpcbynumber(arg1);
 }
 
-void test__strsep__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strsep(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getrpcbynumber__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getrpcbynumber(p);
+    // cppcheck-suppress memleak
 }
 
-void test__strsep__leakignore() {
-  char *p = malloc(10); *p=0;
-  strsep(p, arg2);
-  // cppcheck-suppress memleak
+void test__getrpcbynumber__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getrpcbynumber(x);
 }
 
-void test__strsep__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strsep(p, arg2);
+void test__getprotoent__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getprotoent();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strsep__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strsep(x, arg2);
+void test__getprotoent__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getprotoent();
 }
 
-void test__strsep__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strsep(arg1, p);
+void test__getprotoent__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getprotoent();
+    // cppcheck-suppress memleak
 }
 
-void test__strsep__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strsep(arg1, x);
+void test__getprotobyname__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getprotobyname(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strdup__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strdup(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getprotobyname__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getprotobyname(arg1);
 }
 
-void test__strdup__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strdup(p);
+void test__getprotobyname__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getprotobyname(p);
+    // cppcheck-suppress memleak
 }
 
-void test__strdup__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strdup(x);
+void test__getprotobyname__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = getprotobyname(NULL);
 }
 
-void test__strndup__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strndup(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getprotobyname__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = getprotobyname(x);
 }
 
-void test__strndup__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strndup(p, arg2);
+void test__getprotobynumber__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getprotobynumber(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strndup__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strndup(x, arg2);
+void test__getprotobynumber__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getprotobynumber(arg1);
 }
 
-void test__strndup__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strndup(arg1, x);
+void test__getprotobynumber__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getprotobynumber(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wcsdup__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wcsdup(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getprotobynumber__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getprotobynumber(x);
 }
 
-void test__wcsdup__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcsdup(p);
+void test__getservent__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getservent();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcsdup__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcsdup(x);
+void test__getservent__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getservent();
 }
 
-void test__mkstemp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; mkstemp(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getservent__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getservent();
+    // cppcheck-suppress memleak
 }
 
-void test__mkstemp__leakignore() {
-  char *p = malloc(10); *p=0;
-  mkstemp(p);
-  // cppcheck-suppress memleak
+void test__getservbyname__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getservbyname(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__mkstemp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mkstemp(p);
+void test__getservbyname__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getservbyname(arg1, arg2);
 }
 
-void test__mkstemp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  mkstemp(x);
+void test__getservbyname__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getservbyname(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__mkdtemp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; mkdtemp(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getservbyname__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = getservbyname(NULL, arg2);
 }
 
-void test__mkdtemp__leakignore() {
-  char *p = malloc(10); *p=0;
-  mkdtemp(p);
-  // cppcheck-suppress memleak
+void test__getservbyname__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = getservbyname(x, arg2);
 }
 
-void test__mkdtemp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mkdtemp(p);
+void test__getservbyname__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getservbyname(arg1, x);
 }
 
-void test__mkdtemp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  mkdtemp(x);
+void test__getservbyport__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getservbyport(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__mktemp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = mktemp(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getservbyport__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getservbyport(arg1, arg2);
 }
 
-void test__mktemp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  mktemp(arg1);
+void test__getservbyport__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getservbyport(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__mktemp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = mktemp(p);
-  // cppcheck-suppress memleak
+void test__getservbyport__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getservbyport(x, arg2);
 }
 
-void test__mktemp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = mktemp(p);
+void test__getservbyport__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getservbyport(arg1, x);
 }
 
-void test__mktemp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = mktemp(x);
+void test__getnetent__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getnetent();
+    }
+    // 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__getnetent__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getnetent();
 }
 
-void test__getcwd__leakignore() {
-  char *p = malloc(10); *p=0;
-  getcwd(p, arg2);
-  // cppcheck-suppress memleak
+void test__getnetent__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getnetent();
+    // cppcheck-suppress memleak
 }
 
-void test__getcwd__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  getcwd(x, arg2);
+void test__getnetbyname__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getnetbyname(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getcwd__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  getcwd(arg1, x);
+void test__getnetbyname__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getnetbyname(arg1);
 }
 
-void test__mkdir__noreturn() {
-  int x = 1;
-  if (cond) { x=100; mkdir(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getnetbyname__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getnetbyname(p);
+    // cppcheck-suppress memleak
 }
 
-void test__mkdir__leakignore() {
-  char *p = malloc(10); *p=0;
-  mkdir(p, arg2);
-  // cppcheck-suppress memleak
+void test__getnetbyname__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = getnetbyname(NULL);
 }
 
-void test__mkdir__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mkdir(p, arg2);
+void test__getnetbyname__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = getnetbyname(x);
 }
 
-void test__mkdir__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  mkdir(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mkdir(arg1, x);
+void test__getnetbyaddr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getnetbyaddr(arg1, arg2);
 }
 
-void test__rmdir__noreturn() {
-  int x = 1;
-  if (cond) { x=100; rmdir(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getnetbyaddr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getnetbyaddr(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__rmdir__leakignore() {
-  char *p = malloc(10); *p=0;
-  rmdir(p);
-  // cppcheck-suppress memleak
+void test__getnetbyaddr__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getnetbyaddr(x, arg2);
 }
 
-void test__rmdir__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  rmdir(p);
+void test__getnetbyaddr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getnetbyaddr(arg1, x);
 }
 
-void test__rmdir__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  rmdir(x);
+void test__gethostent__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = gethostent();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__chdir__noreturn() {
-  int x = 1;
-  if (cond) { x=100; chdir(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__gethostent__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    gethostent();
 }
 
-void test__chdir__leakignore() {
-  char *p = malloc(10); *p=0;
-  chdir(p);
-  // cppcheck-suppress memleak
+void test__gethostent__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = gethostent();
+    // cppcheck-suppress memleak
 }
 
-void test__chdir__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  chdir(p);
+void test__gethostbyname__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = gethostbyname(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__chdir__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  chdir(x);
+void test__gethostbyname__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    gethostbyname(arg1);
 }
 
-void test__chroot__noreturn() {
-  int x = 1;
-  if (cond) { x=100; chroot(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__gethostbyname__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = gethostbyname(p);
+    // cppcheck-suppress memleak
 }
 
-void test__chroot__leakignore() {
-  char *p = malloc(10); *p=0;
-  chroot(p);
-  // cppcheck-suppress memleak
+void test__gethostbyname__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = gethostbyname(NULL);
 }
 
-void test__chroot__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  chroot(p);
+void test__gethostbyname__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = gethostbyname(x);
 }
 
-void test__chroot__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  chroot(x);
+void test__gethostbyname2__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = gethostbyname2(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__link__noreturn() {
-  int x = 1;
-  if (cond) { x=100; link(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__gethostbyname2__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    gethostbyname2(arg1, arg2);
 }
 
-void test__link__leakignore() {
-  char *p = malloc(10); *p=0;
-  link(p, arg2);
-  // cppcheck-suppress memleak
+void test__gethostbyname2__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = gethostbyname2(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__link__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  link(p, arg2);
+void test__gethostbyname2__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = gethostbyname2(NULL, arg2);
 }
 
-void test__link__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  link(x, arg2);
+void test__gethostbyname2__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = gethostbyname2(x, arg2);
 }
 
-void test__link__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  link(arg1, p);
+void test__gethostbyname2__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = gethostbyname2(arg1, x);
 }
 
-void test__link__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  link(arg1, x);
+void test__gethostbyaddr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = gethostbyaddr(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__unlink__noreturn() {
-  int x = 1;
-  if (cond) { x=100; unlink(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__gethostbyaddr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    gethostbyaddr(arg1, arg2, arg3);
 }
 
-void test__unlink__leakignore() {
-  char *p = malloc(10); *p=0;
-  unlink(p);
-  // cppcheck-suppress memleak
+void test__gethostbyaddr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = gethostbyaddr(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__unlink__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  unlink(p);
+void test__gethostbyaddr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = gethostbyaddr(NULL, arg2, arg3);
 }
 
-void test__unlink__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  unlink(x);
+void test__gethostbyaddr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = gethostbyaddr(x, arg2, arg3);
 }
 
-void test__rename__noreturn() {
-  int x = 1;
-  if (cond) { x=100; rename(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__gethostbyaddr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = gethostbyaddr(arg1, x, arg3);
 }
 
-void test__rename__leakignore() {
-  char *p = malloc(10); *p=0;
-  rename(p);
-  // cppcheck-suppress memleak
+void test__gethostbyaddr__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = gethostbyaddr(arg1, arg2, x);
 }
 
-void test__rename__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  rename(p);
+void test__brk__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        brk(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__rename__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  rename(x);
+void test__brk__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    brk(p);
+    // cppcheck-suppress memleak
 }
 
-void test__stat__noreturn() {
-  int x = 1;
-  if (cond) { x=100; stat(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__brk__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    brk(NULL);
 }
 
-void test__stat__leakignore() {
-  char *p = malloc(10); *p=0;
-  stat(p, arg2);
-  // cppcheck-suppress memleak
+void test__sbrk__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        sbrk(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__stat__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  stat(p, arg2);
+void test__sbrk__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    sbrk(p);
+    // cppcheck-suppress memleak
 }
 
-void test__stat__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  stat(x, arg2);
+void test__sbrk__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sbrk(x);
 }
 
-void test__stat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  stat(arg1, p);
+void test__closedir__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        closedir(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    closedir(!x);
 }
 
-void test__lstat__leakignore() {
-  char *p = malloc(10); *p=0;
-  lstat(p, arg2);
-  // cppcheck-suppress memleak
+void test__closedir__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    closedir(NULL);
 }
 
-void test__lstat__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  lstat(p, arg2);
+void test__closedir__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    closedir(x);
 }
 
-void test__lstat__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  lstat(x, arg2);
+void test__strfry__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strfry(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lstat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  lstat(arg1, p);
+void test__strfry__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strfry(NULL);
 }
 
-void test__fstat__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fstat(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strsep__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strsep(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fstat__leakignore() {
-  char *p = malloc(10); *p=0;
-  fstat(p, arg2);
-  // cppcheck-suppress memleak
+void test__strsep__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strsep(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__fstat__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fstat(x, arg2);
+void test__strsep__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strsep(NULL, arg2);
 }
 
-void test__fstat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fstat(arg1, p);
+void test__strsep__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strsep(x, arg2);
 }
 
-void test__chmod__noreturn() {
-  int x = 1;
-  if (cond) { x=100; chmod(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strsep__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strsep(arg1, NULL);
 }
 
-void test__chmod__leakignore() {
-  char *p = malloc(10); *p=0;
-  chmod(p, arg2);
-  // cppcheck-suppress memleak
+void test__strsep__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strsep(arg1, x);
 }
 
-void test__chmod__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  chmod(p, arg2);
+void test__strdup__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strdup(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__chmod__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  chmod(x, arg2);
+void test__strdup__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strdup(NULL);
 }
 
-void test__chmod__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  chmod(arg1, x);
+void test__strdup__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strdup(x);
 }
 
-void test__fchmod__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fchmod(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strndup__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strndup(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__strndup__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strndup(NULL, arg2);
 }
 
-void test__fchmod__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fchmod(x, arg2);
+void test__strndup__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strndup(x, arg2);
 }
 
-void test__fchmod__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fchmod(arg1, x);
+void test__strndup__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    strndup(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wcsdup(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__chown__leakignore() {
-  char *p = malloc(10); *p=0;
-  chown(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__wcsdup__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcsdup(NULL);
 }
 
-void test__chown__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  chown(p, arg2, arg3);
+void test__wcsdup__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcsdup(x);
 }
 
-void test__chown__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  chown(x, arg2, arg3);
+void test__mkstemp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        mkstemp(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__chown__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  chown(arg1, x, arg3);
+void test__mkstemp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    mkstemp(p);
+    // cppcheck-suppress memleak
 }
 
-void test__chown__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  chown(arg1, arg2, x);
+void test__mkstemp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    mkstemp(NULL);
 }
 
-void test__lchown__noreturn() {
-  int x = 1;
-  if (cond) { x=100; lchown(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__mkstemp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    mkstemp(x);
 }
 
-void test__lchown__leakignore() {
-  char *p = malloc(10); *p=0;
-  lchown(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__mkdtemp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        mkdtemp(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lchown__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  lchown(p, arg2, arg3);
+void test__mkdtemp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    mkdtemp(p);
+    // cppcheck-suppress memleak
 }
 
-void test__lchown__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  lchown(x, arg2, arg3);
+void test__mkdtemp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    mkdtemp(NULL);
 }
 
-void test__lchown__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  lchown(arg1, x, arg3);
+void test__mkdtemp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    mkdtemp(x);
 }
 
-void test__lchown__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  lchown(arg1, arg2, x);
+void test__mktemp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = mktemp(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__mktemp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    mktemp(arg1);
 }
 
-void test__fchown__leakignore() {
-  char *p = malloc(10); *p=0;
-  fchown(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__mktemp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = mktemp(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fchown__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fchown(x, arg2, arg3);
+void test__mktemp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = mktemp(NULL);
 }
 
-void test__fchown__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fchown(arg1, x, arg3);
+void test__mktemp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = mktemp(x);
 }
 
-void test__fchown__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fchown(arg1, arg2, x);
+void test__getcwd__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        getcwd(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__getcwd__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    getcwd(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__times__leakignore() {
-  char *p = malloc(10); *p=0;
-  times(p);
-  // cppcheck-suppress memleak
+void test__getcwd__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    getcwd(x, arg2);
 }
 
-void test__times__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  times(x);
+void test__getcwd__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    getcwd(arg1, x);
 }
 
-void test__utime__noreturn() {
-  int x = 1;
-  if (cond) { x=100; utime(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__mkdir__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        mkdir(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__utime__leakignore() {
-  char *p = malloc(10); *p=0;
-  utime(p, arg2);
-  // cppcheck-suppress memleak
+void test__mkdir__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    mkdir(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__utime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  utime(p, arg2);
+void test__mkdir__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    mkdir(NULL, arg2);
 }
 
-void test__utime__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  utime(x, arg2);
+void test__mkdir__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    mkdir(x, arg2);
 }
 
-void test__utime__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  utime(arg1, x);
+void test__mkdir__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mkdir(arg1, x);
 }
 
-void test__utimes__noreturn() {
-  int x = 1;
-  if (cond) { x=100; utimes(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__rmdir__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        rmdir(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__utimes__leakignore() {
-  char *p = malloc(10); *p=0;
-  utimes(p, arg2);
-  // cppcheck-suppress memleak
+void test__rmdir__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    rmdir(p);
+    // cppcheck-suppress memleak
 }
 
-void test__utimes__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  utimes(p, arg2);
+void test__rmdir__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    rmdir(NULL);
 }
 
-void test__utimes__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  utimes(x, arg2);
+void test__rmdir__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    rmdir(x);
 }
 
-void test__utimes__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  utimes(arg1, x);
+void test__chdir__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        chdir(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__opendir__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = opendir(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__chdir__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    chdir(p);
+    // cppcheck-suppress memleak
 }
 
-void test__opendir__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  opendir(arg1);
+void test__chdir__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    chdir(NULL);
 }
 
-void test__opendir__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = opendir(p);
+void test__chdir__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    chdir(x);
 }
 
-void test__opendir__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = opendir(x);
+void test__chroot__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        chroot(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fdopendir__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fdopendir(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__chroot__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    chroot(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fdopendir__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fdopendir(arg1);
+void test__chroot__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    chroot(NULL);
 }
 
-void test__fdopendir__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fdopendir(x);
+void test__chroot__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    chroot(x);
 }
 
-void test__isatty__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isatty(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__link__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        link(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__isatty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isatty(arg1);
+void test__link__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    link(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__isatty__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isatty(p);
-  // cppcheck-suppress memleak
+void test__link__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    link(NULL, arg2);
 }
 
-void test__isatty__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isatty(x);
+void test__link__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    link(x, arg2);
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    link(arg1, NULL);
 }
 
-void test__popen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  popen(arg1, arg2);
+void test__link__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    link(arg1, x);
 }
 
-void test__popen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = popen(p, arg2);
+void test__unlink__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        unlink(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__popen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = popen(x, arg2);
+void test__unlink__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    unlink(p);
+    // cppcheck-suppress memleak
 }
 
-void test__popen__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = popen(arg1, p);
+void test__unlink__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    unlink(NULL);
 }
 
-void test__popen__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = popen(arg1, x);
+void test__unlink__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    unlink(x);
 }
 
-void test__pclose__noreturn() {
-  int x = 1;
-  if (cond) { x=100; pclose(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__rename__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        rename(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__pclose__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  pclose(p);
+void test__rename__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    rename(p);
+    // cppcheck-suppress memleak
 }
 
-void test__pclose__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  pclose(x);
+void test__rename__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    rename(NULL);
 }
 
-void test__socket__noreturn() {
-  int x = 1;
-  if (cond) { x=100; socket(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__rename__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    rename(x);
 }
 
-void test__socket__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  socket(x, arg2, arg3);
+void test__stat__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        stat(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__socket__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  socket(arg1, x, arg3);
+void test__stat__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    stat(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__socket__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  socket(arg1, arg2, x);
+void test__stat__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    stat(NULL, arg2);
 }
 
-void test__nice__noreturn() {
-  int x = 1;
-  if (cond) { x=100; nice(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__stat__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    stat(x, arg2);
 }
 
-void test__nice__leakignore() {
-  char *p = malloc(10); *p=0;
-  nice(p);
-  // cppcheck-suppress memleak
+void test__stat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    stat(arg1, NULL);
 }
 
-void test__nice__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  nice(x);
+void test__lstat__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        lstat(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__pause__noreturn() {
-  int x = 1;
-  if (cond) { x=100; pause(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__lstat__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    lstat(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__pause__leakignore() {
-  char *p = malloc(10); *p=0;
-  pause();
-  // cppcheck-suppress memleak
+void test__lstat__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    lstat(NULL, arg2);
 }
 
-void test__close__noreturn() {
-  int x = 1;
-  if (cond) { x=100; close(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__lstat__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    lstat(x, arg2);
 }
 
-void test__close__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  close(x);
+void test__lstat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    lstat(arg1, NULL);
 }
 
-void test__confstr__noreturn() {
-  int x = 1;
-  if (cond) { x=100; confstr(arg1, arg2, arg3); }
-  // 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__confstr__leakignore() {
-  char *p = malloc(10); *p=0;
-  confstr(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__fstat__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fstat(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__confstr__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  confstr(x, arg2, arg3);
+void test__fstat__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fstat(x, arg2);
 }
 
-void test__confstr__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  confstr(arg1, x, arg3);
+void test__fstat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fstat(arg1, NULL);
 }
 
-void test__confstr__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  confstr(arg1, arg2, x);
+void test__chmod__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        chmod(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fpathconf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fpathconf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__chmod__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    chmod(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__fpathconf__leakignore() {
-  char *p = malloc(10); *p=0;
-  fpathconf(p, arg2);
-  // cppcheck-suppress memleak
+void test__chmod__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    chmod(NULL, arg2);
 }
 
-void test__fpathconf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fpathconf(x, arg2);
+void test__chmod__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    chmod(x, arg2);
 }
 
-void test__fpathconf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fpathconf(arg1, x);
+void test__chmod__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    chmod(arg1, x);
 }
 
-void test__pathconf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; pathconf(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__pathconf__leakignore() {
-  char *p = malloc(10); *p=0;
-  pathconf(p, arg2);
-  // cppcheck-suppress memleak
+void test__fchmod__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fchmod(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__pathconf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  pathconf(p, arg2);
+void test__fchmod__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fchmod(x, arg2);
 }
 
-void test__pathconf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  pathconf(x, arg2);
+void test__fchmod__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fchmod(arg1, x);
 }
 
-void test__pathconf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  pathconf(arg1, x);
+void test__chown__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        chown(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__sysconf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; sysconf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__chown__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    chown(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__sysconf__leakignore() {
-  char *p = malloc(10); *p=0;
-  sysconf(p);
-  // cppcheck-suppress memleak
+void test__chown__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    chown(NULL, arg2, arg3);
 }
 
-void test__sysconf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sysconf(x);
+void test__chown__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    chown(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    chown(arg1, x, arg3);
 }
 
-void test__fdopen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fdopen(arg1, arg2);
+void test__chown__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    chown(arg1, arg2, x);
 }
 
-void test__fdopen__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fdopen(x, 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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = fdopen(arg1, p);
+void test__lchown__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    lchown(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__fdopen__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = fdopen(arg1, x);
+void test__lchown__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    lchown(NULL, arg2, arg3);
 }
 
-void test__random__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = random(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__lchown__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    lchown(x, arg2, arg3);
 }
 
-void test__random__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  random();
+void test__lchown__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    lchown(arg1, x, arg3);
 }
 
-void test__srandom__noreturn() {
-  int x = 1;
-  if (cond) { x=100; srandom(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__lchown__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    lchown(arg1, arg2, x);
 }
 
-void test__rewinddir__noreturn() {
-  int x = 1;
-  if (cond) { x=100; rewinddir(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__leakignore() {
-  char *p = malloc(10); *p=0;
-  rewinddir(p);
-  // cppcheck-suppress memleak
+void test__fchown__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fchown(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__rewinddir__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  rewinddir(p);
+void test__fchown__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fchown(x, arg2, arg3);
 }
 
-void test__rewinddir__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  rewinddir(x);
+void test__fchown__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fchown(arg1, x, arg3);
 }
 
-void test__seekdir__noreturn() {
-  int x = 1;
-  if (cond) { x=100; seekdir(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fchown__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fchown(arg1, arg2, x);
 }
 
-void test__seekdir__leakignore() {
-  char *p = malloc(10); *p=0;
-  seekdir(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__seekdir__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  seekdir(p, arg2);
+void test__times__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    times(p);
+    // cppcheck-suppress memleak
 }
 
-void test__seekdir__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  seekdir(x, arg2);
+void test__times__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    times(x);
 }
 
-void test__seekdir__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  seekdir(arg1, x);
+void test__utime__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        utime(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__rand_r__noreturn() {
-  int x = 1;
-  if (cond) { x=100; rand_r(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__utime__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    utime(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__rand_r__leakignore() {
-  char *p = malloc(10); *p=0;
-  rand_r(p);
-  // cppcheck-suppress memleak
+void test__utime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    utime(NULL, arg2);
 }
 
-void test__rand_r__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  rand_r(p);
+void test__utime__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    utime(x, arg2);
 }
 
-void test__strcasecmp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strcasecmp(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__utime__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    utime(arg1, x);
 }
 
-void test__strcasecmp__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((strcasecmp(arg1, arg2) > 10) || (strcasecmp(arg1, arg2) < 100)) {}
+void test__utimes__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        utimes(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strcasecmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  strcasecmp(p, arg2);
-  // cppcheck-suppress memleak
+void test__utimes__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    utimes(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__strcasecmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strcasecmp(p, arg2);
+void test__utimes__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    utimes(NULL, arg2);
 }
 
-void test__strcasecmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strcasecmp(x, arg2);
+void test__utimes__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    utimes(x, arg2);
 }
 
-void test__strcasecmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strcasecmp(arg1, p);
+void test__utimes__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    utimes(arg1, x);
 }
 
-void test__strcasecmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strcasecmp(arg1, x);
+void test__opendir__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = opendir(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strncasecmp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strncasecmp(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__opendir__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    opendir(arg1);
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = opendir(NULL);
 }
 
-void test__strncasecmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  strncasecmp(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__opendir__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = opendir(x);
 }
 
-void test__strncasecmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strncasecmp(p, arg2, arg3);
+void test__fdopendir__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fdopendir(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strncasecmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strncasecmp(x, arg2, arg3);
+void test__fdopendir__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fdopendir(arg1);
 }
 
-void test__strncasecmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strncasecmp(arg1, p, arg3);
+void test__fdopendir__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fdopendir(x);
 }
 
-void test__strncasecmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strncasecmp(arg1, x, arg3);
+void test__isatty__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = isatty(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strncasecmp__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  strncasecmp(arg1, arg2, !x);
+void test__isatty__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isatty(arg1);
 }
 
-void test__read__leakignore() {
-  char *p = malloc(10); *p=0;
-  read(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__isatty__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isatty(p);
+    // cppcheck-suppress memleak
 }
 
-void test__read__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  read(x, arg2, arg3);
+void test__isatty__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isatty(x);
 }
 
-void test__read__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  read(arg1, arg2, x);
+void test__popen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = popen(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__popen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    popen(arg1, arg2);
 }
 
-void test__write__leakignore() {
-  char *p = malloc(10); *p=0;
-  write(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__popen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = popen(NULL, arg2);
 }
 
-void test__write__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  write(x, arg2, arg3);
+void test__popen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = popen(x, arg2);
 }
 
-void test__write__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  write(arg1, x, arg3);
+void test__popen__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = popen(arg1, NULL);
 }
 
-void test__write__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  write(arg1, arg2, x);
+void test__popen__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = popen(arg1, x);
 }
 
-void test__recv__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  recv(x, arg2, arg3, arg4);
+void test__pclose__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        pclose(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__recv__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  recv(arg1, arg2, x, arg4);
+void test__pclose__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    pclose(NULL);
 }
 
-void test__recv__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  recv(arg1, arg2, arg3, x);
+void test__pclose__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    pclose(x);
 }
 
-void test__recvfrom__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  recvfrom(x, arg2, arg3, arg4, arg5, arg6);
+void test__socket__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        socket(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__recvfrom__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  recvfrom(arg1, arg2, x, arg4, arg5, arg6);
+void test__socket__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    socket(x, arg2, arg3);
 }
-
-void test__recvfrom__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  recvfrom(arg1, arg2, arg3, x, arg5, arg6);
+
+void test__socket__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    socket(arg1, x, arg3);
 }
 
-void test__recvmsg__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  recvmsg(x, arg2, arg3);
+void test__socket__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    socket(arg1, arg2, x);
 }
 
-void test__recvmsg__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  recvmsg(arg1, arg2, x);
+void test__nice__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        nice(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__send__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  send(x, arg2, arg3, arg4);
+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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  send(arg1, arg2, x, 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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  send(arg1, arg2, arg3, x);
+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__sendto__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sendto(x, arg2, arg3, arg4, arg5, arg6);
+void test__pathconf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    pathconf(NULL, arg2);
 }
 
-void test__sendto__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sendto(arg1, arg2, x, arg4, arg5, arg6);
+void test__pathconf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    pathconf(x, arg2);
 }
 
-void test__sendto__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sendto(arg1, arg2, arg3, x, 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__sendmsg__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sendmsg(x, arg2, arg3);
+void test__sysconf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    sysconf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__sendmsg__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sendmsg(arg1, x, arg3);
+void test__sysconf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sysconf(x);
 }
 
-void test__sendmsg__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sendmsg(arg1, arg2, x);
+void test__fdopen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fdopen(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fdopen(arg1, arg2);
 }
 
-void test__mmap__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  mmap(arg1, arg2, arg3, arg4, arg5, arg6);
+void test__fdopen__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fdopen(x, arg2);
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = fdopen(arg1, NULL);
 }
 
-void test__mmap__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = mmap(x, arg2, arg3, arg4, arg5, arg6);
+void test__fdopen__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = fdopen(arg1, x);
 }
 
-void test__mmap__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = mmap(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = mmap(arg1, arg2, x, arg4, arg5, arg6);
+void test__random__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    random();
 }
 
-void test__mmap__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = mmap(arg1, arg2, arg3, x, arg5, arg6);
+void test__srandom__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        srandom(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__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__arg6__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = mmap(arg1, arg2, arg3, arg4, arg5, x);
+void test__rewinddir__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    rewinddir(NULL);
 }
 
-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__rewinddir__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    rewinddir(x);
 }
 
-void test__mmap64__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  mmap64(arg1, arg2, arg3, arg4, arg5, arg6);
+void test__seekdir__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        seekdir(arg1, arg2);
+    }
+    // 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__seekdir__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    seekdir(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__mmap64__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = mmap64(x, arg2, arg3, arg4, arg5, arg6);
+void test__seekdir__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    seekdir(NULL, arg2);
 }
 
-void test__mmap64__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = mmap64(arg1, x, arg3, arg4, arg5, arg6);
+void test__seekdir__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    seekdir(x, arg2);
 }
 
-void test__mmap64__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = mmap64(arg1, arg2, x, arg4, arg5, arg6);
+void test__seekdir__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    seekdir(arg1, x);
 }
 
-void test__mmap64__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = mmap64(arg1, arg2, arg3, x, 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__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = mmap64(arg1, arg2, arg3, arg4, x, arg6);
+void test__rand_r__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    rand_r(p);
+    // cppcheck-suppress memleak
 }
 
-void test__mmap64__arg6__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = mmap64(arg1, arg2, arg3, arg4, arg5, x);
+void test__rand_r__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    rand_r(NULL);
 }
 
-void test__munmap__noreturn() {
-  int x = 1;
-  if (cond) { x=100; munmap(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strcasecmp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strcasecmp(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__munmap__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  munmap(p, arg2);
+void test__strcasecmp__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((strcasecmp(arg1, arg2) > 10) || (strcasecmp(arg1, arg2) < 100)) {}
 }
 
-void test__munmap__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  munmap(x, arg2);
+void test__strcasecmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strcasecmp(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__munmap__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  munmap(arg1, x);
+void test__strcasecmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strcasecmp(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strcasecmp(x, arg2);
 }
 
-void test__openlog__leakignore() {
-  char *p = malloc(10); *p=0;
-  openlog(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__strcasecmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strcasecmp(arg1, NULL);
 }
 
-void test__openlog__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  openlog(x, arg2, arg3);
+void test__strcasecmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strcasecmp(arg1, x);
 }
 
-void test__openlog__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  openlog(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  openlog(arg1, arg2, x);
+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__fcntl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fcntl(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strncasecmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strncasecmp(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__fcntl__leakignore() {
-  char *p = malloc(10); *p=0;
-  fcntl(p, arg2);
-  // cppcheck-suppress memleak
+void test__strncasecmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strncasecmp(NULL, arg2, arg3);
 }
 
-void test__fcntl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fcntl(x, arg2);
+void test__strncasecmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strncasecmp(x, arg2, arg3);
 }
 
-void test__fcntl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fcntl(arg1, x);
+void test__strncasecmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strncasecmp(arg1, NULL, arg3);
 }
 
-void test__ioctl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; ioctl(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strncasecmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strncasecmp(arg1, x, arg3);
 }
 
-void test__ioctl__leakignore() {
-  char *p = malloc(10); *p=0;
-  ioctl(p, arg2);
-  // cppcheck-suppress memleak
+void test__strncasecmp__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    strncasecmp(arg1, arg2, !x);
 }
 
-void test__ioctl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ioctl(x, arg2);
+void test__read__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    read(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__ioctl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ioctl(arg1, x);
+void test__read__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    read(x, arg2, arg3);
 }
 
-void test__syslog__noreturn() {
-  int x = 1;
-  if (cond) { x=100; syslog(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__read__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    read(arg1, arg2, x);
 }
 
-void test__syslog__leakignore() {
-  char *p = malloc(10); *p=0;
-  syslog(p, arg2);
-  // cppcheck-suppress memleak
+void test__write__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        write(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__syslog__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  syslog(x, arg2);
+void test__write__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    write(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__vsyslog__noreturn() {
-  int x = 1;
-  if (cond) { x=100; vsyslog(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__write__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    write(x, arg2, arg3);
 }
 
-void test__vsyslog__leakignore() {
-  char *p = malloc(10); *p=0;
-  vsyslog(p, arg2);
-  // cppcheck-suppress memleak
+void test__write__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    write(arg1, x, arg3);
 }
 
-void test__vsyslog__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  vsyslog(x, arg2);
+void test__write__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    write(arg1, arg2, x);
 }
 
-void test__getgid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getgid(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__recv__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    recv(x, arg2, arg3, arg4);
 }
 
-void test__getgid__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getgid();
+void test__recv__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    recv(arg1, arg2, x, arg4);
 }
 
-void test__getegid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getegid(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__recv__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    recv(arg1, arg2, arg3, x);
 }
 
-void test__getegid__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getegid();
+void test__recvfrom__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    recvfrom(x, arg2, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    recvfrom(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__getuid__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getuid();
+void test__recvfrom__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    recvfrom(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__getuid__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getuid();
-  // cppcheck-suppress memleak
+void test__recvmsg__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    recvmsg(x, arg2, arg3);
 }
 
-void test__getsid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getsid(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__recvmsg__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    recvmsg(arg1, arg2, x);
 }
 
-void test__getsid__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getsid(arg1);
+void test__send__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    send(x, arg2, arg3, arg4);
 }
 
-void test__getsid__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getsid(p);
-  // cppcheck-suppress memleak
+void test__send__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    send(arg1, arg2, x, arg4);
 }
 
-void test__getsid__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getsid(x);
+void test__send__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    send(arg1, arg2, arg3, x);
 }
 
-void test__geteuid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = geteuid(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__sendto__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sendto(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__geteuid__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  geteuid();
+void test__sendto__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sendto(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__geteuid__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = geteuid();
-  // cppcheck-suppress memleak
+void test__sendto__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sendto(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__getppid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getppid(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__sendmsg__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sendmsg(x, arg2, arg3);
 }
 
-void test__getppid__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getppid();
+void test__sendmsg__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sendmsg(arg1, x, arg3);
 }
 
-void test__getppid__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getppid();
-  // cppcheck-suppress memleak
+void test__sendmsg__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sendmsg(arg1, arg2, x);
 }
 
-void test__getpid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getpid(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getpid();
+void test__mmap__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    mmap(arg1, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__getpid__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getpid();
-  // cppcheck-suppress memleak
+void test__mmap__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = mmap(p, arg2, arg3, arg4, arg5, arg6);
+    // cppcheck-suppress memleak
 }
 
-void test__getpgrp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getpgrp(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__mmap__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = mmap(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__getpgrp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getpgrp();
+void test__mmap__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = mmap(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__getpgrp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getpgrp();
-  // cppcheck-suppress memleak
+void test__mmap__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = mmap(arg1, arg2, x, arg4, 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__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = mmap(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__getpgid__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getpgid(arg1);
+void test__mmap__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = mmap(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__getpgid__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getpgid(p);
-  // cppcheck-suppress memleak
+void test__mmap__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = mmap(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__getpgid__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getpgid(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__setuid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = setuid(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__mmap64__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    mmap64(arg1, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__setuid__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  setuid(arg1);
+void test__mmap64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = mmap64(p, arg2, arg3, arg4, arg5, arg6);
+    // cppcheck-suppress memleak
 }
 
-void test__setuid__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = setuid(p);
-  // cppcheck-suppress memleak
+void test__mmap64__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = mmap64(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__setuid__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = setuid(x);
+void test__mmap64__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = mmap64(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = mmap64(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__seteuid__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  seteuid(arg1);
+void test__mmap64__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = mmap64(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__seteuid__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = seteuid(p);
-  // cppcheck-suppress memleak
+void test__mmap64__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = mmap64(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__seteuid__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = seteuid(x);
+void test__mmap64__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = mmap64(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__setgid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = setgid(arg1); }
-  // 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__setgid__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  setgid(arg1);
+void test__munmap__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    munmap(NULL, arg2);
 }
 
-void test__setgid__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = setgid(p);
-  // cppcheck-suppress memleak
+void test__munmap__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    munmap(x, arg2);
 }
 
-void test__setgid__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = setgid(x);
+void test__munmap__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    munmap(arg1, x);
 }
 
-void test__setegid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = setegid(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  setegid(arg1);
+void test__openlog__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    openlog(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__setegid__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = setegid(p);
-  // cppcheck-suppress memleak
+void test__openlog__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    openlog(x, arg2, arg3);
 }
 
-void test__setegid__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = setegid(x);
+void test__openlog__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    openlog(arg1, x, arg3);
 }
 
-void test__setpgid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; setpgid(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__openlog__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    openlog(arg1, arg2, x);
 }
 
-void test__setpgid__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setpgid(x, arg2);
-}
+void test__fcntl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fcntl(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
+}
 
-void test__setpgid__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setpgid(arg1, x);
+void test__fcntl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fcntl(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__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__setpgrp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; setpgrp(); }
-  // 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__setregid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; setregid(arg1, arg2); }
-  // 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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setregid(x, arg2);
+
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setregid(arg1, x);
+
+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__setreuid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; setreuid(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__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__getsid__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getsid(x);
+}
 
-void test__setfsuid__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setfsuid(x);
-}
+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__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__geteuid__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = geteuid();
+    // cppcheck-suppress memleak
+}
 
-void test__getwd__noreturn() {
-  int x = 1;
-  if (cond) { x=100; getwd(arg1); }
-  // 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__leakignore() {
-  char *p = malloc(10); *p=0;
-  getwd(p);
-  // cppcheck-suppress memleak
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getwd(p);
+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__htonl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; htonl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
-}
+void test__getpid__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getpid();
+    // cppcheck-suppress memleak
+}
 
-void test__htonl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  htonl(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__htons__noreturn() {
-  int x = 1;
-  if (cond) { x=100; htons(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getpgrp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getpgrp();
+    // cppcheck-suppress memleak
 }
-
-void test__htons__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  htons(x);
+
+void test__getpgid__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getpgid(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
-
-void test__ntohl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; ntohl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+
+void test__getpgid__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getpgid(arg1);
 }
-
-void test__ntohl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ntohl(x);
+
+void test__getpgid__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getpgid(p);
+    // cppcheck-suppress memleak
 }
-
-void test__ntohs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; ntohs(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+
+void test__getpgid__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getpgid(x);
 }
 
-void test__ntohs__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ntohs(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__mq_close__noreturn() {
-  int x = 1;
-  if (cond) { x=100; mq_close(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__setuid__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = setuid(p);
+    // cppcheck-suppress memleak
 }
 
-void test__mq_close__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mq_close(x);
+void test__setuid__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = setuid(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = seteuid(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
-
-void test__mq_getattr__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mq_getattr(x, arg2);
+
+void test__seteuid__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    seteuid(arg1);
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = seteuid(p);
+    // cppcheck-suppress memleak
 }
 
-void test__mq_notify__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mq_notify(p, arg2);
-}
+void test__seteuid__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = seteuid(x);
+}
 
-void test__mq_notify__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  mq_notify(x, arg2);
-}
+void test__setgid__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = setgid(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__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_receive__noreturn() {
-  int x = 1;
-  if (cond) { x=100; mq_receive(arg1, arg2, arg3, arg4); }
-  // 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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mq_receive(x, arg2, arg3, arg4);
+void test__dbm_close__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    dbm_close(NULL);
 }
 
-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_close__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    dbm_close(x);
 }
 
-void test__mq_send__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mq_send(x, arg2, arg3, arg4);
+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_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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    dbm_delete(NULL, arg2);
 }
 
-void test__mq_setattr__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mq_setattr(x, arg2, arg3);
+void test__dbm_delete__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    dbm_delete(x, arg2);
 }
 
-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_delete__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    dbm_delete(arg1, x);
 }
 
-void test__mq_timedreceive__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mq_timedreceive(x, arg2, arg3, arg4, arg5);
+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_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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    dbm_error(arg1);
 }
 
-void test__mq_timedsend__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mq_timedsend(x, arg2, arg3, arg4, arg5);
+void test__dbm_error__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = dbm_error(NULL);
 }
 
-void test__mq_unlink__noreturn() {
-  int x = 1;
-  if (cond) { x=100; mq_unlink(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__dbm_error__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = dbm_error(x);
 }
 
-void test__mq_unlink__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mq_unlink(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  mq_unlink(x);
+void test__dbm_fetch__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    dbm_fetch(arg1, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = dbm_fetch(NULL, arg2);
 }
 
-void test__dbm_clearerr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  dbm_clearerr(p);
+void test__dbm_fetch__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = dbm_fetch(x, arg2);
 }
 
-void test__dbm_clearerr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  dbm_clearerr(x);
+void test__dbm_fetch__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = dbm_fetch(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = dbm_firstkey(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__dbm_close__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  dbm_close(p);
+void test__dbm_firstkey__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    dbm_firstkey(arg1);
 }
 
-void test__dbm_close__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  dbm_close(x);
+void test__dbm_firstkey__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = dbm_firstkey(NULL);
 }
 
-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_firstkey__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = dbm_firstkey(x);
 }
 
-void test__dbm_delete__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  dbm_delete(p, arg2);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  dbm_delete(x, arg2);
+void test__dbm_nextkey__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    dbm_nextkey(arg1);
 }
 
-void test__dbm_delete__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  dbm_delete(arg1, x);
+void test__dbm_nextkey__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = dbm_nextkey(NULL);
 }
 
-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_nextkey__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = dbm_nextkey(x);
 }
 
-void test__dbm_error__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  dbm_error(arg1);
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = dbm_error(p);
+void test__dbm_open__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    dbm_open(NULL, arg2, arg3);
 }
 
-void test__dbm_error__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = dbm_error(x);
+void test__dbm_open__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    dbm_open(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    dbm_open(arg1, x, arg3);
 }
 
-void test__dbm_fetch__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  dbm_fetch(arg1, arg2);
+void test__dbm_open__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    dbm_open(arg1, arg2, x);
 }
 
-void test__dbm_fetch__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = dbm_fetch(p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = dbm_fetch(x, arg2);
+void test__dbm_store__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    dbm_store(NULL, arg2, arg3, arg4);
 }
 
-void test__dbm_fetch__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = dbm_fetch(arg1, x);
+void test__dbm_store__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    dbm_store(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    dbm_store(arg1, x, arg3, arg4);
 }
 
-void test__dbm_firstkey__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  dbm_firstkey(arg1);
+void test__dbm_store__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    dbm_store(arg1, arg2, x, arg4);
 }
 
-void test__dbm_firstkey__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = dbm_firstkey(p);
+void test__dbm_store__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    dbm_store(arg1, arg2, arg3, x);
 }
 
-void test__dbm_firstkey__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = dbm_firstkey(x);
+void test__freeaddrinfo__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        freeaddrinfo(arg1);
+    }
+    // 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__freeaddrinfo__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    freeaddrinfo(NULL);
 }
-
-void test__dbm_nextkey__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  dbm_nextkey(arg1);
+
+void test__freeaddrinfo__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    freeaddrinfo(x);
 }
 
-void test__dbm_nextkey__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = dbm_nextkey(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = dbm_nextkey(x);
+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_open__noreturn() {
-  int x = 1;
-  if (cond) { x=100; dbm_open(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  dbm_open(p, arg2, arg3);
+void test__getpwent__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getpwent();
 }
 
-void test__dbm_open__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  dbm_open(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  dbm_open(arg1, x, arg3);
-}
+void test__getpwnam__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getpwnam(arg1);
+}
 
-void test__dbm_open__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  dbm_open(arg1, arg2, x);
+void test__getpwnam__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getpwnam(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strtok_r(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__dbm_store__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  dbm_store(p, arg2, arg3, arg4);
-}
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  dbm_store(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  dbm_store(arg1, x, arg3, arg4);
+void test__strtok_r__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    strtok_r(x, arg2, arg3);
 }
 
-void test__dbm_store__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  dbm_store(arg1, arg2, x, arg4);
+void test__strtok_r__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strtok_r(arg1, NULL, arg3);
 }
 
-void test__dbm_store__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  dbm_store(arg1, arg2, arg3, x);
+void test__strtok_r__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strtok_r(arg1, x, arg3);
 }
 
-void test__freeaddrinfo__noreturn() {
-  int x = 1;
-  if (cond) { x=100; freeaddrinfo(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  freeaddrinfo(p);
+void test__getpwnam_r__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getpwnam_r(arg1, arg2, arg3, arg4, arg5);
 }
 
-void test__freeaddrinfo__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  freeaddrinfo(x);
+void test__getpwnam_r__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getpwnam_r(x, arg2, arg3, arg4, 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__getpwnam_r__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getpwnam_r(arg1, arg2, arg3, x, arg5);
 }
 
-void test__getaddrinfo__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  getaddrinfo(x, arg2, arg3, arg4);
+void test__getpwuid__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getpwuid(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getaddrinfo__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  getaddrinfo(arg1, x, arg3, arg4);
+void test__getpwuid__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getpwuid(arg1);
 }
 
-void test__getaddrinfo__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  getaddrinfo(arg1, arg2, x, arg4);
+void test__getpwuid__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getpwuid(x);
 }
 
-void test__getaddrinfo__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  getaddrinfo(arg1, arg2, arg3, x);
+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__endhostent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; endhostent(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getpwuid_r__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    getpwuid_r(x, arg2, arg3, arg4, arg5);
 }
 
-void test__sethostent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; sethostent(arg1); }
-  // 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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sethostent(x);
+void test__setpwent__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        setpwent();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__uname__noreturn() {
-  int x = 1;
-  if (cond) { x=100; uname(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  uname(p);
+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__endpwent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; endpwent(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+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__getpwent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getpwent(); }
-  // 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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getpwent();
+void test__catgets__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = catgets(arg1, arg2, arg3, x);
 }
 
-void test__getpwnam__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getpwnam(arg1); }
-  // 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__getpwnam__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getpwnam(arg1);
+void test__catopen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    catopen(NULL, arg2);
 }
 
-void test__getpwnam__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getpwnam(x);
+void test__catopen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    catopen(x, arg2);
 }
 
-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__catopen__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    catopen(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        poll(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strtok_r__leakignore() {
-  char *p = malloc(10); *p=0;
-  strtok_r(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__poll__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    poll(x, arg2, arg3);
 }
 
-void test__strtok_r__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strtok_r(x, arg2, arg3);
+void test__poll__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    poll(arg1, x, arg3);
 }
 
-void test__strtok_r__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strtok_r(arg1, p, arg3);
+void test__poll__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    poll(arg1, arg2, x);
 }
 
-void test__strtok_r__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strtok_r(arg1, x, 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__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strtok_r(arg1, arg2, p);
+void test__regcomp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    regcomp(NULL, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    regcomp(arg1, x, arg3);
 }
 
-void test__getpwnam_r__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getpwnam_r(arg1, arg2, arg3, arg4, arg5);
+void test__regcomp__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    regcomp(arg1, arg2, x);
 }
 
-void test__getpwnam_r__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getpwnam_r(x, 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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getpwnam_r(arg1, arg2, arg3, x, arg5);
+void test__regerror__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    regerror(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    regerror(arg1, x, arg3, arg4);
 }
 
-void test__getpwuid__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getpwuid(arg1);
+void test__regerror__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    regerror(arg1, arg2, arg3, x);
 }
 
-void test__getpwuid__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getpwuid(x);
+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_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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    regexec(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    regexec(x, arg2, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    regexec(arg1, NULL, arg3, arg4, arg5);
 }
 
-void test__setpwent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; setpwent(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__regexec__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    regexec(arg1, x, arg3, arg4, arg5);
 }
 
-void test__catclose__noreturn() {
-  int x = 1;
-  if (cond) { x=100; catclose(arg1); }
-  // 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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  catclose(x);
+void test__regexec__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    regexec(arg1, arg2, arg3, x, arg5);
 }
 
-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__regexec__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    regexec(arg1, arg2, arg3, arg4, x);
 }
 
-void test__catgets__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  catgets(arg1, arg2, arg3, arg4);
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = catgets(x, arg2, arg3, arg4);
+void test__regfree__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    regfree(x);
 }
 
-void test__catgets__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = catgets(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = catgets(arg1, arg2, x, arg4);
+
+void test__sched_get_priority_max__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sched_get_priority_max(x);
 }
-
-void test__catgets__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = catgets(arg1, arg2, arg3, x);
+
+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__catopen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; catopen(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  catopen(p, arg2);
+void test__sched_getparam__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sched_getparam(x, arg2);
 }
 
-void test__catopen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  catopen(x, arg2);
+void test__sched_getparam__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    sched_getparam(arg1, NULL);
 }
 
-void test__catopen__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  catopen(arg1, x);
+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__poll__noreturn() {
-  int x = 1;
-  if (cond) { x=100; poll(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  poll(x, arg2, arg3);
+void test__sched_setscheduler__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sched_setscheduler(x, arg2, arg3);
 }
 
-void test__poll__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  poll(arg1, x, arg3);
+void test__sched_setscheduler__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sched_setscheduler(arg1, x, arg3);
 }
 
-void test__poll__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  poll(arg1, arg2, x);
+void test__sched_setscheduler__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sched_setscheduler(arg1, arg2, x);
 }
 
-void test__regcomp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; regcomp(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__sched_yield__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        sched_yield();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__regcomp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  regcomp(p, arg2, 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__regcomp__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  regcomp(arg1, x, arg3);
+void test__ecvt__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ecvt(x, arg2, arg3, arg4);
 }
 
-void test__regcomp__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  regcomp(arg1, arg2, x);
+void test__ecvt__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ecvt(arg1, x, arg3, 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__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    ecvt(arg1, arg2, NULL, arg4);
 }
 
-void test__regerror__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  regerror(x, arg2, arg3, arg4);
+void test__ecvt__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    ecvt(arg1, arg2, arg3, NULL);
 }
 
-void test__regerror__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  regerror(arg1, x, 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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  regerror(arg1, arg2, arg3, x);
+void test__fcvt__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fcvt(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fcvt(arg1, x, arg3, arg4);
 }
 
-void test__regexec__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  regexec(p, arg2, arg3, arg4, arg5);
+void test__fcvt__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fcvt(arg1, arg2, NULL, arg4);
 }
 
-void test__regexec__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  regexec(x, arg2, arg3, arg4, arg5);
+void test__fcvt__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fcvt(arg1, arg2, arg3, NULL);
 }
 
-void test__regexec__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  regexec(arg1, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  regexec(arg1, x, arg3, arg4, arg5);
+void test__gcvt__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    gcvt(x, arg2, arg3);
 }
 
-void test__regexec__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  regexec(arg1, arg2, x, arg4, arg5);
+void test__gcvt__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    gcvt(arg1, x, arg3);
 }
 
-void test__regexec__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  regexec(arg1, arg2, arg3, x, arg5);
+void test__gcvt__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    gcvt(arg1, arg2, NULL);
 }
 
-void test__regexec__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  regexec(arg1, arg2, arg3, arg4, x);
+void test__lseek__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        lseek(arg1, arg2, arg3);
+    }
+    // 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__lseek__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    lseek(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__regfree__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  regfree(p);
+void test__lseek__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    lseek(x, arg2, arg3);
 }
 
-void test__regfree__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  regfree(x);
+void test__lseek__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    lseek(arg1, x, arg3);
 }
 
-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__lseek__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    lseek(arg1, arg2, x);
 }
 
-void test__sched_get_priority_max__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sched_get_priority_max(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_min__noreturn() {
-  int x = 1;
-  if (cond) { x=100; sched_get_priority_min(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__nanosleep__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    nanosleep(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__sched_get_priority_min__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sched_get_priority_min(x);
+void test__nanosleep__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    nanosleep(NULL, arg2);
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        setkey(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__sched_getparam__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sched_getparam(x, arg2);
+void test__setkey__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    setkey(p);
+    // cppcheck-suppress memleak
 }
 
-void test__sched_getparam__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  sched_getparam(arg1, p);
+void test__setkey__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    setkey(NULL);
 }
 
-void test__sched_getscheduler__noreturn() {
-  int x = 1;
-  if (cond) { x=100; sched_getscheduler(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__setkey__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    setkey(x);
 }
 
-void test__sched_getscheduler__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sched_getscheduler(x);
+void test__getpass__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        getpass(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__getpass__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    getpass(p);
+    // cppcheck-suppress memleak
 }
 
-void test__sched_rr_get_interval__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sched_rr_get_interval(x, arg2);
+void test__getpass__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getpass(NULL);
 }
 
-void test__sched_rr_get_interval__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  sched_rr_get_interval(arg1, p);
+void test__drand48__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = drand48();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__sched_setparam__noreturn() {
-  int x = 1;
-  if (cond) { x=100; sched_setparam(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__drand48__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    drand48();
 }
 
-void test__sched_setparam__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sched_setparam(x, arg2);
+void test__putenv__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        putenv(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__sched_setparam__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sched_setparam(arg1, x);
+void test__putenv__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    putenv(NULL);
 }
 
-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__putenv__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    putenv(x);
 }
 
-void test__sched_setscheduler__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sched_setscheduler(x, arg2, arg3);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sched_setscheduler(arg1, x, arg3);
+void test__setenv__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    setenv(NULL, arg2, arg3);
 }
 
-void test__sched_setscheduler__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sched_setscheduler(arg1, arg2, x);
+void test__setenv__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    setenv(x, arg2, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    setenv(arg1, NULL, 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__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    setenv(arg1, x, arg3);
 }
 
-void test__ecvt__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ecvt(x, arg2, arg3, arg4);
+void test__setenv__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    setenv(arg1, arg2, x);
 }
 
-void test__ecvt__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ecvt(arg1, x, arg3, arg4);
+void test__unsetenv__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        unsetenv(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ecvt__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ecvt(arg1, arg2, p, arg4);
+void test__unsetenv__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    unsetenv(NULL);
 }
 
-void test__ecvt__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ecvt(arg1, arg2, arg3, p);
+void test__unsetenv__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    unsetenv(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        localtime(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fcvt__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fcvt(x, arg2, arg3, arg4);
+void test__localtime__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    localtime(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fcvt__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fcvt(arg1, x, arg3, arg4);
+void test__localtime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    localtime(NULL);
 }
 
-void test__fcvt__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fcvt(arg1, arg2, p, arg4);
+void test__localtime__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    localtime(x);
 }
 
-void test__fcvt__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fcvt(arg1, arg2, arg3, p);
+void test__std__localtime__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::localtime(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::localtime(NULL);
 }
 
-void test__gcvt__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  gcvt(x, arg2, arg3);
+void test__std__localtime__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::localtime(x);
 }
 
-void test__gcvt__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  gcvt(arg1, x, 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__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  gcvt(arg1, arg2, p);
+void test__localtime_r__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    localtime_r(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    localtime_r(NULL, arg2);
 }
 
-void test__lseek__leakignore() {
-  char *p = malloc(10); *p=0;
-  lseek(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__localtime_r__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    localtime_r(x, arg2);
 }
 
-void test__lseek__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  lseek(x, arg2, arg3);
+void test__localtime_r__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    localtime_r(arg1, NULL);
 }
 
-void test__lseek__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  lseek(arg1, x, arg3);
+void test__readdir__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        readdir(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lseek__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  lseek(arg1, arg2, x);
+void test__readdir__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    readdir(p);
+    // cppcheck-suppress memleak
 }
 
-void test__nanosleep__noreturn() {
-  int x = 1;
-  if (cond) { x=100; nanosleep(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__readdir__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    readdir(NULL);
 }
 
-void test__nanosleep__leakignore() {
-  char *p = malloc(10); *p=0;
-  nanosleep(p, arg2);
-  // cppcheck-suppress memleak
+void test__readdir__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    readdir(x);
 }
 
-void test__nanosleep__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  nanosleep(p, arg2);
+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__setkey__noreturn() {
-  int x = 1;
-  if (cond) { x=100; setkey(arg1); }
-  // 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__setkey__leakignore() {
-  char *p = malloc(10); *p=0;
-  setkey(p);
-  // cppcheck-suppress memleak
+void test__readdir_r__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    readdir_r(NULL, arg2, arg3);
 }
 
-void test__setkey__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  setkey(p);
+void test__readdir_r__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    readdir_r(x, arg2, arg3);
 }
 
-void test__setkey__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  setkey(x);
+void test__readdir_r__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    readdir_r(arg1, NULL, arg3);
 }
 
-void test__getpass__noreturn() {
-  int x = 1;
-  if (cond) { x=100; getpass(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__readdir_r__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    readdir_r(arg1, arg2, NULL);
 }
 
-void test__getpass__leakignore() {
-  char *p = malloc(10); *p=0;
-  getpass(p);
-  // cppcheck-suppress memleak
+void test__readlink__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        readlink(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getpass__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getpass(p);
+void test__readlink__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    readlink(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__drand48__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = drand48(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__readlink__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    readlink(NULL, arg2, arg3);
 }
 
-void test__drand48__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  drand48();
+void test__readlink__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    readlink(x, arg2, arg3);
 }
 
-void test__putenv__noreturn() {
-  int x = 1;
-  if (cond) { x=100; putenv(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__readlink__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    readlink(arg1, NULL, arg3);
 }
 
-void test__putenv__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  putenv(p);
+void test__readlink__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    readlink(arg1, arg2, x);
 }
 
-void test__putenv__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  putenv(x);
+void test__readlinkat__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        readlinkat(arg1, arg2, arg3, arg4);
+    }
+    // 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__readlinkat__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    readlinkat(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__setenv__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  setenv(p, arg2, arg3);
+void test__readlinkat__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    readlinkat(x, arg2, arg3, arg4);
 }
 
-void test__setenv__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  setenv(x, arg2, arg3);
+void test__readlinkat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    readlinkat(arg1, NULL, arg3, arg4);
 }
 
-void test__setenv__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  setenv(arg1, p, arg3);
+void test__readlinkat__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    readlinkat(arg1, x, arg3, arg4);
 }
 
-void test__setenv__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  setenv(arg1, x, arg3);
+void test__readlinkat__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    readlinkat(arg1, arg2, NULL, arg4);
 }
 
-void test__setenv__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setenv(arg1, arg2, x);
+void test__readlinkat__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    readlinkat(arg1, arg2, arg3, x);
 }
 
-void test__unsetenv__noreturn() {
-  int x = 1;
-  if (cond) { x=100; unsetenv(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  unsetenv(p);
+void test__asctime_r__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    asctime_r(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__unsetenv__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  unsetenv(x);
+void test__asctime_r__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    asctime_r(NULL, arg2);
 }
 
-void test__localtime__noreturn() {
-  int x = 1;
-  if (cond) { x=100; localtime(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__asctime_r__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    asctime_r(x, arg2);
 }
 
-void test__localtime__leakignore() {
-  char *p = malloc(10); *p=0;
-  localtime(p);
-  // cppcheck-suppress memleak
+void test__asctime_r__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    asctime_r(arg1, NULL);
 }
 
-void test__localtime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  localtime(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  localtime(x);
+void test__ctime_r__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    ctime_r(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    ctime_r(NULL, arg2);
 }
 
-void test__std__localtime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::localtime(p);
+void test__ctime_r__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    ctime_r(x, arg2);
 }
 
-void test__std__localtime__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::localtime(x);
+void test__ctime_r__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    ctime_r(arg1, NULL);
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        gmtime_r(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__localtime_r__leakignore() {
-  char *p = malloc(10); *p=0;
-  localtime_r(p, arg2);
-  // cppcheck-suppress memleak
+void test__gmtime_r__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    gmtime_r(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__localtime_r__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  localtime_r(p, arg2);
+void test__gmtime_r__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    gmtime_r(NULL, arg2);
 }
 
-void test__localtime_r__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  localtime_r(x, arg2);
+void test__gmtime_r__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    gmtime_r(x, arg2);
 }
 
-void test__localtime_r__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  localtime_r(arg1, p);
+void test__gmtime_r__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    gmtime_r(arg1, NULL);
 }
 
-void test__readdir__noreturn() {
-  int x = 1;
-  if (cond) { x=100; readdir(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__gmtime__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = gmtime(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__readdir__leakignore() {
-  char *p = malloc(10); *p=0;
-  readdir(p);
-  // cppcheck-suppress memleak
+void test__gmtime__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    gmtime(arg1);
 }
 
-void test__readdir__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  readdir(p);
+void test__gmtime__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = gmtime(p);
+    // cppcheck-suppress memleak
 }
 
-void test__readdir__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  readdir(x);
+void test__gmtime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = gmtime(NULL);
 }
 
-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__gmtime__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = gmtime(x);
 }
 
-void test__readdir_r__leakignore() {
-  char *p = malloc(10); *p=0;
-  readdir_r(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  readdir_r(p, arg2, arg3);
+void test__clock_settime__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    clock_settime(x, arg2);
 }
 
-void test__readdir_r__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  readdir_r(x, 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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  readdir_r(arg1, p, arg3);
+void test__killpg__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    killpg(x, arg2);
 }
 
-void test__readdir_r__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  readdir_r(arg1, arg2, p);
+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__readlink__noreturn() {
-  int x = 1;
-  if (cond) { x=100; readlink(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__clock_getres__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    clock_getres(x, arg2);
 }
 
-void test__readlink__leakignore() {
-  char *p = malloc(10); *p=0;
-  readlink(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  readlink(p, arg2, arg3);
+
+void test__tmpnam__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    tmpnam(x);
 }
-
-void test__readlink__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  readlink(x, 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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  readlink(arg1, p, arg3);
-}
+void test__makecontext__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    makecontext(arg1, arg2, x);
+}
 
-void test__readlink__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  readlink(arg1, arg2, x);
+void test__swapcontext__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        swapcontext(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    swapcontext(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__readlinkat__leakignore() {
-  char *p = malloc(10); *p=0;
-  readlinkat(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__swapcontext__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    swapcontext(NULL, arg2);
 }
 
-void test__readlinkat__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  readlinkat(x, arg2, arg3, arg4);
+void test__swapcontext__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    swapcontext(arg1, NULL);
 }
 
-void test__readlinkat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  readlinkat(arg1, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  readlinkat(arg1, x, arg3, arg4);
+void test__getcontext__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    getcontext(p);
+    // cppcheck-suppress memleak
 }
 
-void test__readlinkat__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  readlinkat(arg1, arg2, p, arg4);
+void test__getcontext__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getcontext(NULL);
 }
 
-void test__readlinkat__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  readlinkat(arg1, arg2, arg3, x);
+void test__ualarm__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        ualarm(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__ualarm__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    ualarm(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__asctime_r__leakignore() {
-  char *p = malloc(10); *p=0;
-  asctime_r(p, arg2);
-  // cppcheck-suppress memleak
+void test__ualarm__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ualarm(x, arg2);
 }
 
-void test__asctime_r__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  asctime_r(p, arg2);
+void test__ualarm__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ualarm(arg1, x);
 }
 
-void test__asctime_r__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  asctime_r(x, 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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  asctime_r(arg1, p);
+void test__scalb__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    scalb(arg1, arg2);
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = scalb(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__ctime_r__leakignore() {
-  char *p = malloc(10); *p=0;
-  ctime_r(p, arg2);
-  // cppcheck-suppress memleak
+void test__scalb__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = scalb(x, arg2);
 }
 
-void test__ctime_r__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ctime_r(p, arg2);
+void test__scalb__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = scalb(arg1, x);
 }
 
-void test__ctime_r__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  ctime_r(x, 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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ctime_r(arg1, p);
+void test__bcopy__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    bcopy(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    bcopy(NULL, arg2, arg3);
 }
 
-void test__gmtime_r__leakignore() {
-  char *p = malloc(10); *p=0;
-  gmtime_r(p, arg2);
-  // cppcheck-suppress memleak
+void test__bcopy__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    bcopy(x, arg2, arg3);
 }
 
-void test__gmtime_r__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  gmtime_r(p, arg2);
+void test__bcopy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    bcopy(arg1, NULL, arg3);
 }
 
-void test__gmtime_r__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  gmtime_r(x, arg2);
+void test__bcopy__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    bcopy(arg1, arg2, x);
 }
 
-void test__gmtime_r__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  gmtime_r(arg1, p);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = gmtime(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__bcmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    bcmp(arg1, arg2, arg3);
 }
 
-void test__gmtime__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  gmtime(arg1);
+void test__bcmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = bcmp(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__gmtime__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = gmtime(p);
-  // cppcheck-suppress memleak
+void test__bcmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = bcmp(NULL, arg2, arg3);
 }
 
-void test__gmtime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = gmtime(p);
+void test__bcmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = bcmp(x, arg2, arg3);
 }
 
-void test__gmtime__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = gmtime(x);
+void test__bcmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = bcmp(arg1, NULL, 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__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = bcmp(arg1, x, arg3);
 }
 
-void test__clock_settime__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  clock_settime(x, arg2);
+void test__bcmp__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = bcmp(arg1, arg2, x);
 }
 
-void test__clock_settime__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  clock_settime(arg1, x);
+void test__bzero__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        bzero(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__killpg__noreturn() {
-  int x = 1;
-  if (cond) { x=100; killpg(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__bzero__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    bzero(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__killpg__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  killpg(x, arg2);
+void test__bzero__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    bzero(NULL, arg2);
 }
 
-void test__killpg__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  killpg(arg1, x);
+void test__bzero__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    bzero(arg1, x);
 }
 
-void test__kill__noreturn() {
-  int x = 1;
-  if (cond) { x=100; kill(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ftime__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        ftime(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__kill__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  kill(x, arg2);
+void test__ftime__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    ftime(p);
+    // cppcheck-suppress memleak
 }
 
-void test__kill__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  kill(arg1, x);
+void test__ftime__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ftime(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wcswcs(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__wcswcs__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcswcs(arg1, arg2);
 }
 
-void test__clock_gettime__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  clock_gettime(arg1, p);
+void test__wcswcs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wcswcs(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcswcs(NULL, arg2);
 }
 
-void test__clock_getres__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  clock_getres(x, arg2);
+void test__wcswcs__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcswcs(x, arg2);
 }
 
-void test__tmpnam__noreturn() {
-  int x = 1;
-  if (cond) { x=100; tmpnam(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcswcs__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcswcs(arg1, NULL);
 }
 
-void test__tmpnam__leakignore() {
-  char *p = malloc(10); *p=0;
-  tmpnam(p);
-  // cppcheck-suppress memleak
+void test__wcswcs__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcswcs(arg1, x);
 }
 
-void test__tmpnam__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  tmpnam(x);
+void test__stpcpy__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        stpcpy(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__tmpnam_r__noreturn() {
-  int x = 1;
-  if (cond) { x=100; tmpnam_r(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__stpcpy__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    stpcpy(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__tmpnam_r__leakignore() {
-  char *p = malloc(10); *p=0;
-  tmpnam_r(p);
-  // cppcheck-suppress memleak
+void test__stpcpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    stpcpy(NULL, arg2);
 }
 
-void test__tmpnam_r__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  tmpnam_r(x);
+void test__stpcpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    stpcpy(arg1, NULL);
 }
 
-void test__makecontext__noreturn() {
-  int x = 1;
-  if (cond) { x=100; makecontext(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__stpcpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    stpcpy(arg1, x);
 }
 
-void test__makecontext__leakignore() {
-  char *p = malloc(10); *p=0;
-  makecontext(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__index__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = index(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__makecontext__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  makecontext(p, arg2, arg3);
+void test__index__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    index(arg1, arg2);
 }
 
-void test__makecontext__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  makecontext(arg1, p, arg3);
+void test__index__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = index(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__makecontext__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  makecontext(arg1, x, arg3);
+void test__index__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = index(NULL, arg2);
 }
 
-void test__makecontext__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  makecontext(arg1, arg2, x);
+void test__index__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = index(x, arg2);
 }
 
-void test__swapcontext__noreturn() {
-  int x = 1;
-  if (cond) { x=100; swapcontext(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__index__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = index(arg1, x);
 }
 
-void test__swapcontext__leakignore() {
-  char *p = malloc(10); *p=0;
-  swapcontext(p, arg2);
-  // cppcheck-suppress memleak
+void test__rindex__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = rindex(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__swapcontext__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  swapcontext(p, arg2);
+void test__rindex__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    rindex(arg1, arg2);
 }
 
-void test__swapcontext__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  swapcontext(arg1, p);
+void test__rindex__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = rindex(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__getcontext__noreturn() {
-  int x = 1;
-  if (cond) { x=100; getcontext(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__rindex__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = rindex(NULL, arg2);
 }
 
-void test__getcontext__leakignore() {
-  char *p = malloc(10); *p=0;
-  getcontext(p);
-  // cppcheck-suppress memleak
+void test__rindex__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = rindex(x, arg2);
 }
 
-void test__getcontext__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getcontext(p);
+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__ualarm__noreturn() {
-  int x = 1;
-  if (cond) { x=100; ualarm(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__bsd_signal__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    bsd_signal(x, arg2);
 }
 
-void test__ualarm__leakignore() {
-  char *p = malloc(10); *p=0;
-  ualarm(p, arg2);
-  // cppcheck-suppress memleak
+void test__bsd_signal__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    bsd_signal(arg1, x);
 }
 
-void test__ualarm__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ualarm(x, arg2);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ualarm(arg1, x);
-}
+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__scalb__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = scalb(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
-}
+void test__pthread_attr_destroy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    pthread_attr_destroy(NULL);
+}
 
-void test__scalb__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  scalb(arg1, arg2);
-}
+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__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = scalb(p, arg2);
-  // cppcheck-suppress memleak
-}
+void test__pthread_attr_init__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    pthread_attr_init(NULL);
+}
 
-void test__scalb__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = scalb(x, arg2);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = scalb(arg1, x);
+void test__pthread_attr_setstackaddr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    pthread_attr_setstackaddr(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    pthread_attr_setstackaddr(NULL, arg2);
 }
 
-void test__bcopy__leakignore() {
-  char *p = malloc(10); *p=0;
-  bcopy(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__pthread_attr_setstackaddr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    pthread_attr_setstackaddr(x, arg2);
 }
 
-void test__bcopy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  bcopy(p, arg2, arg3);
+void test__pthread_attr_setstackaddr__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    pthread_attr_setstackaddr(arg1, NULL);
 }
 
-void test__bcopy__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  bcopy(x, arg2, arg3);
+void test__pthread_attr_setstackaddr__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    pthread_attr_setstackaddr(arg1, x);
 }
 
-void test__bcopy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  bcopy(arg1, p, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  bcopy(arg1, arg2, x);
+void test__pthread_attr_getstackaddr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    pthread_attr_getstackaddr(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    pthread_attr_getstackaddr(NULL, arg2);
 }
 
-void test__bcmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  bcmp(arg1, arg2, arg3);
+void test__pthread_attr_getstackaddr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    pthread_attr_getstackaddr(x, arg2);
 }
 
-void test__bcmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = bcmp(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__pthread_attr_getstackaddr__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    pthread_attr_getstackaddr(arg1, NULL);
 }
 
-void test__bcmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = bcmp(p, arg2, arg3);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = bcmp(x, arg2, arg3);
+void test__tempnam__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    tempnam(arg1, arg2);
 }
 
-void test__bcmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = bcmp(arg1, p, arg3);
+void test__tempnam__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = tempnam(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__bcmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = bcmp(arg1, x, arg3);
+void test__tempnam__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = tempnam(x, arg2);
 }
 
-void test__bcmp__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = bcmp(arg1, arg2, x);
+void test__tempnam__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = tempnam(arg1, x);
 }
 
-void test__bzero__noreturn() {
-  int x = 1;
-  if (cond) { x=100; bzero(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__leakignore() {
-  char *p = malloc(10); *p=0;
-  bzero(p, arg2);
-  // cppcheck-suppress memleak
+void test__crypt__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    crypt(arg1, arg2);
 }
 
-void test__bzero__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  bzero(p, arg2);
+void test__crypt__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = crypt(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__bzero__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  bzero(arg1, x);
+void test__crypt__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = crypt(NULL, arg2);
 }
 
-void test__ftime__noreturn() {
-  int x = 1;
-  if (cond) { x=100; ftime(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__crypt__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = crypt(x, arg2);
 }
 
-void test__ftime__leakignore() {
-  char *p = malloc(10); *p=0;
-  ftime(p);
-  // cppcheck-suppress memleak
+void test__crypt__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = crypt(arg1, NULL);
 }
 
-void test__ftime__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ftime(x);
+void test__crypt__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = crypt(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__ttyname__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ttyname(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcswcs__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcswcs(arg1, arg2);
+void test__ttyname__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ttyname(arg1);
 }
 
-void test__wcswcs__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcswcs(p, arg2);
-  // cppcheck-suppress memleak
+void test__ttyname__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ttyname(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wcswcs__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcswcs(p, arg2);
+void test__ttyname__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ttyname(x);
 }
 
-void test__wcswcs__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcswcs(x, arg2);
+void test__getspnam__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getspnam(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcswcs__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcswcs(arg1, p);
+void test__getspnam__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getspnam(arg1);
 }
 
-void test__wcswcs__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcswcs(arg1, x);
+void test__getspnam__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getspnam(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__getspnam__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = getspnam(NULL);
 }
 
-void test__stpcpy__leakignore() {
-  char *p = malloc(10); *p=0;
-  stpcpy(p, arg2);
-  // cppcheck-suppress memleak
+void test__getspnam__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = getspnam(x);
 }
 
-void test__stpcpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  stpcpy(p, arg2);
+void test__getspent__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getspent();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__stpcpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  stpcpy(arg1, p);
+void test__getspent__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getspent();
 }
 
-void test__stpcpy__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  stpcpy(arg1, x);
+void test__getspent__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getspent();
+    // cppcheck-suppress memleak
 }
 
-void test__index__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = index(arg1, arg2); }
-  // 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__index__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  index(arg1, arg2);
+void test__fgetspent__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fgetspent(arg1);
 }
 
-void test__index__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = index(p, arg2);
-  // cppcheck-suppress memleak
+void test__fgetspent__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fgetspent(p);
+    // cppcheck-suppress memleak
 }
 
-void test__index__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = index(p, arg2);
+void test__fgetspent__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = fgetspent(NULL);
 }
 
-void test__index__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = index(x, arg2);
+void test__fgetspent__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = fgetspent(x);
 }
 
-void test__index__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = index(arg1, x);
+void test__sgetspent__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = sgetspent(arg1);
+    }
+    // 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__sgetspent__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sgetspent(arg1);
 }
 
-void test__rindex__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  rindex(arg1, arg2);
+void test__sgetspent__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = sgetspent(p);
+    // cppcheck-suppress memleak
 }
 
-void test__rindex__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = rindex(p, arg2);
-  // cppcheck-suppress memleak
+void test__sgetspent__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = sgetspent(NULL);
 }
 
-void test__rindex__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = rindex(p, arg2);
+void test__sgetspent__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = sgetspent(x);
 }
 
-void test__rindex__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = rindex(x, arg2);
+void test__fgetpwent__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fgetpwent(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__rindex__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = rindex(arg1, x);
+void test__fgetpwent__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fgetpwent(arg1);
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fgetpwent(p);
+    // cppcheck-suppress memleak
 }
 
-void test__bsd_signal__leakignore() {
-  char *p = malloc(10); *p=0;
-  bsd_signal(p, arg2);
-  // cppcheck-suppress memleak
+void test__fgetpwent__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = fgetpwent(NULL);
 }
 
-void test__bsd_signal__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  bsd_signal(x, arg2);
+void test__fgetpwent__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = fgetpwent(x);
 }
 
-void test__bsd_signal__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  bsd_signal(arg1, x);
+void test__getgrent__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getgrent();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fork__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fork(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getgrent__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getgrent();
 }
 
-void test__fork__leakignore() {
-  char *p = malloc(10); *p=0;
-  fork();
-  // cppcheck-suppress memleak
+void test__getgrent__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getgrent();
+    // cppcheck-suppress memleak
 }
 
-void test__vfork__noreturn() {
-  int x = 1;
-  if (cond) { x=100; vfork(); }
-  // 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__vfork__leakignore() {
-  char *p = malloc(10); *p=0;
-  vfork();
-  // cppcheck-suppress memleak
+void test__getgrent_r__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getgrent_r(arg1, arg2, arg3, arg4);
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getgrent_r(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__pthread_atfork__leakignore() {
-  char *p = malloc(10); *p=0;
-  pthread_atfork(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__getgrent_r__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getgrent_r(arg1, x, arg3, 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__getgrent_r__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getgrent_r(arg1, arg2, x, arg4);
 }
 
-void test__pthread_create__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  pthread_create(p, arg2, arg3, arg4);
+void test__fgetgrent__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fgetgrent(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__pthread_create__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  pthread_create(arg1, arg2, p, arg4);
+void test__fgetgrent__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fgetgrent(arg1);
 }
 
-void test__pthread_detach__noreturn() {
-  int x = 1;
-  if (cond) { x=100; pthread_detach(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fgetgrent__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fgetgrent(p);
+    // cppcheck-suppress memleak
 }
 
-void test__pthread_detach__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  pthread_detach(x);
+void test__fgetgrent__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = fgetgrent(NULL);
 }
 
-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__fgetgrent__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = fgetgrent(x);
 }
 
-void test__pthread_equal__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  pthread_equal(arg1, arg2);
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = pthread_equal(x, arg2);
+void test__getnetgrent__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    getnetgrent(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__pthread_equal__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = pthread_equal(arg1, x);
+void test__getnetgrent__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getnetgrent(NULL, arg2, 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__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getnetgrent(arg1, NULL, arg3);
 }
 
-void test__pthread_join__noreturn() {
-  int x = 1;
-  if (cond) { x=100; pthread_join(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getnetgrent__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getnetgrent(arg1, arg2, NULL);
 }
 
-void test__pthread_join__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  pthread_join(x, arg2);
+void test__getgrnam__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getgrnam(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getgrnam(arg1);
 }
 
-void test__pthread_kill__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  pthread_kill(x, arg2);
+void test__getgrnam__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getgrnam(p);
+    // cppcheck-suppress memleak
 }
 
-void test__pthread_kill__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  pthread_kill(arg1, x);
+void test__getgrnam__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = getgrnam(NULL);
 }
 
-void test__pthread_self__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = pthread_self(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getgrnam__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = getgrnam(x);
 }
 
-void test__pthread_self__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  pthread_self();
+void test__getgrgid__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getgrgid(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getgrgid(arg1);
 }
 
-void test__pthread_attr_destroy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  pthread_attr_destroy(p);
+void test__getgrgid__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getgrgid(p);
+    // cppcheck-suppress memleak
 }
-
-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__getgrgid__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = getgrgid(x);
 }
 
-void test__pthread_attr_init__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  pthread_attr_init(p);
+void test__getlogin__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getlogin();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getlogin();
 }
 
-void test__pthread_attr_setstackaddr__leakignore() {
-  char *p = malloc(10); *p=0;
-  pthread_attr_setstackaddr(p, arg2);
-  // cppcheck-suppress memleak
+void test__getlogin__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getlogin();
+    // cppcheck-suppress memleak
 }
 
-void test__pthread_attr_setstackaddr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  pthread_attr_setstackaddr(p, arg2);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  pthread_attr_setstackaddr(x, arg2);
+void test__ctermid__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    ctermid(p);
+    // cppcheck-suppress memleak
 }
 
-void test__pthread_attr_setstackaddr__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  pthread_attr_setstackaddr(arg1, p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  pthread_attr_setstackaddr(arg1, x);
+
+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_getstackaddr__noreturn() {
-  int x = 1;
-  if (cond) { x=100; pthread_attr_getstackaddr(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__leakignore() {
-  char *p = malloc(10); *p=0;
-  pthread_attr_getstackaddr(p, arg2);
-  // cppcheck-suppress memleak
+void test__remove__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    remove(p);
+    // cppcheck-suppress memleak
 }
 
-void test__pthread_attr_getstackaddr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  pthread_attr_getstackaddr(p, arg2);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  pthread_attr_getstackaddr(x, 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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  pthread_attr_getstackaddr(arg1, p);
+void test__fileno__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fileno(arg1);
 }
 
-void test__tempnam__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = tempnam(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fileno__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fileno(p);
+    // cppcheck-suppress memleak
 }
 
-void test__tempnam__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  tempnam(arg1, arg2);
+void test__fileno__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = fileno(NULL);
 }
 
-void test__tempnam__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = tempnam(p, arg2);
-  // cppcheck-suppress memleak
+void test__fileno__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = fileno(x);
 }
 
-void test__tempnam__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = tempnam(x, arg2);
+void test__fseeko__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fseeko(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__tempnam__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = tempnam(arg1, x);
+void test__fseeko__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fseeko(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fseeko(NULL, arg2, arg3);
 }
 
-void test__crypt__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  crypt(arg1, arg2);
+void test__fseeko__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fseeko(x, arg2, arg3);
 }
 
-void test__crypt__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = crypt(p, arg2);
-  // cppcheck-suppress memleak
+void test__fseeko__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fseeko(arg1, x, arg3);
 }
 
-void test__crypt__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = crypt(p, arg2);
+void test__fseeko__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fseeko(arg1, arg2, x);
 }
 
-void test__crypt__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = crypt(x, arg2);
+void test__ftello__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ftello(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__crypt__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = crypt(arg1, p);
+void test__ftello__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ftello(arg1);
 }
 
-void test__crypt__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = crypt(arg1, x);
+void test__ftello__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ftello(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ttyname__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ttyname(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ftello__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = ftello(NULL);
 }
 
-void test__ttyname__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ttyname(arg1);
+void test__ftello__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = ftello(x);
 }
 
-void test__ttyname__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ttyname(p);
-  // cppcheck-suppress memleak
+void test__execv__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        execv(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ttyname__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ttyname(x);
+void test__execv__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    execv(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__getspnam__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getspnam(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__execv__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    execv(NULL, arg2);
 }
 
-void test__getspnam__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getspnam(arg1);
+void test__execv__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    execv(x, arg2);
 }
 
-void test__getspnam__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getspnam(p);
-  // cppcheck-suppress memleak
+void test__execv__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    execv(arg1, x);
 }
 
-void test__getspnam__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = getspnam(p);
+void test__execvp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        execvp(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getspnam__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = getspnam(x);
+void test__execvp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    execvp(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__execvp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    execvp(NULL, arg2);
 }
 
-void test__getspent__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getspent();
+void test__execvp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    execvp(x, arg2);
 }
 
-void test__getspent__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getspent();
-  // cppcheck-suppress memleak
+void test__execvp__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    execvp(arg1, x);
 }
 
-void test__fgetspent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fgetspent(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wait__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wait(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fgetspent__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fgetspent(arg1);
+void test__wait__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wait(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fgetspent__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fgetspent(p);
-  // cppcheck-suppress memleak
+void test__waitpid__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        waitpid(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fgetspent__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = fgetspent(p);
+void test__waitpid__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    waitpid(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__fgetspent__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = fgetspent(x);
+void test__waitpid__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    waitpid(x, arg2, arg3);
 }
 
-void test__sgetspent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = sgetspent(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__waitpid__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    waitpid(arg1, arg2, x);
 }
 
-void test__sgetspent__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sgetspent(arg1);
+void test__strnlen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = strnlen(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__strnlen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    strnlen(arg1, arg2);
 }
 
-void test__sgetspent__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = sgetspent(p);
+void test__strnlen__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = strnlen(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__sgetspent__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = sgetspent(x);
+void test__strnlen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strnlen(NULL, arg2);
 }
 
-void test__fgetpwent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fgetpwent(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strnlen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strnlen(x, arg2);
 }
 
-void test__fgetpwent__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fgetpwent(arg1);
+void test__strnlen__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = strnlen(arg1, x);
 }
 
-void test__fgetpwent__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fgetpwent(p);
-  // cppcheck-suppress memleak
+void test__wcsnlen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wcsnlen(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fgetpwent__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = fgetpwent(p);
+void test__wcsnlen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcsnlen(arg1, arg2);
 }
 
-void test__fgetpwent__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = fgetpwent(x);
+void test__wcsnlen__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wcsnlen(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__getgrent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getgrent(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcsnlen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcsnlen(NULL, arg2);
 }
 
-void test__getgrent__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getgrent();
+void test__wcsnlen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcsnlen(x, arg2);
 }
 
-void test__getgrent__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getgrent();
-  // cppcheck-suppress memleak
+void test__wcsnlen__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = wcsnlen(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ffs(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getgrent_r__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getgrent_r(arg1, arg2, arg3, arg4);
+void test__ffs__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ffs(arg1);
 }
 
-void test__getgrent_r__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getgrent_r(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__ffs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ffs(p);
+    // cppcheck-suppress memleak
 }
 
-void test__getgrent_r__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getgrent_r(arg1, x, arg3, arg4);
+void test__ffs__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ffs(x);
 }
 
-void test__getgrent_r__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getgrent_r(arg1, arg2, x, arg4);
+void test__shmctl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        shmctl(arg1, arg2);
+    }
+    // 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__shmctl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    shmctl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__fgetgrent__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fgetgrent(arg1);
+void test__shmctl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    shmctl(x, arg2);
 }
 
-void test__fgetgrent__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fgetgrent(p);
-  // cppcheck-suppress memleak
+void test__shmctl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    shmctl(arg1, x);
 }
 
-void test__fgetgrent__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = fgetgrent(p);
-}
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = fgetgrent(x);
+void test__shmget__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    shmget(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__getnetgrent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; getnetgrent(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__shmget__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    shmget(x, arg2, arg3);
 }
 
-void test__getnetgrent__leakignore() {
-  char *p = malloc(10); *p=0;
-  getnetgrent(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getnetgrent(p, arg2, arg3);
+void test__shmat__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    shmat(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__getnetgrent__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getnetgrent(arg1, p, arg3);
+void test__shmat__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    shmat(x, arg2, arg3);
 }
 
-void test__getnetgrent__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getnetgrent(arg1, arg2, p);
+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__getgrnam__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getgrnam(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__shmdt__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    shmdt(p);
+    // cppcheck-suppress memleak
 }
 
-void test__getgrnam__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getgrnam(arg1);
+void test__getrlimit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        getrlimit(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__getrlimit__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    getrlimit(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__getgrnam__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = getgrnam(p);
+void test__getrlimit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    getrlimit(x, arg2);
 }
 
-void test__getgrnam__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = getgrnam(x);
+void test__getrlimit__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getrlimit(arg1, NULL);
 }
 
-void test__getgrgid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getgrgid(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__setrlimit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        setrlimit(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getgrgid__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getgrgid(arg1);
+void test__setrlimit__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    setrlimit(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__getgrgid__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getgrgid(p);
-  // cppcheck-suppress memleak
+void test__setrlimit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    setrlimit(x, arg2);
 }
 
-void test__getgrgid__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = getgrgid(x);
+void test__setrlimit__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    setrlimit(arg1, NULL);
 }
 
-void test__getlogin__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getlogin(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__setrlimit__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    setrlimit(arg1, x);
 }
 
-void test__getlogin__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getlogin();
+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__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getlogin();
-  // cppcheck-suppress memleak
+void test__glob__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    glob(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    glob(x, arg2, arg3, arg4);
 }
 
-void test__ctermid__leakignore() {
-  char *p = malloc(10); *p=0;
-  ctermid(p);
-  // cppcheck-suppress memleak
+void test__glob__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    glob(arg1, x, arg3, arg4);
 }
 
-void test__realpath__noreturn() {
-  int x = 1;
-  if (cond) { x=100; realpath(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__glob__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    glob(arg1, arg2, x, arg4);
 }
 
-void test__realpath__leakignore() {
-  char *p = malloc(10); *p=0;
-  realpath(p, arg2);
-  // cppcheck-suppress memleak
+void test__glob__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    glob(arg1, arg2, arg3, NULL);
 }
 
-void test__realpath__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  realpath(p, arg2);
+void test__globfree__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        globfree(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__realpath__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  realpath(x, arg2);
+void test__globfree__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    globfree(NULL);
 }
 
-void test__remove__noreturn() {
-  int x = 1;
-  if (cond) { x=100; remove(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__globfree__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    globfree(x);
 }
 
-void test__remove__leakignore() {
-  char *p = malloc(10); *p=0;
-  remove(p);
-  // cppcheck-suppress memleak
+void test__wcpncpy__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wcpncpy(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__remove__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  remove(p);
+void test__wcpncpy__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcpncpy(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__remove__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  remove(x);
+void test__wcpncpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcpncpy(NULL, arg2, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcpncpy(arg1, NULL, arg3);
 }
 
-void test__fileno__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fileno(arg1);
+void test__wcpncpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcpncpy(arg1, x, arg3);
 }
 
-void test__fileno__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fileno(p);
-  // cppcheck-suppress memleak
+void test__wcpncpy__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wcpncpy(arg1, arg2, !x);
 }
 
-void test__fileno__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = fileno(p);
+void test__wcpncpy__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wcpncpy(arg1, arg2, x);
 }
 
-void test__fileno__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = fileno(x);
+void test__stpncpy__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        stpncpy(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fseeko__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fseeko(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__fseeko__leakignore() {
-  char *p = malloc(10); *p=0;
-  fseeko(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__stpncpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    stpncpy(NULL, arg2, arg3);
 }
 
-void test__fseeko__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fseeko(p, arg2, arg3);
+void test__stpncpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    stpncpy(arg1, NULL, arg3);
 }
 
-void test__fseeko__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fseeko(x, arg2, arg3);
+void test__stpncpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    stpncpy(arg1, x, arg3);
 }
 
-void test__fseeko__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fseeko(arg1, x, arg3);
+void test__stpncpy__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    stpncpy(arg1, arg2, !x);
 }
 
-void test__fseeko__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fseeko(arg1, arg2, x);
+void test__stpncpy__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    stpncpy(arg1, arg2, x);
 }
 
-void test__ftello__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ftello(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__ftello__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ftello(arg1);
+void test__memccpy__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    memccpy(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__ftello__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ftello(p);
-  // cppcheck-suppress memleak
+void test__memccpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    memccpy(NULL, arg2, arg3, arg4);
 }
 
-void test__ftello__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = ftello(p);
+void test__memccpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    memccpy(arg1, NULL, arg3, arg4);
 }
 
-void test__ftello__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = ftello(x);
+void test__memccpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    memccpy(arg1, x, arg3, arg4);
 }
 
-void test__execv__noreturn() {
-  int x = 1;
-  if (cond) { x=100; execv(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__memccpy__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    memccpy(arg1, arg2, x, arg4);
 }
 
-void test__execv__leakignore() {
-  char *p = malloc(10); *p=0;
-  execv(p, arg2);
-  // cppcheck-suppress memleak
+void test__memccpy__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    memccpy(arg1, arg2, arg3, x);
 }
 
-void test__execv__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  execv(p, arg2);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  execv(x, arg2);
+void test__getopt__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    getopt(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__execv__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  execv(arg1, x);
+void test__getopt__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    getopt(x, arg2, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getopt(arg1, NULL, arg3);
 }
 
-void test__execvp__leakignore() {
-  char *p = malloc(10); *p=0;
-  execvp(p, arg2);
-  // cppcheck-suppress memleak
+void test__getopt__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    getopt(arg1, x, arg3);
 }
 
-void test__execvp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  execvp(p, arg2);
+void test__getopt__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getopt(arg1, arg2, NULL);
 }
 
-void test__execvp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  execvp(x, arg2);
+void test__getopt__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    getopt(arg1, arg2, x);
 }
 
-void test__execvp__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  execvp(arg1, x);
+void test__getitimer__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        getitimer(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wait__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wait(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getitimer__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    getitimer(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__wait__leakignore() {
-  char *p = malloc(10); *p=0;
-  wait(p);
-  // cppcheck-suppress memleak
+void test__getitimer__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    getitimer(x, arg2);
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getitimer(arg1, NULL);
 }
 
-void test__waitpid__leakignore() {
-  char *p = malloc(10); *p=0;
-  waitpid(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__getitimer__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    getitimer(arg1, x);
 }
 
-void test__waitpid__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  waitpid(x, arg2, arg3);
+void test__setitimer__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        setitimer(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__waitpid__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  waitpid(arg1, arg2, x);
+void test__setitimer__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    setitimer(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__strnlen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = strnlen(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__setitimer__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    setitimer(x, arg2, arg3);
 }
 
-void test__strnlen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  strnlen(arg1, arg2);
+void test__setitimer__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    setitimer(arg1, x, arg3);
 }
 
-void test__strnlen__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = strnlen(p, arg2);
-  // cppcheck-suppress memleak
+void test__setitimer__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    setitimer(arg1, arg2, x);
 }
 
-void test__strnlen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strnlen(p, arg2);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strnlen(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = strnlen(arg1, x);
+
+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__wcsnlen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wcsnlen(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcsnlen(arg1, arg2);
+
+void test__getrusage__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    getrusage(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__wcsnlen__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcsnlen(p, arg2);
-  // cppcheck-suppress memleak
+void test__getrusage__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    getrusage(x, arg2);
 }
 
-void test__wcsnlen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcsnlen(p, 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__wcsnlen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcsnlen(x, arg2);
+void test__sigemptyset__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    sigemptyset(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wcsnlen__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wcsnlen(arg1, x);
-}
+void test__sigemptyset__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    sigemptyset(NULL);
+}
 
-void test__ffs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ffs(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__sigfillset__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        sigfillset(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
-
-void test__ffs__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ffs(arg1);
+
+void test__sigfillset__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    sigfillset(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ffs__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ffs(p);
-  // cppcheck-suppress memleak
+void test__sigfillset__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    sigfillset(NULL);
 }
 
-void test__ffs__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ffs(x);
+void test__sigaddset__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        sigaddset(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__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__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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getrlimit(arg1, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  setrlimit(arg1, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  glob(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  glob(arg1, arg2, arg3, p);
-}
-
-void test__globfree__noreturn() {
-  int x = 1;
-  if (cond) { x=100; globfree(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
-}
-
-void test__globfree__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  globfree(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcpncpy(p, arg2, arg3);
-}
-
-void test__wcpncpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcpncpy(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  stpncpy(p, arg2, arg3);
-}
-
-void test__stpncpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  stpncpy(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  memccpy(p, arg2, arg3, arg4);
-}
-
-void test__memccpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  memccpy(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getopt(arg1, p, arg3);
-}
-
-void test__getopt__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  getopt(arg1, x, arg3);
-}
-
-void test__getopt__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getopt(arg1, arg2, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getitimer(arg1, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  sigsuspend(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getrusage(arg1, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  sigemptyset(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  sigfillset(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  sigaddset(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  sigdelset(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  sigismember(p, 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__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__msgctl__leakignore() {
-  char *p = malloc(10); *p=0;
-  msgctl(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  msgctl(x, arg2, arg3);
+void test__msgctl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    msgctl(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__msgctl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  msgctl(arg1, x, arg3);
+void test__msgctl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    msgctl(x, arg2, arg3);
 }
 
-void test__msgctl__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  msgctl(arg1, arg2, x);
+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__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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  msgrcv(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  msgsnd(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  tcsendbreak(arg1, p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  tcgetattr(arg1, p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  tcsetattr(arg1, arg2, p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  cfsetospeed(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  cfsetispeed(p, 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 723162687..68a848ea7 100644
--- a/test/cfg/generated-cfg-tests-qt.cpp
+++ b/test/cfg/generated-cfg-tests-qt.cpp
@@ -8,1550 +8,2092 @@
 // => '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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  connect(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  connect(arg1, arg2, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  disconnect(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  disconnect(arg1, arg2, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = tr(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = QObject::tr(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  QSettings::setValue(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = QSettings::value(p, 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__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__QString__asprintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    QString::asprintf(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = QList::at(arg1);
+    }
+    // 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__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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QList::at(arg1);
+}
 
-void test__QList__endsWith__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QList::endsWith(x);
+void test__QList__at__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QList::at(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = QString::at(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__QString__contains__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QString::contains(arg1, arg2);
+void test__QString__at__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QString::at(arg1);
 }
 
-void test__QString__contains__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QString::contains(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QString::contains(arg1, 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__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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = QList::endsWith(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__QString__startsWith__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QString::startsWith(arg1, arg2);
+void test__QList__endsWith__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QList::endsWith(arg1);
 }
 
-void test__QString__startsWith__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QString::startsWith(x, arg2);
+void test__QList__endsWith__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QList::endsWith(x);
 }
 
-void test__QString__startsWith__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QString::startsWith(arg1, 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__endsWith__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = QString::endsWith(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__QString__contains__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QString::contains(arg1, arg2);
 }
 
-void test__QString__endsWith__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QString::endsWith(arg1, arg2);
+void test__QString__contains__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QString::contains(x, arg2);
 }
 
-void test__QString__endsWith__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QString::endsWith(x, arg2);
+void test__QString__contains__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QString::contains(arg1, x);
 }
 
-void test__QString__endsWith__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QString::endsWith(arg1, 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__QStringList__contains__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = QStringList::contains(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__QString__startsWith__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QString::startsWith(arg1, arg2);
 }
 
-void test__QStringList__contains__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QStringList::contains(arg1);
+void test__QString__startsWith__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QString::startsWith(x, arg2);
 }
 
-void test__QStringList__contains__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QStringList::contains(x);
+void test__QString__startsWith__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QString::startsWith(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = QString::endsWith(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__QStringList__startsWith__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QStringList::startsWith(arg1);
+void test__QString__endsWith__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QString::endsWith(arg1, arg2);
 }
 
-void test__QStringList__startsWith__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QStringList::startsWith(x);
+void test__QString__endsWith__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QString::endsWith(x, arg2);
 }
 
-void test__QStringList__endsWith__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = QStringList::endsWith(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__QString__endsWith__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QString::endsWith(arg1, x);
 }
 
-void test__QStringList__endsWith__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QStringList::endsWith(arg1);
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QStringList::endsWith(x);
+void test__QStringList__contains__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QStringList::contains(arg1);
 }
 
-void test__QList__count__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = QList::count(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__QStringList__contains__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QStringList::contains(x);
 }
 
-void test__QList__count__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QList::count();
+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__length__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = QList::length(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__QStringList__startsWith__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QStringList::startsWith(arg1);
 }
 
-void test__QList__length__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QList::length();
+void test__QStringList__startsWith__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QStringList::startsWith(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = QStringList::endsWith(arg1);
+    }
+    // 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__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__QString__size__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = QString::size(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QString::size();
+void test__QStringList__indexOf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QStringList::indexOf(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = QString::indexOf();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__QStringList__count__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QStringList::count();
+void test__QString__indexOf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QString::indexOf();
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = QString::isRightToLeft();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__QStringList__length__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QStringList::length();
+void test__QString__isRightToLeft__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QString::isRightToLeft();
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = QList::lastIndexOf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__QStringList__size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QStringList::size();
+void test__QList__lastIndexOf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QList::lastIndexOf(arg1, 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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QList::lastIndexOf(x, arg2);
 }
 
-void test__QList__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QList::empty();
+void test__QList__lastIndexOf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QList::lastIndexOf(arg1, 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__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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QList::isEmpty::QString::isEmpty();
+void test__QStringList__lastIndexOf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QStringList::lastIndexOf(arg1, 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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QStringList::lastIndexOf(x, arg2);
 }
 
-void test__QString__isNull__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QString::isNull();
+void test__QStringList__lastIndexOf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QStringList::lastIndexOf(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = QString::lastIndexOf(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__QStringList__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QStringList::empty();
+void test__QString__lastIndexOf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QString::lastIndexOf(arg1, 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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QString::lastIndexOf(x, arg2, arg3);
 }
 
-void test__QStringList__isEmpty____useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QStringList::isEmpty::();
+void test__QString__lastIndexOf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QString::lastIndexOf(arg1, x, arg3);
 }
 
-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__lastIndexOf__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QString::lastIndexOf(arg1, arg2, x);
 }
 
-void test__QString__fromStdString__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QString::fromStdString(arg1);
+void test__QString__left__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = QString::left(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QString::left(arg1);
 }
 
-void test__QList__indexOf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QList::indexOf(arg1);
+void test__QString__left__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QString::left(x);
 }
 
-void test__QList__indexOf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QList::indexOf(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__QStringList__indexOf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = QStringList::indexOf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__QList__mid__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QList::mid(arg1, arg2);
 }
 
-void test__QStringList__indexOf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QStringList::indexOf(arg1);
+void test__QList__mid__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QList::mid(x, arg2);
 }
 
-void test__QStringList__indexOf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QStringList::indexOf(x);
+void test__QList__mid__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QList::mid(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = QString::mid(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__QString__indexOf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QString::indexOf();
+void test__QString__mid__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QString::mid(arg1, 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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QString::mid(x, arg2);
 }
 
-void test__QString__isRightToLeft__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QString::isRightToLeft();
+void test__QString__mid__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QString::mid(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = QStringList::mid(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__QList__lastIndexOf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QList::lastIndexOf(arg1, arg2);
+void test__QStringList__mid__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QStringList::mid(arg1, arg2);
 }
 
-void test__QList__lastIndexOf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QList::lastIndexOf(x, arg2);
+void test__QStringList__mid__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QStringList::mid(x, arg2);
 }
 
-void test__QList__lastIndexOf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QList::lastIndexOf(arg1, x);
+void test__QStringList__mid__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QStringList::mid(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = QString::number();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__QStringList__lastIndexOf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QStringList::lastIndexOf(arg1, arg2);
+void test__QString__number__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QString::number();
 }
 
-void test__QStringList__lastIndexOf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QStringList::lastIndexOf(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QStringList::lastIndexOf(arg1, x);
+void test__QString__right__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QString::right(arg1);
 }
 
-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__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = QString::right(!x);
 }
 
-void test__QString__lastIndexOf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QString::lastIndexOf(arg1, arg2, arg3);
+void test__QString__right__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QString::right(x);
 }
 
-void test__QString__lastIndexOf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QString::lastIndexOf(x, 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__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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QString::split(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__QString__split__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QString::split(x);
 }
 
-void test__QList__mid__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QList::mid(arg1, arg2);
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QList::mid(x, arg2);
+void test__QString__toInt__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QString::toInt(arg1, arg2);
 }
 
-void test__QList__mid__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QList::mid(arg1, x);
+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__mid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = QString::mid(arg1, arg2); }
-  // 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__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__toUpper__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QString::toUpper();
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = QString::toUtf8();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  QMetaObject::connectSlotsByName(p);
-}
-
-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__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 a70b91210..8a3ec088e 100644
--- a/test/cfg/generated-cfg-tests-sdl.cpp
+++ b/test/cfg/generated-cfg-tests-sdl.cpp
@@ -8,122 +8,153 @@
 // => '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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SDL_mutexP(p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SDL_mutexV(p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SDL_RWsize(p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SDL_RWread(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SDL_RWread(arg1, p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  IMG_isPNG(p);
+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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  IMG_isJPG(p);
+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 8187f332e..cea9f8b49 100644
--- a/test/cfg/generated-cfg-tests-sfml.cpp
+++ b/test/cfg/generated-cfg-tests-sfml.cpp
@@ -8,1353 +8,1856 @@
 // => '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__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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sf::err();
+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__sleep__noreturn() {
-  int x = 1;
-  if (cond) { x=100; sf::sleep(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__sf__RenderWindow__getViewport__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sf::RenderWindow::getViewport(arg1);
 }
 
-void test__sf__sleep__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sf::sleep(x);
+void test__sf__RenderWindow__getViewport__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sf::RenderWindow::getViewport(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = sf::RenderTexture::getViewport(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__sf__Time__asSeconds__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sf::Time::asSeconds();
+void test__sf__RenderTexture__getViewport__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sf::RenderTexture::getViewport(arg1);
 }
 
-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__RenderTexture__getViewport__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sf::RenderTexture::getViewport(x);
 }
 
-void test__sf__Time__asMilliseconds__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sf::Time::asMilliseconds();
+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__asMicroseconds__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = sf::Time::asMicroseconds(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__sf__RenderTarget__mapPixelToCoords__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sf::RenderTarget::mapPixelToCoords(arg1, arg2);
 }
 
-void test__sf__Time__asMicroseconds__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sf::Time::asMicroseconds();
+void test__sf__RenderTarget__mapPixelToCoords__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sf::RenderTarget::mapPixelToCoords(x, arg2);
 }
 
-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__mapPixelToCoords__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sf::RenderTarget::mapPixelToCoords(arg1, 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__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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sf::String::isEmpty();
+void test__sf__RenderTarget__mapCoordsToPixel__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sf::RenderTarget::mapCoordsToPixel(arg1, 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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sf::RenderTarget::mapCoordsToPixel(x, arg2);
 }
 
-void test__sf__String__getSize__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sf::String::getSize();
+void test__sf__RenderTarget__mapCoordsToPixel__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sf::RenderTarget::mapCoordsToPixel(arg1, 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__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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  sf::String::find(p, arg2);
+void test__sf__RenderWindow__mapPixelToCoords__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sf::RenderWindow::mapPixelToCoords(arg1, arg2);
 }
 
-void test__sf__String__find__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  sf::String::find(x, arg2);
+void test__sf__RenderWindow__mapPixelToCoords__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sf::RenderWindow::mapPixelToCoords(x, arg2);
 }
 
-void test__sf__String__find__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sf::String::find(arg1, x);
+void test__sf__RenderWindow__mapPixelToCoords__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sf::RenderWindow::mapPixelToCoords(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__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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sf::String::substring(arg1, arg2);
+void test__sf__RenderWindow__mapCoordsToPixel__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sf::RenderWindow::mapCoordsToPixel(arg1, arg2);
 }
 
-void test__sf__String__substring__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = sf::String::substring(x, arg2);
+void test__sf__RenderWindow__mapCoordsToPixel__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sf::RenderWindow::mapCoordsToPixel(x, arg2);
 }
 
-void test__sf__String__substring__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = sf::String::substring(arg1, x);
+void test__sf__RenderWindow__mapCoordsToPixel__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sf::RenderWindow::mapCoordsToPixel(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__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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sf::String::erase(x, arg2);
+void test__sf__RenderTexture__mapPixelToCoords__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sf::RenderTexture::mapPixelToCoords(arg1, arg2);
 }
 
-void test__sf__String__erase__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sf::String::erase(arg1, x);
+void test__sf__RenderTexture__mapPixelToCoords__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sf::RenderTexture::mapPixelToCoords(x, arg2);
 }
 
-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__mapPixelToCoords__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sf::RenderTexture::mapPixelToCoords(arg1, x);
 }
 
-void test__sf__RenderTarget__clear__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sf::RenderTarget::clear(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__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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sf::RenderTexture::mapCoordsToPixel(arg1, arg2);
 }
 
-void test__sf__RenderWindow__clear__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sf::RenderWindow::clear(x);
+void test__sf__RenderTexture__mapCoordsToPixel__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sf::RenderTexture::mapCoordsToPixel(x, arg2);
 }
 
-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__mapCoordsToPixel__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sf::RenderTexture::mapCoordsToPixel(arg1, x);
 }
 
-void test__sf__RenderTexture__clear__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sf::RenderTexture::clear(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__setView__noreturn() {
-  int x = 1;
-  if (cond) { x=100; sf::RenderTarget::setView(arg1); }
-  // 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__setView__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sf::RenderTarget::setView(x);
+void test__sf__RenderTarget__draw__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sf::RenderTarget::draw(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sf::RenderTarget::draw(arg1, arg2, x, arg4);
 }
 
-void test__sf__RenderWindow__setView__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sf::RenderWindow::setView(x);
+void test__sf__RenderTarget__draw__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sf::RenderTarget::draw(arg1, arg2, arg3, 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__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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sf::RenderTexture::setView(x);
+void test__sf__RenderWindow__draw__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sf::RenderWindow::draw(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sf::RenderWindow::draw(arg1, x, arg3, arg4);
 }
 
-void test__sf__RenderTarget__getView__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sf::RenderTarget::getView();
+void test__sf__RenderWindow__draw__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sf::RenderWindow::draw(arg1, arg2, x, arg4);
 }
 
-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__RenderWindow__draw__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sf::RenderWindow::draw(arg1, arg2, arg3, x);
 }
 
-void test__sf__RenderTarget__getDefaultView__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sf::RenderTarget::getDefaultView();
+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__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__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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sf::RenderWindow::getView();
+void test__sf__RenderTexture__draw__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sf::RenderTexture::draw(arg1, arg2, arg3, x);
 }
 
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  sf::Window::setIcon(arg1, arg2, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  sf::RenderWindow::setIcon(arg1, arg2, p);
-}
-
-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__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 e391a847a..c4f1e81ba 100644
--- a/test/cfg/generated-cfg-tests-std.cpp
+++ b/test/cfg/generated-cfg-tests-std.cpp
@@ -8,29513 +8,37878 @@
 // => '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__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__std__abort__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::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__abs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = abs(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__abs__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    abs(arg1);
 }
 
-void test__abs__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  abs(arg1);
+void test__abs__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((abs(arg1) > 10) || (abs(arg1) < 100)) {}
 }
 
-void test__abs__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((abs(arg1) > 10) || (abs(arg1) < 100)) {}
+void test__abs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = abs(p);
+    // cppcheck-suppress memleak
 }
 
-void test__abs__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = abs(p);
-  // cppcheck-suppress memleak
+void test__abs__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = abs(!x);
 }
 
-void test__abs__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = abs(!x);
+void test__abs__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = abs(x);
 }
 
-void test__abs__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__std__abs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::abs(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__abs__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::abs(arg1);
 }
 
-void test__std__abs__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::abs(arg1);
+void test__std__abs__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::abs(arg1) > 10) || (std::abs(arg1) < 100)) {}
 }
 
-void test__std__abs__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::abs(arg1) > 10) || (std::abs(arg1) < 100)) {}
+void test__std__abs__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = std::abs(!x);
 }
 
-void test__std__abs__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = std::abs(!x);
+void test__std__abs__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::abs(x);
 }
 
-void test__std__abs__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__imaxabs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = imaxabs(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__imaxabs__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    imaxabs(arg1);
 }
 
-void test__imaxabs__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  imaxabs(arg1);
+void test__imaxabs__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((imaxabs(arg1) > 10) || (imaxabs(arg1) < 100)) {}
 }
 
-void test__imaxabs__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((imaxabs(arg1) > 10) || (imaxabs(arg1) < 100)) {}
+void test__imaxabs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = imaxabs(p);
+    // cppcheck-suppress memleak
 }
 
-void test__imaxabs__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = imaxabs(p);
-  // cppcheck-suppress memleak
+void test__imaxabs__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = imaxabs(x);
 }
 
-void test__imaxabs__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = imaxabs(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::imaxabs(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__imaxabs__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::imaxabs(arg1);
 }
 
-void test__std__imaxabs__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::imaxabs(arg1);
+void test__std__imaxabs__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::imaxabs(arg1) > 10) || (std::imaxabs(arg1) < 100)) {}
 }
 
-void test__std__imaxabs__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::imaxabs(arg1) > 10) || (std::imaxabs(arg1) < 100)) {}
+void test__std__imaxabs__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::imaxabs(x);
 }
 
-void test__std__imaxabs__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::imaxabs(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::proj(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__proj__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::proj(arg1);
 }
 
-void test__std__proj__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::proj(arg1);
+void test__std__proj__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::proj(arg1) > 10) || (std::proj(arg1) < 100)) {}
 }
 
-void test__std__proj__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::proj(arg1) > 10) || (std::proj(arg1) < 100)) {}
+void test__std__proj__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::proj(x);
 }
 
-void test__std__proj__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::proj(x);
+void test__cproj__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cproj(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cproj__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cproj(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cproj__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cproj(arg1);
 }
 
-void test__cproj__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cproj(arg1);
+void test__cproj__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cproj(arg1) > 10) || (cproj(arg1) < 100)) {}
 }
 
-void test__cproj__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cproj(arg1) > 10) || (cproj(arg1) < 100)) {}
+void test__cproj__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cproj(p);
+    // cppcheck-suppress memleak
 }
 
-void test__cproj__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cproj(p);
-  // cppcheck-suppress memleak
+void test__cproj__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cproj(x);
 }
 
-void test__cproj__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cproj(x);
+void test__cprojf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cprojf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cprojf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cprojf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cprojf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cprojf(arg1);
 }
 
-void test__cprojf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cprojf(arg1);
+void test__cprojf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cprojf(arg1) > 10) || (cprojf(arg1) < 100)) {}
 }
 
-void test__cprojf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cprojf(arg1) > 10) || (cprojf(arg1) < 100)) {}
+void test__cprojf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cprojf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__cprojf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cprojf(p);
-  // cppcheck-suppress memleak
+void test__cprojf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cprojf(x);
 }
 
-void test__cprojf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cprojf(x);
+void test__cprojl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cprojl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cprojl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cprojl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cprojl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cprojl(arg1);
 }
 
-void test__cprojl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cprojl(arg1);
+void test__cprojl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cprojl(arg1) > 10) || (cprojl(arg1) < 100)) {}
 }
 
-void test__cprojl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cprojl(arg1) > 10) || (cprojl(arg1) < 100)) {}
+void test__cprojl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cprojl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__cprojl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cprojl(p);
-  // cppcheck-suppress memleak
+void test__cprojl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cprojl(x);
 }
 
-void test__cprojl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cprojl(x);
+void test__creal__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = creal(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__creal__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = creal(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__creal__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    creal(arg1);
 }
 
-void test__creal__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  creal(arg1);
+void test__creal__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((creal(arg1) > 10) || (creal(arg1) < 100)) {}
 }
 
-void test__creal__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((creal(arg1) > 10) || (creal(arg1) < 100)) {}
+void test__creal__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = creal(p);
+    // cppcheck-suppress memleak
 }
 
-void test__creal__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = creal(p);
-  // cppcheck-suppress memleak
+void test__creal__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = creal(x);
 }
 
-void test__creal__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = creal(x);
+void test__crealf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = crealf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__crealf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = crealf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__crealf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    crealf(arg1);
 }
 
-void test__crealf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  crealf(arg1);
+void test__crealf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((crealf(arg1) > 10) || (crealf(arg1) < 100)) {}
 }
 
-void test__crealf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((crealf(arg1) > 10) || (crealf(arg1) < 100)) {}
+void test__crealf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = crealf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__crealf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = crealf(p);
-  // cppcheck-suppress memleak
+void test__crealf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = crealf(x);
 }
 
-void test__crealf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = crealf(x);
+void test__creall__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = creall(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__creall__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = creall(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__creall__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    creall(arg1);
 }
 
-void test__creall__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  creall(arg1);
+void test__creall__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((creall(arg1) > 10) || (creall(arg1) < 100)) {}
 }
 
-void test__creall__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((creall(arg1) > 10) || (creall(arg1) < 100)) {}
+void test__creall__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = creall(p);
+    // cppcheck-suppress memleak
 }
 
-void test__creall__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = creall(p);
-  // cppcheck-suppress memleak
+void test__creall__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = creall(x);
 }
 
-void test__creall__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = creall(x);
+void test__acos__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = acos(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__acos__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = acos(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__acos__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    acos(arg1);
 }
 
-void test__acos__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  acos(arg1);
+void test__acos__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((acos(arg1) > 10) || (acos(arg1) < 100)) {}
 }
 
-void test__acos__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((acos(arg1) > 10) || (acos(arg1) < 100)) {}
+void test__acos__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = acos(p);
+    // cppcheck-suppress memleak
 }
 
-void test__acos__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = acos(p);
-  // cppcheck-suppress memleak
+void test__acos__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = acos(x);
 }
 
-void test__acos__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = acos(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::acos(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__acos__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::acos(arg1);
 }
 
-void test__std__acos__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::acos(arg1);
+void test__std__acos__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::acos(arg1) > 10) || (std::acos(arg1) < 100)) {}
 }
 
-void test__std__acos__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::acos(arg1) > 10) || (std::acos(arg1) < 100)) {}
+void test__std__acos__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::acos(x);
 }
 
-void test__std__acos__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::acos(x);
+void test__acosf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = acosf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__acosf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = acosf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__acosf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    acosf(arg1);
 }
 
-void test__acosf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  acosf(arg1);
+void test__acosf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((acosf(arg1) > 10) || (acosf(arg1) < 100)) {}
 }
 
-void test__acosf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((acosf(arg1) > 10) || (acosf(arg1) < 100)) {}
+void test__acosf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = acosf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__acosf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = acosf(p);
-  // cppcheck-suppress memleak
+void test__acosf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = acosf(x);
 }
 
-void test__acosf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = acosf(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::acosf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__acosf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::acosf(arg1);
 }
 
-void test__std__acosf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::acosf(arg1);
+void test__std__acosf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::acosf(arg1) > 10) || (std::acosf(arg1) < 100)) {}
 }
 
-void test__std__acosf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::acosf(arg1) > 10) || (std::acosf(arg1) < 100)) {}
+void test__std__acosf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::acosf(x);
 }
 
-void test__std__acosf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::acosf(x);
+void test__acosl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = acosl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__acosl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = acosl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__acosl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    acosl(arg1);
 }
 
-void test__acosl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  acosl(arg1);
+void test__acosl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((acosl(arg1) > 10) || (acosl(arg1) < 100)) {}
 }
 
-void test__acosl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((acosl(arg1) > 10) || (acosl(arg1) < 100)) {}
+void test__acosl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = acosl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__acosl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = acosl(p);
-  // cppcheck-suppress memleak
+void test__acosl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = acosl(x);
 }
 
-void test__acosl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = acosl(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::acosl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__acosl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::acosl(arg1);
 }
 
-void test__std__acosl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::acosl(arg1);
+void test__std__acosl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::acosl(arg1) > 10) || (std::acosl(arg1) < 100)) {}
 }
 
-void test__std__acosl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::acosl(arg1) > 10) || (std::acosl(arg1) < 100)) {}
+void test__std__acosl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::acosl(x);
 }
 
-void test__std__acosl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::acosl(x);
+void test__acosh__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = acosh(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__acosh__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = acosh(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__acosh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    acosh(arg1);
 }
 
-void test__acosh__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  acosh(arg1);
+void test__acosh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((acosh(arg1) > 10) || (acosh(arg1) < 100)) {}
 }
 
-void test__acosh__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((acosh(arg1) > 10) || (acosh(arg1) < 100)) {}
+void test__acosh__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = acosh(p);
+    // cppcheck-suppress memleak
 }
 
-void test__acosh__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = acosh(p);
-  // cppcheck-suppress memleak
+void test__acosh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = acosh(x);
 }
 
-void test__acosh__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = acosh(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::acosh(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__acosh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::acosh(arg1);
 }
 
-void test__std__acosh__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::acosh(arg1);
+void test__std__acosh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::acosh(arg1) > 10) || (std::acosh(arg1) < 100)) {}
 }
 
-void test__std__acosh__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::acosh(arg1) > 10) || (std::acosh(arg1) < 100)) {}
+void test__std__acosh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::acosh(x);
 }
 
-void test__std__acosh__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::acosh(x);
+void test__acoshf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = acoshf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__acoshf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = acoshf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__acoshf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    acoshf(arg1);
 }
 
-void test__acoshf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  acoshf(arg1);
+void test__acoshf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((acoshf(arg1) > 10) || (acoshf(arg1) < 100)) {}
 }
 
-void test__acoshf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((acoshf(arg1) > 10) || (acoshf(arg1) < 100)) {}
+void test__acoshf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = acoshf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__acoshf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = acoshf(p);
-  // cppcheck-suppress memleak
+void test__acoshf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = acoshf(x);
 }
 
-void test__acoshf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = acoshf(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::acoshf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__acoshf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::acoshf(arg1);
 }
 
-void test__std__acoshf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::acoshf(arg1);
+void test__std__acoshf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::acoshf(arg1) > 10) || (std::acoshf(arg1) < 100)) {}
 }
 
-void test__std__acoshf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::acoshf(arg1) > 10) || (std::acoshf(arg1) < 100)) {}
+void test__std__acoshf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::acoshf(x);
 }
 
-void test__std__acoshf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::acoshf(x);
+void test__acoshl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = acoshl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__acoshl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = acoshl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__acoshl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    acoshl(arg1);
 }
 
-void test__acoshl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  acoshl(arg1);
+void test__acoshl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((acoshl(arg1) > 10) || (acoshl(arg1) < 100)) {}
 }
 
-void test__acoshl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((acoshl(arg1) > 10) || (acoshl(arg1) < 100)) {}
+void test__acoshl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = acoshl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__acoshl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = acoshl(p);
-  // cppcheck-suppress memleak
+void test__acoshl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = acoshl(x);
 }
 
-void test__acoshl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = acoshl(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::acoshl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__acoshl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::acoshl(arg1);
 }
 
-void test__std__acoshl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::acoshl(arg1);
+void test__std__acoshl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::acoshl(arg1) > 10) || (std::acoshl(arg1) < 100)) {}
 }
 
-void test__std__acoshl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::acoshl(arg1) > 10) || (std::acoshl(arg1) < 100)) {}
+void test__std__acoshl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::acoshl(x);
 }
 
-void test__std__acoshl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::acoshl(x);
+void test__asctime__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = asctime(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__asctime__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = asctime(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__asctime__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    asctime(arg1);
 }
 
-void test__asctime__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  asctime(arg1);
+void test__asctime__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = asctime(p);
+    // cppcheck-suppress memleak
 }
 
-void test__asctime__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = asctime(p);
-  // cppcheck-suppress memleak
+void test__asctime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = asctime(NULL);
 }
 
-void test__asctime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = asctime(p);
+void test__asctime__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = asctime(x);
 }
 
-void test__asctime__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = asctime(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::asctime(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__asctime__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::asctime(arg1);
 }
 
-void test__std__asctime__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::asctime(arg1);
+void test__std__asctime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::asctime(NULL);
 }
 
-void test__std__asctime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::asctime(p);
+void test__std__asctime__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::asctime(x);
 }
 
-void test__std__asctime__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::asctime(x);
+void test__assert__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    assert(p);
+    // cppcheck-suppress memleak
 }
 
-void test__assert__leakignore() {
-  char *p = malloc(10); *p=0;
-  assert(p);
-  // cppcheck-suppress memleak
+void test__assert__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    assert(x);
 }
 
-void test__assert__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  assert(x);
+void test__sqrt__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = sqrt(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__sqrt__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = sqrt(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__sqrt__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sqrt(arg1);
 }
 
-void test__sqrt__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sqrt(arg1);
+void test__sqrt__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((sqrt(arg1) > 10) || (sqrt(arg1) < 100)) {}
 }
 
-void test__sqrt__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((sqrt(arg1) > 10) || (sqrt(arg1) < 100)) {}
+void test__sqrt__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = sqrt(p);
+    // cppcheck-suppress memleak
 }
 
-void test__sqrt__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = sqrt(p);
-  // cppcheck-suppress memleak
+void test__sqrt__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sqrt(x);
 }
 
-void test__sqrt__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = sqrt(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::sqrt(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__sqrt__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::sqrt(arg1);
 }
 
-void test__std__sqrt__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::sqrt(arg1);
+void test__std__sqrt__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::sqrt(arg1) > 10) || (std::sqrt(arg1) < 100)) {}
 }
 
-void test__std__sqrt__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::sqrt(arg1) > 10) || (std::sqrt(arg1) < 100)) {}
+void test__std__sqrt__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::sqrt(x);
 }
 
-void test__std__sqrt__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::sqrt(x);
+void test__sqrtf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = sqrtf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__sqrtf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = sqrtf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__sqrtf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sqrtf(arg1);
 }
 
-void test__sqrtf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sqrtf(arg1);
+void test__sqrtf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((sqrtf(arg1) > 10) || (sqrtf(arg1) < 100)) {}
 }
 
-void test__sqrtf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((sqrtf(arg1) > 10) || (sqrtf(arg1) < 100)) {}
+void test__sqrtf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = sqrtf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__sqrtf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = sqrtf(p);
-  // cppcheck-suppress memleak
+void test__sqrtf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sqrtf(x);
 }
 
-void test__sqrtf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = sqrtf(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::sqrtf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__sqrtf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::sqrtf(arg1);
 }
 
-void test__std__sqrtf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::sqrtf(arg1);
+void test__std__sqrtf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::sqrtf(arg1) > 10) || (std::sqrtf(arg1) < 100)) {}
 }
 
-void test__std__sqrtf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::sqrtf(arg1) > 10) || (std::sqrtf(arg1) < 100)) {}
+void test__std__sqrtf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::sqrtf(x);
 }
 
-void test__std__sqrtf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::sqrtf(x);
+void test__sqrtl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = sqrtl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__sqrtl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = sqrtl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__sqrtl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sqrtl(arg1);
 }
 
-void test__sqrtl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sqrtl(arg1);
+void test__sqrtl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((sqrtl(arg1) > 10) || (sqrtl(arg1) < 100)) {}
 }
 
-void test__sqrtl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((sqrtl(arg1) > 10) || (sqrtl(arg1) < 100)) {}
+void test__sqrtl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = sqrtl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__sqrtl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = sqrtl(p);
-  // cppcheck-suppress memleak
+void test__sqrtl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sqrtl(x);
 }
 
-void test__sqrtl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = sqrtl(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::sqrtl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__sqrtl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::sqrtl(arg1);
 }
 
-void test__std__sqrtl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::sqrtl(arg1);
+void test__std__sqrtl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::sqrtl(arg1) > 10) || (std::sqrtl(arg1) < 100)) {}
 }
 
-void test__std__sqrtl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::sqrtl(arg1) > 10) || (std::sqrtl(arg1) < 100)) {}
+void test__std__sqrtl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::sqrtl(x);
 }
 
-void test__std__sqrtl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::sqrtl(x);
+void test__csqrt__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = csqrt(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__csqrt__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = csqrt(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__csqrt__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    csqrt(arg1);
 }
 
-void test__csqrt__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  csqrt(arg1);
+void test__csqrt__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((csqrt(arg1) > 10) || (csqrt(arg1) < 100)) {}
 }
 
-void test__csqrt__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((csqrt(arg1) > 10) || (csqrt(arg1) < 100)) {}
+void test__csqrt__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = csqrt(p);
+    // cppcheck-suppress memleak
 }
 
-void test__csqrt__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = csqrt(p);
-  // cppcheck-suppress memleak
+void test__csqrt__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = csqrt(x);
 }
 
-void test__csqrt__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = csqrt(x);
+void test__csqrtf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = csqrtf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__csqrtf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = csqrtf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__csqrtf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    csqrtf(arg1);
 }
 
-void test__csqrtf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  csqrtf(arg1);
+void test__csqrtf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((csqrtf(arg1) > 10) || (csqrtf(arg1) < 100)) {}
 }
 
-void test__csqrtf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((csqrtf(arg1) > 10) || (csqrtf(arg1) < 100)) {}
+void test__csqrtf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = csqrtf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__csqrtf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = csqrtf(p);
-  // cppcheck-suppress memleak
+void test__csqrtf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = csqrtf(x);
 }
 
-void test__csqrtf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = csqrtf(x);
+void test__csqrtl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = csqrtl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__csqrtl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = csqrtl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__csqrtl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    csqrtl(arg1);
 }
 
-void test__csqrtl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  csqrtl(arg1);
+void test__csqrtl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((csqrtl(arg1) > 10) || (csqrtl(arg1) < 100)) {}
 }
 
-void test__csqrtl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((csqrtl(arg1) > 10) || (csqrtl(arg1) < 100)) {}
+void test__csqrtl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = csqrtl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__csqrtl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = csqrtl(p);
-  // cppcheck-suppress memleak
+void test__csqrtl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = csqrtl(x);
 }
 
-void test__csqrtl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = csqrtl(x);
+void test__sinh__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = sinh(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__sinh__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = sinh(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__sinh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sinh(arg1);
 }
 
-void test__sinh__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sinh(arg1);
+void test__sinh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((sinh(arg1) > 10) || (sinh(arg1) < 100)) {}
 }
 
-void test__sinh__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((sinh(arg1) > 10) || (sinh(arg1) < 100)) {}
+void test__sinh__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = sinh(p);
+    // cppcheck-suppress memleak
 }
 
-void test__sinh__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = sinh(p);
-  // cppcheck-suppress memleak
+void test__sinh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sinh(x);
 }
 
-void test__sinh__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = sinh(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::sinh(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__sinh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::sinh(arg1);
 }
 
-void test__std__sinh__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::sinh(arg1);
+void test__std__sinh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::sinh(arg1) > 10) || (std::sinh(arg1) < 100)) {}
 }
 
-void test__std__sinh__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::sinh(arg1) > 10) || (std::sinh(arg1) < 100)) {}
+void test__std__sinh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::sinh(x);
 }
 
-void test__std__sinh__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::sinh(x);
+void test__sinhf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = sinhf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__sinhf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = sinhf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__sinhf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sinhf(arg1);
 }
 
-void test__sinhf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sinhf(arg1);
+void test__sinhf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((sinhf(arg1) > 10) || (sinhf(arg1) < 100)) {}
 }
 
-void test__sinhf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((sinhf(arg1) > 10) || (sinhf(arg1) < 100)) {}
+void test__sinhf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = sinhf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__sinhf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = sinhf(p);
-  // cppcheck-suppress memleak
+void test__sinhf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sinhf(x);
 }
 
-void test__sinhf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = sinhf(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::sinhf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__sinhf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::sinhf(arg1);
 }
 
-void test__std__sinhf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::sinhf(arg1);
+void test__std__sinhf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::sinhf(arg1) > 10) || (std::sinhf(arg1) < 100)) {}
 }
 
-void test__std__sinhf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::sinhf(arg1) > 10) || (std::sinhf(arg1) < 100)) {}
+void test__std__sinhf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::sinhf(x);
 }
 
-void test__std__sinhf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::sinhf(x);
+void test__sinhl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = sinhl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__sinhl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = sinhl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__sinhl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sinhl(arg1);
 }
 
-void test__sinhl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sinhl(arg1);
+void test__sinhl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((sinhl(arg1) > 10) || (sinhl(arg1) < 100)) {}
 }
 
-void test__sinhl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((sinhl(arg1) > 10) || (sinhl(arg1) < 100)) {}
+void test__sinhl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = sinhl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__sinhl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = sinhl(p);
-  // cppcheck-suppress memleak
+void test__sinhl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sinhl(x);
 }
 
-void test__sinhl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = sinhl(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::sinhl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__sinhl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::sinhl(arg1);
 }
 
-void test__std__sinhl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::sinhl(arg1);
+void test__std__sinhl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::sinhl(arg1) > 10) || (std::sinhl(arg1) < 100)) {}
 }
 
-void test__std__sinhl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::sinhl(arg1) > 10) || (std::sinhl(arg1) < 100)) {}
+void test__std__sinhl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::sinhl(x);
 }
 
-void test__std__sinhl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::sinhl(x);
+void test__sin__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = sin(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__sin__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = sin(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__sin__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sin(arg1);
 }
 
-void test__sin__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sin(arg1);
+void test__sin__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((sin(arg1) > 10) || (sin(arg1) < 100)) {}
 }
 
-void test__sin__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((sin(arg1) > 10) || (sin(arg1) < 100)) {}
+void test__sin__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = sin(p);
+    // cppcheck-suppress memleak
 }
 
-void test__sin__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = sin(p);
-  // cppcheck-suppress memleak
+void test__sin__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sin(x);
 }
 
-void test__sin__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = sin(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::sin(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__sin__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::sin(arg1);
 }
 
-void test__std__sin__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::sin(arg1);
+void test__std__sin__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::sin(arg1) > 10) || (std::sin(arg1) < 100)) {}
 }
 
-void test__std__sin__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::sin(arg1) > 10) || (std::sin(arg1) < 100)) {}
+void test__std__sin__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::sin(x);
 }
 
-void test__std__sin__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::sin(x);
+void test__sinf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = sinf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__sinf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = sinf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__sinf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sinf(arg1);
 }
 
-void test__sinf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sinf(arg1);
+void test__sinf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((sinf(arg1) > 10) || (sinf(arg1) < 100)) {}
 }
 
-void test__sinf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((sinf(arg1) > 10) || (sinf(arg1) < 100)) {}
+void test__sinf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = sinf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__sinf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = sinf(p);
-  // cppcheck-suppress memleak
+void test__sinf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sinf(x);
 }
 
-void test__sinf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = sinf(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::sinf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__sinf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::sinf(arg1);
 }
 
-void test__std__sinf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::sinf(arg1);
+void test__std__sinf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::sinf(arg1) > 10) || (std::sinf(arg1) < 100)) {}
 }
 
-void test__std__sinf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::sinf(arg1) > 10) || (std::sinf(arg1) < 100)) {}
+void test__std__sinf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::sinf(x);
 }
 
-void test__std__sinf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::sinf(x);
+void test__sinl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = sinl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__sinl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = sinl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__sinl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    sinl(arg1);
 }
 
-void test__sinl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  sinl(arg1);
+void test__sinl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((sinl(arg1) > 10) || (sinl(arg1) < 100)) {}
 }
 
-void test__sinl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((sinl(arg1) > 10) || (sinl(arg1) < 100)) {}
+void test__sinl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = sinl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__sinl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = sinl(p);
-  // cppcheck-suppress memleak
+void test__sinl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = sinl(x);
 }
 
-void test__sinl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = sinl(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::sinl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__sinl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::sinl(arg1);
 }
 
-void test__std__sinl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::sinl(arg1);
+void test__std__sinl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::sinl(arg1) > 10) || (std::sinl(arg1) < 100)) {}
 }
 
-void test__std__sinl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::sinl(arg1) > 10) || (std::sinl(arg1) < 100)) {}
+void test__std__sinl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::sinl(x);
 }
 
-void test__std__sinl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::sinl(x);
+void test__csin__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = csin(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__csin__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = csin(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__csin__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    csin(arg1);
 }
 
-void test__csin__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  csin(arg1);
+void test__csin__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((csin(arg1) > 10) || (csin(arg1) < 100)) {}
 }
 
-void test__csin__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((csin(arg1) > 10) || (csin(arg1) < 100)) {}
+void test__csin__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = csin(p);
+    // cppcheck-suppress memleak
 }
 
-void test__csin__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = csin(p);
-  // cppcheck-suppress memleak
+void test__csin__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = csin(x);
 }
 
-void test__csin__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = csin(x);
+void test__csinf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = csinf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__csinf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = csinf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__csinf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    csinf(arg1);
 }
 
-void test__csinf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  csinf(arg1);
+void test__csinf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((csinf(arg1) > 10) || (csinf(arg1) < 100)) {}
 }
 
-void test__csinf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((csinf(arg1) > 10) || (csinf(arg1) < 100)) {}
+void test__csinf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = csinf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__csinf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = csinf(p);
-  // cppcheck-suppress memleak
+void test__csinf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = csinf(x);
 }
 
-void test__csinf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = csinf(x);
+void test__csinl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = csinl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__csinl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = csinl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__csinl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    csinl(arg1);
 }
 
-void test__csinl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  csinl(arg1);
+void test__csinl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((csinl(arg1) > 10) || (csinl(arg1) < 100)) {}
 }
 
-void test__csinl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((csinl(arg1) > 10) || (csinl(arg1) < 100)) {}
+void test__csinl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = csinl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__csinl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = csinl(p);
-  // cppcheck-suppress memleak
+void test__csinl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = csinl(x);
 }
 
-void test__csinl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = csinl(x);
+void test__csinh__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = csinh(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__csinh__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = csinh(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__csinh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    csinh(arg1);
 }
 
-void test__csinh__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  csinh(arg1);
+void test__csinh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((csinh(arg1) > 10) || (csinh(arg1) < 100)) {}
 }
 
-void test__csinh__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((csinh(arg1) > 10) || (csinh(arg1) < 100)) {}
+void test__csinh__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = csinh(p);
+    // cppcheck-suppress memleak
 }
 
-void test__csinh__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = csinh(p);
-  // cppcheck-suppress memleak
+void test__csinh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = csinh(x);
 }
 
-void test__csinh__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = csinh(x);
+void test__csinhf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = csinhf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__csinhf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = csinhf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__csinhf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    csinhf(arg1);
 }
 
-void test__csinhf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  csinhf(arg1);
+void test__csinhf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((csinhf(arg1) > 10) || (csinhf(arg1) < 100)) {}
 }
 
-void test__csinhf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((csinhf(arg1) > 10) || (csinhf(arg1) < 100)) {}
+void test__csinhf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = csinhf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__csinhf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = csinhf(p);
-  // cppcheck-suppress memleak
+void test__csinhf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = csinhf(x);
 }
 
-void test__csinhf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = csinhf(x);
+void test__csinhl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = csinhl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__csinhl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = csinhl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__csinhl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    csinhl(arg1);
 }
 
-void test__csinhl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  csinhl(arg1);
+void test__csinhl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((csinhl(arg1) > 10) || (csinhl(arg1) < 100)) {}
 }
 
-void test__csinhl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((csinhl(arg1) > 10) || (csinhl(arg1) < 100)) {}
+void test__csinhl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = csinhl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__csinhl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = csinhl(p);
-  // cppcheck-suppress memleak
+void test__csinhl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = csinhl(x);
 }
 
-void test__csinhl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = csinhl(x);
+void test__asin__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = asin(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__asin__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = asin(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__asin__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    asin(arg1);
 }
 
-void test__asin__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  asin(arg1);
+void test__asin__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((asin(arg1) > 10) || (asin(arg1) < 100)) {}
 }
 
-void test__asin__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((asin(arg1) > 10) || (asin(arg1) < 100)) {}
+void test__asin__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = asin(p);
+    // cppcheck-suppress memleak
 }
 
-void test__asin__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = asin(p);
-  // cppcheck-suppress memleak
+void test__asin__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = asin(x);
 }
 
-void test__asin__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = asin(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::asin(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__asin__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::asin(arg1);
 }
 
-void test__std__asin__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::asin(arg1);
+void test__std__asin__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::asin(arg1) > 10) || (std::asin(arg1) < 100)) {}
 }
 
-void test__std__asin__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::asin(arg1) > 10) || (std::asin(arg1) < 100)) {}
+void test__std__asin__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::asin(x);
 }
 
-void test__std__asin__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::asin(x);
+void test__asinf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = asinf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__asinf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = asinf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__asinf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    asinf(arg1);
 }
 
-void test__asinf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  asinf(arg1);
+void test__asinf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((asinf(arg1) > 10) || (asinf(arg1) < 100)) {}
 }
 
-void test__asinf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((asinf(arg1) > 10) || (asinf(arg1) < 100)) {}
+void test__asinf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = asinf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__asinf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = asinf(p);
-  // cppcheck-suppress memleak
+void test__asinf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = asinf(x);
 }
 
-void test__asinf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = asinf(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::asinf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__asinf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::asinf(arg1);
 }
 
-void test__std__asinf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::asinf(arg1);
+void test__std__asinf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::asinf(arg1) > 10) || (std::asinf(arg1) < 100)) {}
 }
 
-void test__std__asinf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::asinf(arg1) > 10) || (std::asinf(arg1) < 100)) {}
+void test__std__asinf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::asinf(x);
 }
 
-void test__std__asinf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::asinf(x);
+void test__asinl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = asinl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__asinl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = asinl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__asinl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    asinl(arg1);
 }
 
-void test__asinl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  asinl(arg1);
+void test__asinl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((asinl(arg1) > 10) || (asinl(arg1) < 100)) {}
 }
 
-void test__asinl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((asinl(arg1) > 10) || (asinl(arg1) < 100)) {}
+void test__asinl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = asinl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__asinl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = asinl(p);
-  // cppcheck-suppress memleak
+void test__asinl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = asinl(x);
 }
 
-void test__asinl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = asinl(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::asinl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__asinl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::asinl(arg1);
 }
 
-void test__std__asinl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::asinl(arg1);
+void test__std__asinl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::asinl(arg1) > 10) || (std::asinl(arg1) < 100)) {}
 }
 
-void test__std__asinl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::asinl(arg1) > 10) || (std::asinl(arg1) < 100)) {}
+void test__std__asinl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::asinl(x);
 }
 
-void test__std__asinl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::asinl(x);
+void test__casin__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = casin(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__casin__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = casin(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__casin__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    casin(arg1);
 }
 
-void test__casin__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  casin(arg1);
+void test__casin__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((casin(arg1) > 10) || (casin(arg1) < 100)) {}
 }
 
-void test__casin__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((casin(arg1) > 10) || (casin(arg1) < 100)) {}
+void test__casin__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = casin(p);
+    // cppcheck-suppress memleak
 }
 
-void test__casin__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = casin(p);
-  // cppcheck-suppress memleak
+void test__casin__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = casin(x);
 }
 
-void test__casin__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = casin(x);
+void test__casinf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = casinf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__casinf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = casinf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__casinf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    casinf(arg1);
 }
 
-void test__casinf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  casinf(arg1);
+void test__casinf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((casinf(arg1) > 10) || (casinf(arg1) < 100)) {}
 }
 
-void test__casinf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((casinf(arg1) > 10) || (casinf(arg1) < 100)) {}
+void test__casinf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = casinf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__casinf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = casinf(p);
-  // cppcheck-suppress memleak
+void test__casinf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = casinf(x);
 }
 
-void test__casinf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = casinf(x);
+void test__casinl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = casinl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__casinl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = casinl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__casinl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    casinl(arg1);
 }
 
-void test__casinl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  casinl(arg1);
+void test__casinl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((casinl(arg1) > 10) || (casinl(arg1) < 100)) {}
 }
 
-void test__casinl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((casinl(arg1) > 10) || (casinl(arg1) < 100)) {}
+void test__casinl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = casinl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__casinl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = casinl(p);
-  // cppcheck-suppress memleak
+void test__casinl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = casinl(x);
 }
 
-void test__casinl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = casinl(x);
+void test__asinh__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = asinh(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__asinh__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = asinh(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__asinh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    asinh(arg1);
 }
 
-void test__asinh__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  asinh(arg1);
+void test__asinh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((asinh(arg1) > 10) || (asinh(arg1) < 100)) {}
 }
 
-void test__asinh__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((asinh(arg1) > 10) || (asinh(arg1) < 100)) {}
+void test__asinh__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = asinh(p);
+    // cppcheck-suppress memleak
 }
 
-void test__asinh__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = asinh(p);
-  // cppcheck-suppress memleak
+void test__asinh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = asinh(x);
 }
 
-void test__asinh__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = asinh(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::asinh(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__asinh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::asinh(arg1);
 }
 
-void test__std__asinh__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::asinh(arg1);
+void test__std__asinh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::asinh(arg1) > 10) || (std::asinh(arg1) < 100)) {}
 }
 
-void test__std__asinh__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::asinh(arg1) > 10) || (std::asinh(arg1) < 100)) {}
+void test__std__asinh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::asinh(x);
 }
 
-void test__std__asinh__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::asinh(x);
+void test__asinhf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = asinhf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__asinhf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = asinhf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__asinhf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    asinhf(arg1);
 }
 
-void test__asinhf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  asinhf(arg1);
+void test__asinhf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((asinhf(arg1) > 10) || (asinhf(arg1) < 100)) {}
 }
 
-void test__asinhf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((asinhf(arg1) > 10) || (asinhf(arg1) < 100)) {}
+void test__asinhf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = asinhf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__asinhf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = asinhf(p);
-  // cppcheck-suppress memleak
+void test__asinhf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = asinhf(x);
 }
 
-void test__asinhf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = asinhf(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::asinhf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__asinhf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::asinhf(arg1);
 }
 
-void test__std__asinhf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::asinhf(arg1);
+void test__std__asinhf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::asinhf(arg1) > 10) || (std::asinhf(arg1) < 100)) {}
 }
 
-void test__std__asinhf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::asinhf(arg1) > 10) || (std::asinhf(arg1) < 100)) {}
+void test__std__asinhf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::asinhf(x);
 }
 
-void test__std__asinhf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::asinhf(x);
+void test__asinhl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = asinhl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__asinhl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = asinhl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__asinhl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    asinhl(arg1);
 }
 
-void test__asinhl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  asinhl(arg1);
+void test__asinhl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((asinhl(arg1) > 10) || (asinhl(arg1) < 100)) {}
 }
 
-void test__asinhl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((asinhl(arg1) > 10) || (asinhl(arg1) < 100)) {}
+void test__asinhl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = asinhl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__asinhl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = asinhl(p);
-  // cppcheck-suppress memleak
+void test__asinhl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = asinhl(x);
 }
 
-void test__asinhl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = asinhl(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::asinhl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__asinhl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::asinhl(arg1);
 }
 
-void test__std__asinhl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::asinhl(arg1);
+void test__std__asinhl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::asinhl(arg1) > 10) || (std::asinhl(arg1) < 100)) {}
 }
 
-void test__std__asinhl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::asinhl(arg1) > 10) || (std::asinhl(arg1) < 100)) {}
+void test__std__asinhl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::asinhl(x);
 }
 
-void test__std__asinhl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::asinhl(x);
+void test__casinh__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = casinh(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__casinh__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = casinh(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__casinh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    casinh(arg1);
 }
 
-void test__casinh__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  casinh(arg1);
+void test__casinh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((casinh(arg1) > 10) || (casinh(arg1) < 100)) {}
 }
 
-void test__casinh__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((casinh(arg1) > 10) || (casinh(arg1) < 100)) {}
+void test__casinh__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = casinh(p);
+    // cppcheck-suppress memleak
 }
 
-void test__casinh__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = casinh(p);
-  // cppcheck-suppress memleak
+void test__casinh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = casinh(x);
 }
 
-void test__casinh__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = casinh(x);
+void test__casinhf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = casinhf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__casinhf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = casinhf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__casinhf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    casinhf(arg1);
 }
 
-void test__casinhf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  casinhf(arg1);
+void test__casinhf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((casinhf(arg1) > 10) || (casinhf(arg1) < 100)) {}
 }
 
-void test__casinhf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((casinhf(arg1) > 10) || (casinhf(arg1) < 100)) {}
+void test__casinhf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = casinhf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__casinhf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = casinhf(p);
-  // cppcheck-suppress memleak
+void test__casinhf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = casinhf(x);
 }
 
-void test__casinhf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = casinhf(x);
+void test__casinhl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = casinhl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__casinhl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = casinhl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__casinhl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    casinhl(arg1);
 }
 
-void test__casinhl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  casinhl(arg1);
+void test__casinhl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((casinhl(arg1) > 10) || (casinhl(arg1) < 100)) {}
 }
 
-void test__casinhl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((casinhl(arg1) > 10) || (casinhl(arg1) < 100)) {}
+void test__casinhl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = casinhl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__casinhl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = casinhl(p);
-  // cppcheck-suppress memleak
+void test__casinhl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = casinhl(x);
 }
 
-void test__casinhl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = casinhl(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wcsftime(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcsftime(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__wcsftime__leakignore() {
-  char *p = malloc(10); *p=0;
-  wcsftime(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__wcsftime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcsftime(NULL, arg2, arg3, arg4);
 }
 
-void test__wcsftime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcsftime(p, arg2, arg3, arg4);
+void test__wcsftime__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wcsftime(arg1, x, arg3, arg4);
 }
 
-void test__wcsftime__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wcsftime(arg1, x, arg3, arg4);
+void test__wcsftime__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcsftime(arg1, arg2, NULL, arg4);
 }
 
-void test__wcsftime__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcsftime(arg1, arg2, p, arg4);
+void test__wcsftime__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcsftime(arg1, arg2, x, arg4);
 }
 
-void test__wcsftime__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcsftime(arg1, arg2, x, arg4);
+void test__wcsftime__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcsftime(arg1, arg2, arg3, NULL);
 }
 
-void test__wcsftime__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcsftime(arg1, arg2, arg3, p);
+void test__wcsftime__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcsftime(arg1, arg2, arg3, x);
 }
 
-void test__wcsftime__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcsftime(arg1, arg2, arg3, x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::wcsftime(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__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__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcsftime(NULL, arg2, arg3, arg4);
 }
 
-void test__std__wcsftime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcsftime(p, arg2, arg3, arg4);
+void test__std__wcsftime__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wcsftime(arg1, x, arg3, arg4);
 }
 
-void test__std__wcsftime__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wcsftime(arg1, x, arg3, arg4);
+void test__std__wcsftime__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcsftime(arg1, arg2, NULL, arg4);
 }
 
-void test__std__wcsftime__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcsftime(arg1, arg2, p, arg4);
+void test__std__wcsftime__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wcsftime(arg1, arg2, x, arg4);
 }
 
-void test__std__wcsftime__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wcsftime(arg1, arg2, x, arg4);
+void test__std__wcsftime__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcsftime(arg1, arg2, arg3, NULL);
 }
 
-void test__std__wcsftime__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcsftime(arg1, arg2, arg3, p);
+void test__std__wcsftime__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wcsftime(arg1, arg2, arg3, x);
 }
 
-void test__std__wcsftime__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wcsftime(arg1, arg2, arg3, x);
+void test__tan__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = tan(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__tan__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = tan(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__tan__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    tan(arg1);
 }
 
-void test__tan__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  tan(arg1);
+void test__tan__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((tan(arg1) > 10) || (tan(arg1) < 100)) {}
 }
 
-void test__tan__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((tan(arg1) > 10) || (tan(arg1) < 100)) {}
+void test__tan__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = tan(p);
+    // cppcheck-suppress memleak
 }
 
-void test__tan__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = tan(p);
-  // cppcheck-suppress memleak
+void test__tan__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = tan(x);
 }
 
-void test__tan__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = tan(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::tan(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__tan__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::tan(arg1);
 }
 
-void test__std__tan__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::tan(arg1);
+void test__std__tan__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::tan(arg1) > 10) || (std::tan(arg1) < 100)) {}
 }
 
-void test__std__tan__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::tan(arg1) > 10) || (std::tan(arg1) < 100)) {}
+void test__std__tan__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::tan(x);
 }
 
-void test__std__tan__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::tan(x);
+void test__tanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = tanf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__tanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = tanf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__tanf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    tanf(arg1);
 }
 
-void test__tanf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  tanf(arg1);
+void test__tanf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((tanf(arg1) > 10) || (tanf(arg1) < 100)) {}
 }
 
-void test__tanf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((tanf(arg1) > 10) || (tanf(arg1) < 100)) {}
+void test__tanf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = tanf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__tanf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = tanf(p);
-  // cppcheck-suppress memleak
+void test__tanf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = tanf(x);
 }
 
-void test__tanf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = tanf(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::tanf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__tanf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::tanf(arg1);
 }
 
-void test__std__tanf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::tanf(arg1);
+void test__std__tanf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::tanf(arg1) > 10) || (std::tanf(arg1) < 100)) {}
 }
 
-void test__std__tanf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::tanf(arg1) > 10) || (std::tanf(arg1) < 100)) {}
+void test__std__tanf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::tanf(x);
 }
 
-void test__std__tanf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::tanf(x);
+void test__tanl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = tanl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__tanl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = tanl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__tanl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    tanl(arg1);
 }
 
-void test__tanl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  tanl(arg1);
+void test__tanl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((tanl(arg1) > 10) || (tanl(arg1) < 100)) {}
 }
 
-void test__tanl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((tanl(arg1) > 10) || (tanl(arg1) < 100)) {}
+void test__tanl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = tanl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__tanl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = tanl(p);
-  // cppcheck-suppress memleak
+void test__tanl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = tanl(x);
 }
 
-void test__tanl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = tanl(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::tanl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__tanl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::tanl(arg1);
 }
 
-void test__std__tanl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::tanl(arg1);
+void test__std__tanl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::tanl(arg1) > 10) || (std::tanl(arg1) < 100)) {}
 }
 
-void test__std__tanl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::tanl(arg1) > 10) || (std::tanl(arg1) < 100)) {}
+void test__std__tanl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::tanl(x);
 }
 
-void test__std__tanl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::tanl(x);
+void test__ctan__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ctan(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ctan__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ctan(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ctan__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ctan(arg1);
 }
 
-void test__ctan__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ctan(arg1);
+void test__ctan__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ctan(arg1) > 10) || (ctan(arg1) < 100)) {}
 }
 
-void test__ctan__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ctan(arg1) > 10) || (ctan(arg1) < 100)) {}
+void test__ctan__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ctan(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ctan__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ctan(p);
-  // cppcheck-suppress memleak
+void test__ctan__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ctan(x);
 }
 
-void test__ctan__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ctan(x);
+void test__ctanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ctanf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ctanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ctanf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ctanf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ctanf(arg1);
 }
 
-void test__ctanf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ctanf(arg1);
+void test__ctanf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ctanf(arg1) > 10) || (ctanf(arg1) < 100)) {}
 }
 
-void test__ctanf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ctanf(arg1) > 10) || (ctanf(arg1) < 100)) {}
+void test__ctanf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ctanf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ctanf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ctanf(p);
-  // cppcheck-suppress memleak
+void test__ctanf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ctanf(x);
 }
 
-void test__ctanf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ctanf(x);
+void test__ctanl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ctanl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ctanl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ctanl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ctanl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ctanl(arg1);
 }
 
-void test__ctanl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ctanl(arg1);
+void test__ctanl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ctanl(arg1) > 10) || (ctanl(arg1) < 100)) {}
 }
 
-void test__ctanl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ctanl(arg1) > 10) || (ctanl(arg1) < 100)) {}
+void test__ctanl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ctanl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ctanl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ctanl(p);
-  // cppcheck-suppress memleak
+void test__ctanl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ctanl(x);
 }
 
-void test__ctanl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ctanl(x);
+void test__tanh__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = tanh(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__tanh__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = tanh(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__tanh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    tanh(arg1);
 }
 
-void test__tanh__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  tanh(arg1);
+void test__tanh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((tanh(arg1) > 10) || (tanh(arg1) < 100)) {}
 }
 
-void test__tanh__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((tanh(arg1) > 10) || (tanh(arg1) < 100)) {}
+void test__tanh__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = tanh(p);
+    // cppcheck-suppress memleak
 }
 
-void test__tanh__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = tanh(p);
-  // cppcheck-suppress memleak
+void test__tanh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = tanh(x);
 }
 
-void test__tanh__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = tanh(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::tanh(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__tanh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::tanh(arg1);
 }
 
-void test__std__tanh__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::tanh(arg1);
+void test__std__tanh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::tanh(arg1) > 10) || (std::tanh(arg1) < 100)) {}
 }
 
-void test__std__tanh__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::tanh(arg1) > 10) || (std::tanh(arg1) < 100)) {}
+void test__std__tanh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::tanh(x);
 }
 
-void test__std__tanh__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::tanh(x);
+void test__tanhf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = tanhf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__tanhf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = tanhf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__tanhf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    tanhf(arg1);
 }
 
-void test__tanhf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  tanhf(arg1);
+void test__tanhf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((tanhf(arg1) > 10) || (tanhf(arg1) < 100)) {}
 }
 
-void test__tanhf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((tanhf(arg1) > 10) || (tanhf(arg1) < 100)) {}
+void test__tanhf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = tanhf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__tanhf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = tanhf(p);
-  // cppcheck-suppress memleak
+void test__tanhf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = tanhf(x);
 }
 
-void test__tanhf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = tanhf(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::tanhf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__tanhf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::tanhf(arg1);
 }
 
-void test__std__tanhf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::tanhf(arg1);
+void test__std__tanhf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::tanhf(arg1) > 10) || (std::tanhf(arg1) < 100)) {}
 }
 
-void test__std__tanhf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::tanhf(arg1) > 10) || (std::tanhf(arg1) < 100)) {}
+void test__std__tanhf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::tanhf(x);
 }
 
-void test__std__tanhf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::tanhf(x);
+void test__tanhl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = tanhl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__tanhl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = tanhl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__tanhl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    tanhl(arg1);
 }
 
-void test__tanhl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  tanhl(arg1);
+void test__tanhl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((tanhl(arg1) > 10) || (tanhl(arg1) < 100)) {}
 }
 
-void test__tanhl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((tanhl(arg1) > 10) || (tanhl(arg1) < 100)) {}
+void test__tanhl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = tanhl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__tanhl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = tanhl(p);
-  // cppcheck-suppress memleak
+void test__tanhl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = tanhl(x);
 }
 
-void test__tanhl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = tanhl(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::tanhl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__tanhl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::tanhl(arg1);
 }
 
-void test__std__tanhl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::tanhl(arg1);
+void test__std__tanhl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::tanhl(arg1) > 10) || (std::tanhl(arg1) < 100)) {}
 }
 
-void test__std__tanhl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::tanhl(arg1) > 10) || (std::tanhl(arg1) < 100)) {}
+void test__std__tanhl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::tanhl(x);
 }
 
-void test__std__tanhl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::tanhl(x);
+void test__ctanh__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ctanh(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ctanh__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ctanh(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ctanh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ctanh(arg1);
 }
 
-void test__ctanh__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ctanh(arg1);
+void test__ctanh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ctanh(arg1) > 10) || (ctanh(arg1) < 100)) {}
 }
 
-void test__ctanh__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ctanh(arg1) > 10) || (ctanh(arg1) < 100)) {}
+void test__ctanh__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ctanh(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ctanh__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ctanh(p);
-  // cppcheck-suppress memleak
+void test__ctanh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ctanh(x);
 }
 
-void test__ctanh__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ctanh(x);
+void test__ctanhf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ctanhf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ctanhf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ctanhf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ctanhf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ctanhf(arg1);
 }
 
-void test__ctanhf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ctanhf(arg1);
+void test__ctanhf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ctanhf(arg1) > 10) || (ctanhf(arg1) < 100)) {}
 }
 
-void test__ctanhf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ctanhf(arg1) > 10) || (ctanhf(arg1) < 100)) {}
+void test__ctanhf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ctanhf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ctanhf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ctanhf(p);
-  // cppcheck-suppress memleak
+void test__ctanhf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ctanhf(x);
 }
 
-void test__ctanhf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ctanhf(x);
+void test__ctanhl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ctanhl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ctanhl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ctanhl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ctanhl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ctanhl(arg1);
 }
 
-void test__ctanhl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ctanhl(arg1);
+void test__ctanhl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ctanhl(arg1) > 10) || (ctanhl(arg1) < 100)) {}
 }
 
-void test__ctanhl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ctanhl(arg1) > 10) || (ctanhl(arg1) < 100)) {}
+void test__ctanhl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ctanhl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ctanhl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ctanhl(p);
-  // cppcheck-suppress memleak
+void test__ctanhl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ctanhl(x);
 }
 
-void test__ctanhl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ctanhl(x);
+void test__feclearexcept__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        feclearexcept(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__feclearexcept__noreturn() {
-  int x = 1;
-  if (cond) { x=100; feclearexcept(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__feclearexcept__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((feclearexcept(arg1) > 10) || (feclearexcept(arg1) < 100)) {}
 }
 
-void test__feclearexcept__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((feclearexcept(arg1) > 10) || (feclearexcept(arg1) < 100)) {}
+void test__feclearexcept__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    feclearexcept(p);
+    // cppcheck-suppress memleak
 }
 
-void test__feclearexcept__leakignore() {
-  char *p = malloc(10); *p=0;
-  feclearexcept(p);
-  // cppcheck-suppress memleak
+void test__feclearexcept__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    feclearexcept(x);
 }
 
-void test__feclearexcept__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  feclearexcept(x);
+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__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::feclearexcept(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__feclearexcept__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::feclearexcept(arg1) > 10) || (std::feclearexcept(arg1) < 100)) {}
 }
 
-void test__std__feclearexcept__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::feclearexcept(arg1) > 10) || (std::feclearexcept(arg1) < 100)) {}
+void test__std__feclearexcept__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::feclearexcept(x);
 }
 
-void test__std__feclearexcept__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::feclearexcept(x);
+void test__fegetenv__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fegetenv(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fegetenv__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fegetenv(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fegetenv__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fegetenv(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fegetenv__leakignore() {
-  char *p = malloc(10); *p=0;
-  fegetenv(p);
-  // cppcheck-suppress memleak
+void test__fegetenv__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fegetenv(NULL);
 }
 
-void test__fegetenv__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fegetenv(p);
+void test__std__fegetenv__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::fegetenv(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fegetenv__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::fegetenv(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fegetenv__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fegetenv(NULL);
 }
 
-void test__std__fegetenv__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fegetenv(p);
+void test__fegetexceptflag__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fegetexceptflag(arg1, arg2);
+    }
+    // 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__fegetexceptflag__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fegetexceptflag(p, arg2);
+    // cppcheck-suppress memleak
 }
-
-void test__fegetexceptflag__leakignore() {
-  char *p = malloc(10); *p=0;
-  fegetexceptflag(p, arg2);
-  // cppcheck-suppress memleak
-}
-
-void test__fegetexceptflag__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fegetexceptflag(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fegetexceptflag(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  feholdexcept(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::feholdexcept(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fesetenv(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fesetenv(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fesetexceptflag(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fesetexceptflag(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  feupdateenv(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::feupdateenv(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  atexit(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::atexit(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = atoi(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::atoi(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = atol(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::atol(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = atoll(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::atoll(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = atof(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::atof(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  clearerr(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::clearerr(p);
-}
-
-void test__std__clearerr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::clearerr(x);
-}
-
-void test__clock__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = clock(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
-}
-
-void test__clock__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  clock();
-}
-
-void test__clock__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = clock();
-  // cppcheck-suppress memleak
-}
-
-void test__cbrt__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cbrt(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
-}
-
-void test__cbrt__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cbrt(arg1);
-}
-
-void test__cbrt__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cbrt(arg1) > 10) || (cbrt(arg1) < 100)) {}
-}
-
-void test__cbrt__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cbrt(p);
-  // cppcheck-suppress memleak
-}
-
-void test__cbrt__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cbrt(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__std__cbrt__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::cbrt(arg1);
-}
-
-void test__std__cbrt__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::cbrt(arg1) > 10) || (std::cbrt(arg1) < 100)) {}
-}
-
-void test__std__cbrt__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::cbrt(x);
-}
-
-void test__cbrtf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cbrtf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
-}
-
-void test__cbrtf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cbrtf(arg1);
-}
-
-void test__cbrtf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cbrtf(arg1) > 10) || (cbrtf(arg1) < 100)) {}
-}
-
-void test__cbrtf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cbrtf(p);
-  // cppcheck-suppress memleak
-}
-
-void test__cbrtf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cbrtf(x);
+
+void test__fegetexceptflag__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fegetexceptflag(NULL, arg2);
 }
 
-void test__std__cbrtf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::cbrtf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fegetexceptflag__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fegetexceptflag(arg1, x);
 }
 
-void test__std__cbrtf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::cbrtf(arg1);
+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__cbrtf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::cbrtf(arg1) > 10) || (std::cbrtf(arg1) < 100)) {}
+void test__std__fegetexceptflag__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fegetexceptflag(NULL, arg2);
 }
 
-void test__std__cbrtf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::cbrtf(x);
+void test__std__fegetexceptflag__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fegetexceptflag(arg1, x);
 }
 
-void test__cbrtl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cbrtl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fegetround__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fegetround();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cbrtl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cbrtl(arg1);
+void test__fegetround__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fegetround();
 }
 
-void test__cbrtl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cbrtl(arg1) > 10) || (cbrtl(arg1) < 100)) {}
+void test__fegetround__pure()
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fegetround() > 10) || (fegetround() < 100)) {}
 }
 
-void test__cbrtl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cbrtl(p);
-  // cppcheck-suppress memleak
+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__cbrtl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cbrtl(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__std__cbrtl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::cbrtl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
-}
+void test__feholdexcept__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        feholdexcept(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
+}
 
-void test__std__cbrtl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::cbrtl(arg1);
+void test__feholdexcept__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    feholdexcept(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__cbrtl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::cbrtl(arg1) > 10) || (std::cbrtl(arg1) < 100)) {}
+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__cbrtl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::cbrtl(x);
-}
+void test__std__feholdexcept__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::feholdexcept(NULL);
+}
 
-void test__cos__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cos(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
-}
+void test__feraiseexcept__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        feraiseexcept(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
+}
 
-void test__cos__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cos(arg1);
-}
+void test__feraiseexcept__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    feraiseexcept(p);
+    // cppcheck-suppress memleak
+}
 
-void test__cos__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cos(arg1) > 10) || (cos(arg1) < 100)) {}
+void test__feraiseexcept__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    feraiseexcept(x);
 }
 
-void test__cos__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cos(p);
-  // cppcheck-suppress memleak
+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__cos__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cos(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__std__cos__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::cos(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fesetenv__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fesetenv(NULL);
 }
 
-void test__std__cos__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::cos(arg1);
+void test__fesetenv__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fesetenv(x);
 }
 
-void test__std__cos__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::cos(arg1) > 10) || (std::cos(arg1) < 100)) {}
+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__cos__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::cos(x);
+void test__std__fesetenv__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fesetenv(x);
 }
-
-void test__cosf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cosf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+
+void test__fesetexceptflag__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fesetexceptflag(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
-
-void test__cosf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cosf(arg1);
+
+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__cosf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cosf(arg1) > 10) || (cosf(arg1) < 100)) {}
+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__cosf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cosf(p);
-  // cppcheck-suppress memleak
-}
+void test__std__fesetround__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fesetround(x);
+}
 
-void test__cosf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cosf(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__std__cosf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::cosf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__feupdateenv__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    feupdateenv(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__cosf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::cosf(arg1);
+void test__feupdateenv__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    feupdateenv(NULL);
 }
 
-void test__std__cosf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::cosf(arg1) > 10) || (std::cosf(arg1) < 100)) {}
+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__cosf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::cosf(x);
+void test__std__feupdateenv__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::feupdateenv(NULL);
 }
 
-void test__cosl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cosl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__feupdateenv__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::feupdateenv(x);
 }
 
-void test__cosl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cosl(arg1);
+void test__atan__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = atan(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cosl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cosl(arg1) > 10) || (cosl(arg1) < 100)) {}
+void test__atan__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    atan(arg1);
 }
 
-void test__cosl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cosl(p);
-  // cppcheck-suppress memleak
+void test__atan__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((atan(arg1) > 10) || (atan(arg1) < 100)) {}
 }
 
-void test__cosl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cosl(x);
+void test__atan__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = atan(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__cosl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::cosl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__atan__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = atan(x);
 }
 
-void test__std__cosl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::cosl(arg1);
+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__cosl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::cosl(arg1) > 10) || (std::cosl(arg1) < 100)) {}
+void test__std__atan__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::atan(arg1);
 }
 
-void test__std__cosl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::cosl(x);
+void test__std__atan__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::atan(arg1) > 10) || (std::atan(arg1) < 100)) {}
 }
 
-void test__ccos__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ccos(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__atan__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::atan(x);
 }
 
-void test__ccos__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ccos(arg1);
+void test__atanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = atanf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ccos__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ccos(arg1) > 10) || (ccos(arg1) < 100)) {}
+void test__atanf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    atanf(arg1);
 }
 
-void test__ccos__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ccos(p);
-  // cppcheck-suppress memleak
+void test__atanf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((atanf(arg1) > 10) || (atanf(arg1) < 100)) {}
 }
 
-void test__ccos__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ccos(x);
+void test__atanf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = atanf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ccosf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ccosf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__atanf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = atanf(x);
 }
 
-void test__ccosf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ccosf(arg1);
+void test__std__atanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::atanf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ccosf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ccosf(arg1) > 10) || (ccosf(arg1) < 100)) {}
+void test__std__atanf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::atanf(arg1);
 }
 
-void test__ccosf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ccosf(p);
-  // cppcheck-suppress memleak
+void test__std__atanf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::atanf(arg1) > 10) || (std::atanf(arg1) < 100)) {}
 }
 
-void test__ccosf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ccosf(x);
+void test__std__atanf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::atanf(x);
 }
 
-void test__ccosl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ccosl(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__ccosl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ccosl(arg1);
+void test__atanl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    atanl(arg1);
 }
 
-void test__ccosl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ccosl(arg1) > 10) || (ccosl(arg1) < 100)) {}
+void test__atanl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((atanl(arg1) > 10) || (atanl(arg1) < 100)) {}
 }
 
-void test__ccosl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ccosl(p);
-  // cppcheck-suppress memleak
+void test__atanl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = atanl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ccosl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ccosl(x);
+void test__atanl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = atanl(x);
 }
 
-void test__cosh__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cosh(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__cosh__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cosh(arg1);
+void test__std__atanl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::atanl(arg1);
 }
 
-void test__cosh__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cosh(arg1) > 10) || (cosh(arg1) < 100)) {}
+void test__std__atanl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::atanl(arg1) > 10) || (std::atanl(arg1) < 100)) {}
 }
 
-void test__cosh__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cosh(p);
-  // cppcheck-suppress memleak
+void test__std__atanl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::atanl(x);
 }
 
-void test__cosh__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cosh(x);
+void test__catan__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = catan(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__catan__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    catan(arg1);
 }
 
-void test__std__cosh__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::cosh(arg1);
+void test__catan__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((catan(arg1) > 10) || (catan(arg1) < 100)) {}
 }
 
-void test__std__cosh__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::cosh(arg1) > 10) || (std::cosh(arg1) < 100)) {}
+void test__catan__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = catan(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__cosh__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::cosh(x);
+void test__catan__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = catan(x);
 }
 
-void test__coshf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = coshf(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__coshf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  coshf(arg1);
+void test__catanf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    catanf(arg1);
 }
 
-void test__coshf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((coshf(arg1) > 10) || (coshf(arg1) < 100)) {}
+void test__catanf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((catanf(arg1) > 10) || (catanf(arg1) < 100)) {}
 }
 
-void test__coshf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = coshf(p);
-  // cppcheck-suppress memleak
+void test__catanf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = catanf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__coshf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = coshf(x);
+void test__catanf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = catanf(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__catanl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = catanl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__coshf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::coshf(arg1);
+void test__catanl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    catanl(arg1);
 }
 
-void test__std__coshf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::coshf(arg1) > 10) || (std::coshf(arg1) < 100)) {}
+void test__catanl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((catanl(arg1) > 10) || (catanl(arg1) < 100)) {}
 }
 
-void test__std__coshf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::coshf(x);
+void test__catanl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = catanl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__coshl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = coshl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__catanl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = catanl(x);
 }
 
-void test__coshl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  coshl(arg1);
+void test__tgamma__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = tgamma(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__coshl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((coshl(arg1) > 10) || (coshl(arg1) < 100)) {}
+void test__tgamma__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    tgamma(arg1);
 }
 
-void test__coshl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = coshl(p);
-  // cppcheck-suppress memleak
+void test__tgamma__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((tgamma(arg1) > 10) || (tgamma(arg1) < 100)) {}
 }
 
-void test__coshl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = coshl(x);
+void test__tgamma__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = tgamma(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__coshl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::coshl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__tgamma__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = tgamma(x);
 }
 
-void test__std__coshl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::coshl(arg1);
+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__coshl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::coshl(arg1) > 10) || (std::coshl(arg1) < 100)) {}
+void test__std__tgamma__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::tgamma(arg1);
 }
 
-void test__std__coshl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::coshl(x);
+void test__std__tgamma__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::tgamma(arg1) > 10) || (std::tgamma(arg1) < 100)) {}
 }
 
-void test__ccosh__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ccosh(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__tgamma__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::tgamma(x);
 }
 
-void test__ccosh__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ccosh(arg1);
+void test__tgammaf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = tgammaf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ccosh__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ccosh(arg1) > 10) || (ccosh(arg1) < 100)) {}
+void test__tgammaf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    tgammaf(arg1);
 }
 
-void test__ccosh__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ccosh(p);
-  // cppcheck-suppress memleak
+void test__tgammaf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((tgammaf(arg1) > 10) || (tgammaf(arg1) < 100)) {}
 }
 
-void test__ccosh__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ccosh(x);
+void test__tgammaf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = tgammaf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ccoshf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ccoshf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__tgammaf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = tgammaf(x);
 }
 
-void test__ccoshf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ccoshf(arg1);
+void test__std__tgammaf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::tgammaf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ccoshf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ccoshf(arg1) > 10) || (ccoshf(arg1) < 100)) {}
+void test__std__tgammaf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::tgammaf(arg1);
 }
 
-void test__ccoshf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ccoshf(p);
-  // cppcheck-suppress memleak
+void test__std__tgammaf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::tgammaf(arg1) > 10) || (std::tgammaf(arg1) < 100)) {}
 }
 
-void test__ccoshf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ccoshf(x);
+void test__std__tgammaf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::tgammaf(x);
 }
 
-void test__ccoshl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ccoshl(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__ccoshl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ccoshl(arg1);
+void test__tgammal__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    tgammal(arg1);
 }
 
-void test__ccoshl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ccoshl(arg1) > 10) || (ccoshl(arg1) < 100)) {}
+void test__tgammal__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((tgammal(arg1) > 10) || (tgammal(arg1) < 100)) {}
 }
 
-void test__ccoshl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ccoshl(p);
-  // cppcheck-suppress memleak
+void test__tgammal__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = tgammal(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ccoshl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ccoshl(x);
+void test__tgammal__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = tgammal(x);
 }
 
-void test__ctime__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ctime(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__ctime__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ctime(arg1);
+void test__std__tgammal__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::tgammal(arg1);
 }
 
-void test__ctime__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ctime(p);
-  // cppcheck-suppress memleak
+void test__std__tgammal__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::tgammal(arg1) > 10) || (std::tgammal(arg1) < 100)) {}
 }
 
-void test__ctime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = ctime(p);
+void test__std__tgammal__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::tgammal(x);
 }
 
-void test__ctime__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = ctime(x);
+void test__trunc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = trunc(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__ctime__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::ctime(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__trunc__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    trunc(arg1);
 }
 
-void test__std__ctime__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ctime(arg1);
+void test__trunc__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((trunc(arg1) > 10) || (trunc(arg1) < 100)) {}
 }
 
-void test__std__ctime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::ctime(p);
+void test__trunc__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = trunc(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__ctime__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::ctime(x);
+void test__trunc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = trunc(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__trunc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::trunc(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__difftime__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  difftime(arg1, arg2);
+void test__std__trunc__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::trunc(arg1);
 }
 
-void test__difftime__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = difftime(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__trunc__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::trunc(arg1) > 10) || (std::trunc(arg1) < 100)) {}
 }
 
-void test__difftime__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = difftime(x, arg2);
+void test__std__trunc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::trunc(x);
 }
 
-void test__difftime__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = difftime(arg1, x);
+void test__truncf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = truncf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__truncf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    truncf(arg1);
 }
 
-void test__std__difftime__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::difftime(arg1, arg2);
+void test__truncf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((truncf(arg1) > 10) || (truncf(arg1) < 100)) {}
 }
 
-void test__std__difftime__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::difftime(x, arg2);
+void test__truncf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = truncf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__difftime__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::difftime(arg1, x);
+void test__truncf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = truncf(x);
 }
 
-void test__div__noreturn() {
-  int x = 1;
-  if (cond) { x=100; div(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__div__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((div(arg1, arg2) > 10) || (div(arg1, arg2) < 100)) {}
+void test__std__truncf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::truncf(arg1);
 }
 
-void test__div__leakignore() {
-  char *p = malloc(10); *p=0;
-  div(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__truncf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::truncf(arg1) > 10) || (std::truncf(arg1) < 100)) {}
 }
 
-void test__div__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  div(x, arg2);
+void test__std__truncf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::truncf(x);
 }
 
-void test__div__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  div(arg1, x);
+void test__truncl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = truncl(arg1);
+    }
+    // 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__truncl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    truncl(arg1);
 }
 
-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__truncl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((truncl(arg1) > 10) || (truncl(arg1) < 100)) {}
 }
 
-void test__std__div__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::div(x, arg2);
+void test__truncl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = truncl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__div__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::div(arg1, x);
+void test__truncl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = truncl(x);
 }
 
-void test__imaxdiv__noreturn() {
-  int x = 1;
-  if (cond) { x=100; imaxdiv(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__imaxdiv__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((imaxdiv(arg1, arg2) > 10) || (imaxdiv(arg1, arg2) < 100)) {}
+void test__std__truncl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::truncl(arg1);
 }
 
-void test__imaxdiv__leakignore() {
-  char *p = malloc(10); *p=0;
-  imaxdiv(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__truncl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::truncl(arg1) > 10) || (std::truncl(arg1) < 100)) {}
 }
 
-void test__imaxdiv__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  imaxdiv(x, arg2);
+void test__std__truncl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::truncl(x);
 }
 
-void test__imaxdiv__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  imaxdiv(arg1, x);
+void test__atanh__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = atanh(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__atanh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    atanh(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__atanh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((atanh(arg1) > 10) || (atanh(arg1) < 100)) {}
 }
 
-void test__std__imaxdiv__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::imaxdiv(x, arg2);
+void test__atanh__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = atanh(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__imaxdiv__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::imaxdiv(arg1, x);
+void test__atanh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = atanh(x);
 }
 
-void test__exit__noreturn() {
-  int x = 1;
-  if (cond) { x=100; exit(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__exit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  exit(x);
+void test__std__atanh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::atanh(arg1);
 }
 
-void test__std__exit__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::exit(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__atanh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::atanh(arg1) > 10) || (std::atanh(arg1) < 100)) {}
 }
 
-void test__std__exit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::exit(x);
+void test__std__atanh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::atanh(x);
 }
 
-void test__erf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = erf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__atanhf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = atanhf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__erf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  erf(arg1);
+void test__atanhf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    atanhf(arg1);
 }
 
-void test__erf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((erf(arg1) > 10) || (erf(arg1) < 100)) {}
+void test__atanhf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((atanhf(arg1) > 10) || (atanhf(arg1) < 100)) {}
 }
 
-void test__erf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = erf(p);
-  // cppcheck-suppress memleak
+void test__atanhf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = atanhf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__erf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = erf(x);
+void test__atanhf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = atanhf(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__std__atanhf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::atanhf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__erf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::erf(arg1);
+void test__std__atanhf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::atanhf(arg1);
 }
 
-void test__std__erf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::erf(arg1) > 10) || (std::erf(arg1) < 100)) {}
+void test__std__atanhf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::atanhf(arg1) > 10) || (std::atanhf(arg1) < 100)) {}
 }
 
-void test__std__erf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::erf(x);
+void test__std__atanhf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::atanhf(x);
 }
 
-void test__erff__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = erff(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__atanhl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = atanhl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__erff__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  erff(arg1);
+void test__atanhl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    atanhl(arg1);
 }
 
-void test__erff__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((erff(arg1) > 10) || (erff(arg1) < 100)) {}
+void test__atanhl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((atanhl(arg1) > 10) || (atanhl(arg1) < 100)) {}
 }
 
-void test__erff__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = erff(p);
-  // cppcheck-suppress memleak
+void test__atanhl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = atanhl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__erff__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = erff(x);
+void test__atanhl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = atanhl(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__std__atanhl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::atanhl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__erff__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::erff(arg1);
+void test__std__atanhl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::atanhl(arg1);
 }
 
-void test__std__erff__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::erff(arg1) > 10) || (std::erff(arg1) < 100)) {}
+void test__std__atanhl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::atanhl(arg1) > 10) || (std::atanhl(arg1) < 100)) {}
 }
 
-void test__std__erff__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::erff(x);
+void test__std__atanhl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::atanhl(x);
 }
 
-void test__erfl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = erfl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__catanh__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = catanh(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__erfl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  erfl(arg1);
+void test__catanh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    catanh(arg1);
 }
 
-void test__erfl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((erfl(arg1) > 10) || (erfl(arg1) < 100)) {}
+void test__catanh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((catanh(arg1) > 10) || (catanh(arg1) < 100)) {}
 }
 
-void test__erfl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = erfl(p);
-  // cppcheck-suppress memleak
+void test__catanh__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = catanh(p);
+    // cppcheck-suppress memleak
 }
 
-void test__erfl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = erfl(x);
+void test__catanh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = catanh(x);
 }
 
-void test__std__erfl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::erfl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__catanhf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = catanhf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__erfl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::erfl(arg1);
+void test__catanhf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    catanhf(arg1);
 }
 
-void test__std__erfl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::erfl(arg1) > 10) || (std::erfl(arg1) < 100)) {}
+void test__catanhf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((catanhf(arg1) > 10) || (catanhf(arg1) < 100)) {}
 }
 
-void test__std__erfl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::erfl(x);
+void test__catanhf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = catanhf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__erfc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = erfc(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__catanhf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = catanhf(x);
 }
 
-void test__erfc__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  erfc(arg1);
+void test__catanhl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = catanhl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__erfc__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((erfc(arg1) > 10) || (erfc(arg1) < 100)) {}
+void test__catanhl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    catanhl(arg1);
 }
 
-void test__erfc__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = erfc(p);
-  // cppcheck-suppress memleak
+void test__catanhl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((catanhl(arg1) > 10) || (catanhl(arg1) < 100)) {}
 }
 
-void test__erfc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = erfc(x);
+void test__catanhl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = catanhl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__erfc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::erfc(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__catanhl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = catanhl(x);
 }
 
-void test__std__erfc__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::erfc(arg1);
+void test__atan2__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = atan2(arg1, arg2);
+    }
+    // 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__atan2__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    atan2(arg1, arg2);
 }
 
-void test__std__erfc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::erfc(x);
+void test__atan2__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((atan2(arg1, arg2) > 10) || (atan2(arg1, arg2) < 100)) {}
 }
 
-void test__erfcf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = erfcf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__atan2__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = atan2(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__erfcf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  erfcf(arg1);
+void test__atan2__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = atan2(x, arg2);
 }
 
-void test__erfcf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((erfcf(arg1) > 10) || (erfcf(arg1) < 100)) {}
+void test__atan2__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = atan2(arg1, x);
 }
 
-void test__erfcf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = erfcf(p);
-  // cppcheck-suppress memleak
+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__erfcf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = erfcf(x);
+void test__std__atan2__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::atan2(arg1, 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__std__atan2__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::atan2(arg1, arg2) > 10) || (std::atan2(arg1, arg2) < 100)) {}
 }
 
-void test__std__erfcf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::erfcf(arg1);
+void test__std__atan2__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::atan2(x, arg2);
 }
 
-void test__std__erfcf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::erfcf(arg1) > 10) || (std::erfcf(arg1) < 100)) {}
+void test__std__atan2__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::atan2(arg1, x);
 }
 
-void test__std__erfcf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::erfcf(x);
+void test__atan2f__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = atan2f(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__erfcl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = erfcl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__atan2f__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    atan2f(arg1, arg2);
 }
 
-void test__erfcl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  erfcl(arg1);
+void test__atan2f__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((atan2f(arg1, arg2) > 10) || (atan2f(arg1, arg2) < 100)) {}
 }
 
-void test__erfcl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((erfcl(arg1) > 10) || (erfcl(arg1) < 100)) {}
+void test__atan2f__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = atan2f(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__erfcl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = erfcl(p);
-  // cppcheck-suppress memleak
+void test__atan2f__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = atan2f(x, arg2);
 }
 
-void test__erfcl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = erfcl(x);
+void test__atan2f__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = atan2f(arg1, x);
 }
 
-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__atan2f__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::atan2f(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__erfcl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::erfcl(arg1);
+void test__std__atan2f__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::atan2f(arg1, arg2);
 }
 
-void test__std__erfcl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::erfcl(arg1) > 10) || (std::erfcl(arg1) < 100)) {}
+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__erfcl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::erfcl(x);
+void test__std__atan2f__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::atan2f(x, arg2);
 }
 
-void test__carg__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = carg(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__atan2f__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::atan2f(arg1, x);
 }
 
-void test__carg__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  carg(arg1);
+void test__atan2l__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = atan2l(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__carg__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((carg(arg1) > 10) || (carg(arg1) < 100)) {}
+void test__atan2l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    atan2l(arg1, arg2);
 }
 
-void test__carg__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = carg(p);
-  // cppcheck-suppress memleak
+void test__atan2l__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((atan2l(arg1, arg2) > 10) || (atan2l(arg1, arg2) < 100)) {}
 }
 
-void test__carg__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = carg(x);
+void test__atan2l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = atan2l(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__cargf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cargf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__atan2l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = atan2l(x, arg2);
 }
 
-void test__cargf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cargf(arg1);
+void test__atan2l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = atan2l(arg1, x);
 }
 
-void test__cargf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cargf(arg1) > 10) || (cargf(arg1) < 100)) {}
+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__cargf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cargf(p);
-  // cppcheck-suppress memleak
+void test__std__atan2l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::atan2l(arg1, arg2);
 }
 
-void test__cargf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cargf(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__cargl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cargl(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__cargl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cargl(arg1);
+void test__std__atan2l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::atan2l(arg1, x);
 }
 
-void test__cargl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cargl(arg1) > 10) || (cargl(arg1) < 100)) {}
+void test__atexit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        atexit(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cargl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cargl(p);
-  // cppcheck-suppress memleak
+void test__atexit__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((atexit(arg1) > 10) || (atexit(arg1) < 100)) {}
 }
 
-void test__cargl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cargl(x);
+void test__atexit__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    atexit(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__atexit__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    atexit(NULL);
 }
 
-void test__exp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  exp(arg1);
+void test__std__atexit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::atexit(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__exp__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((exp(arg1) > 10) || (exp(arg1) < 100)) {}
+void test__std__atexit__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::atexit(arg1) > 10) || (std::atexit(arg1) < 100)) {}
 }
 
-void test__exp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = exp(p);
-  // cppcheck-suppress memleak
+void test__std__atexit__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::atexit(NULL);
 }
 
-void test__exp__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = exp(x);
+void test__atoi__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = atoi(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__atoi__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    atoi(arg1);
 }
 
-void test__std__exp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::exp(arg1);
+void test__atoi__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((atoi(arg1) > 10) || (atoi(arg1) < 100)) {}
 }
 
-void test__std__exp__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::exp(arg1) > 10) || (std::exp(arg1) < 100)) {}
+void test__atoi__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = atoi(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__exp__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::exp(x);
+void test__atoi__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = atoi(NULL);
 }
 
-void test__expf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = expf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__atoi__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = atoi(x);
 }
 
-void test__expf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  expf(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__expf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((expf(arg1) > 10) || (expf(arg1) < 100)) {}
+void test__std__atoi__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::atoi(arg1);
 }
 
-void test__expf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = expf(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__expf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = expf(x);
+void test__std__atoi__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::atoi(NULL);
 }
 
-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__atoi__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::atoi(x);
 }
 
-void test__std__expf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::expf(arg1);
+void test__atol__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = atol(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__expf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::expf(arg1) > 10) || (std::expf(arg1) < 100)) {}
+void test__atol__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    atol(arg1);
 }
 
-void test__std__expf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::expf(x);
+void test__atol__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((atol(arg1) > 10) || (atol(arg1) < 100)) {}
 }
 
-void test__expl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = expl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__atol__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = atol(p);
+    // cppcheck-suppress memleak
 }
 
-void test__expl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  expl(arg1);
+void test__atol__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = atol(NULL);
 }
 
-void test__expl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((expl(arg1) > 10) || (expl(arg1) < 100)) {}
+void test__atol__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = atol(x);
 }
 
-void test__expl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = expl(p);
-  // cppcheck-suppress memleak
+void test__std__atol__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::atol(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__expl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = expl(x);
+void test__std__atol__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::atol(arg1);
 }
 
-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__atol__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::atol(arg1) > 10) || (std::atol(arg1) < 100)) {}
 }
 
-void test__std__expl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::expl(arg1);
+void test__std__atol__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::atol(NULL);
 }
 
-void test__std__expl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::expl(arg1) > 10) || (std::expl(arg1) < 100)) {}
+void test__std__atol__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::atol(x);
 }
 
-void test__std__expl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::expl(x);
+void test__atoll__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = atoll(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cexp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cexp(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__atoll__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    atoll(arg1);
 }
 
-void test__cexp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cexp(arg1);
+void test__atoll__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((atoll(arg1) > 10) || (atoll(arg1) < 100)) {}
 }
 
-void test__cexp__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cexp(arg1) > 10) || (cexp(arg1) < 100)) {}
+void test__atoll__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = atoll(p);
+    // cppcheck-suppress memleak
 }
 
-void test__cexp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cexp(p);
-  // cppcheck-suppress memleak
+void test__atoll__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = atoll(NULL);
 }
 
-void test__cexp__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cexp(x);
+void test__atoll__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = atoll(x);
 }
 
-void test__cexpf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cexpf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__cexpf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cexpf(arg1);
+void test__std__atoll__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::atoll(arg1);
 }
 
-void test__cexpf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cexpf(arg1) > 10) || (cexpf(arg1) < 100)) {}
+void test__std__atoll__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::atoll(arg1) > 10) || (std::atoll(arg1) < 100)) {}
 }
 
-void test__cexpf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cexpf(p);
-  // cppcheck-suppress memleak
+void test__std__atoll__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::atoll(NULL);
 }
 
-void test__cexpf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cexpf(x);
+void test__std__atoll__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::atoll(x);
 }
 
-void test__cexpl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cexpl(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__cexpl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cexpl(arg1);
+void test__atof__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    atof(arg1);
 }
 
-void test__cexpl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cexpl(arg1) > 10) || (cexpl(arg1) < 100)) {}
+void test__atof__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((atof(arg1) > 10) || (atof(arg1) < 100)) {}
 }
 
-void test__cexpl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cexpl(p);
-  // cppcheck-suppress memleak
+void test__atof__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = atof(p);
+    // cppcheck-suppress memleak
 }
 
-void test__cexpl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cexpl(x);
+void test__atof__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = atof(NULL);
 }
 
-void test__cimag__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cimag(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__atof__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = atof(x);
 }
 
-void test__cimag__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cimag(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__cimag__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cimag(arg1) > 10) || (cimag(arg1) < 100)) {}
+void test__std__atof__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::atof(arg1);
 }
 
-void test__cimag__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cimag(p);
-  // cppcheck-suppress memleak
+void test__std__atof__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::atof(arg1) > 10) || (std::atof(arg1) < 100)) {}
 }
 
-void test__cimag__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cimag(x);
+void test__std__atof__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::atof(NULL);
 }
 
-void test__cimagf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cimagf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__atof__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::atof(x);
 }
 
-void test__cimagf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cimagf(arg1);
+void test__calloc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = calloc(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cimagf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cimagf(arg1) > 10) || (cimagf(arg1) < 100)) {}
+void test__calloc__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    calloc(arg1, arg2);
 }
 
-void test__cimagf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cimagf(p);
-  // cppcheck-suppress memleak
+void test__calloc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = calloc(x, arg2);
 }
 
-void test__cimagf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cimagf(x);
+void test__calloc__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = calloc(arg1, x);
 }
 
-void test__cimagl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cimagl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ceil__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ceil(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cimagl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cimagl(arg1);
+void test__ceil__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ceil(arg1);
 }
 
-void test__cimagl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cimagl(arg1) > 10) || (cimagl(arg1) < 100)) {}
+void test__ceil__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ceil(arg1) > 10) || (ceil(arg1) < 100)) {}
 }
 
-void test__cimagl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cimagl(p);
-  // cppcheck-suppress memleak
+void test__ceil__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ceil(p);
+    // cppcheck-suppress memleak
 }
 
-void test__cimagl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cimagl(x);
+void test__ceil__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ceil(x);
 }
 
-void test__exp2__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = exp2(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__exp2__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  exp2(arg1);
+void test__std__ceil__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::ceil(arg1);
 }
 
-void test__exp2__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((exp2(arg1) > 10) || (exp2(arg1) < 100)) {}
+void test__std__ceil__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::ceil(arg1) > 10) || (std::ceil(arg1) < 100)) {}
 }
 
-void test__exp2__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = exp2(p);
-  // cppcheck-suppress memleak
+void test__std__ceil__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::ceil(x);
 }
 
-void test__exp2__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = exp2(x);
+void test__ceilf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ceilf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__exp2__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::exp2(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ceilf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ceilf(arg1);
 }
 
-void test__std__exp2__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::exp2(arg1);
+void test__ceilf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ceilf(arg1) > 10) || (ceilf(arg1) < 100)) {}
 }
 
-void test__std__exp2__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::exp2(arg1) > 10) || (std::exp2(arg1) < 100)) {}
+void test__ceilf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ceilf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__exp2__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::exp2(x);
+void test__ceilf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ceilf(x);
 }
 
-void test__exp2f__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = exp2f(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__exp2f__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  exp2f(arg1);
+void test__std__ceilf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::ceilf(arg1);
 }
 
-void test__exp2f__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((exp2f(arg1) > 10) || (exp2f(arg1) < 100)) {}
+void test__std__ceilf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::ceilf(arg1) > 10) || (std::ceilf(arg1) < 100)) {}
 }
 
-void test__exp2f__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = exp2f(p);
-  // cppcheck-suppress memleak
+void test__std__ceilf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::ceilf(x);
 }
 
-void test__exp2f__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = exp2f(x);
+void test__ceill__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ceill(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__ceill__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ceill(arg1);
 }
 
-void test__std__exp2f__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::exp2f(arg1);
+void test__ceill__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ceill(arg1) > 10) || (ceill(arg1) < 100)) {}
 }
 
-void test__std__exp2f__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::exp2f(arg1) > 10) || (std::exp2f(arg1) < 100)) {}
+void test__ceill__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ceill(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__exp2f__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::exp2f(x);
+void test__ceill__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ceill(x);
 }
 
-void test__exp2l__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = exp2l(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__exp2l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  exp2l(arg1);
+void test__std__ceill__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::ceill(arg1);
 }
 
-void test__exp2l__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((exp2l(arg1) > 10) || (exp2l(arg1) < 100)) {}
+void test__std__ceill__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::ceill(arg1) > 10) || (std::ceill(arg1) < 100)) {}
 }
 
-void test__exp2l__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = exp2l(p);
-  // cppcheck-suppress memleak
+void test__std__ceill__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::ceill(x);
 }
 
-void test__exp2l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = exp2l(x);
+void test__copysign__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = copysign(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__exp2l__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::exp2l(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__copysign__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    copysign(arg1, arg2);
 }
 
-void test__std__exp2l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::exp2l(arg1);
+void test__copysign__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((copysign(arg1, arg2) > 10) || (copysign(arg1, arg2) < 100)) {}
 }
 
-void test__std__exp2l__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::exp2l(arg1) > 10) || (std::exp2l(arg1) < 100)) {}
+void test__copysign__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = copysign(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__exp2l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::exp2l(x);
+void test__copysign__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = copysign(x, arg2);
 }
 
-void test__expm1__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = expm1(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__copysign__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = copysign(arg1, x);
 }
 
-void test__expm1__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  expm1(arg1);
+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__expm1__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((expm1(arg1) > 10) || (expm1(arg1) < 100)) {}
+void test__std__copysign__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::copysign(arg1, arg2);
 }
 
-void test__expm1__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = expm1(p);
-  // cppcheck-suppress memleak
+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__expm1__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = expm1(x);
+void test__std__copysign__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::copysign(x, arg2);
 }
 
-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__copysign__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::copysign(arg1, x);
 }
 
-void test__std__expm1__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::expm1(arg1);
+void test__copysignf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = copysignf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__expm1__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::expm1(arg1) > 10) || (std::expm1(arg1) < 100)) {}
+void test__copysignf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    copysignf(arg1, arg2);
 }
 
-void test__std__expm1__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::expm1(x);
+void test__copysignf__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((copysignf(arg1, arg2) > 10) || (copysignf(arg1, arg2) < 100)) {}
 }
 
-void test__expm1f__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = expm1f(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__copysignf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = copysignf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__expm1f__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  expm1f(arg1);
+void test__copysignf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = copysignf(x, arg2);
 }
 
-void test__expm1f__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((expm1f(arg1) > 10) || (expm1f(arg1) < 100)) {}
+void test__copysignf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = copysignf(arg1, x);
 }
 
-void test__expm1f__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = expm1f(p);
-  // cppcheck-suppress memleak
+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__expm1f__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = expm1f(x);
+void test__std__copysignf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::copysignf(arg1, arg2);
 }
 
-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__copysignf__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::copysignf(arg1, arg2) > 10) || (std::copysignf(arg1, arg2) < 100)) {}
 }
 
-void test__std__expm1f__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::expm1f(arg1);
+void test__std__copysignf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::copysignf(x, arg2);
 }
 
-void test__std__expm1f__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::expm1f(arg1) > 10) || (std::expm1f(arg1) < 100)) {}
+void test__std__copysignf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::copysignf(arg1, x);
 }
 
-void test__std__expm1f__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::expm1f(x);
+void test__copysignl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = copysignl(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__expm1l__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = expm1l(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__copysignl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    copysignl(arg1, arg2);
 }
 
-void test__expm1l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  expm1l(arg1);
+void test__copysignl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((copysignl(arg1, arg2) > 10) || (copysignl(arg1, arg2) < 100)) {}
 }
 
-void test__expm1l__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((expm1l(arg1) > 10) || (expm1l(arg1) < 100)) {}
+void test__copysignl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = copysignl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__expm1l__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = expm1l(p);
-  // cppcheck-suppress memleak
+void test__copysignl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = copysignl(x, arg2);
 }
 
-void test__expm1l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = expm1l(x);
+void test__copysignl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = copysignl(arg1, x);
 }
 
-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__copysignl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::copysignl(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__expm1l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::expm1l(arg1);
+void test__std__copysignl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::copysignl(arg1, arg2);
 }
 
-void test__std__expm1l__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::expm1l(arg1) > 10) || (std::expm1l(arg1) < 100)) {}
+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__expm1l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::expm1l(x);
+void test__std__copysignl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::copysignl(x, arg2);
 }
 
-void test___Exit__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _Exit(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__copysignl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::copysignl(arg1, x);
 }
 
-void test___Exit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _Exit(x);
+void test__clearerr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        clearerr(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__clearerr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    clearerr(p);
+    // cppcheck-suppress memleak
 }
 
-void test__quick_exit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  quick_exit(x);
+void test__clearerr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    clearerr(NULL);
 }
 
-void test__fabs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fabs(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__clearerr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    clearerr(x);
 }
 
-void test__fabs__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fabs(arg1);
+void test__std__clearerr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::clearerr(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fabs__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((fabs(arg1) > 10) || (fabs(arg1) < 100)) {}
+void test__std__clearerr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::clearerr(NULL);
 }
 
-void test__fabs__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fabs(p);
-  // cppcheck-suppress memleak
+void test__std__clearerr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::clearerr(x);
 }
 
-void test__fabs__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fabs(x);
+void test__clock__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = clock();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fabs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::fabs(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__clock__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    clock();
 }
 
-void test__std__fabs__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fabs(arg1);
+void test__clock__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = clock();
+    // cppcheck-suppress memleak
 }
 
-void test__std__fabs__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::fabs(arg1) > 10) || (std::fabs(arg1) < 100)) {}
+void test__cbrt__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cbrt(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fabs__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fabs(x);
+void test__cbrt__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cbrt(arg1);
 }
 
-void test__fabsf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fabsf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cbrt__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cbrt(arg1) > 10) || (cbrt(arg1) < 100)) {}
 }
 
-void test__fabsf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fabsf(arg1);
+void test__cbrt__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cbrt(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fabsf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((fabsf(arg1) > 10) || (fabsf(arg1) < 100)) {}
+void test__cbrt__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cbrt(x);
 }
 
-void test__fabsf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fabsf(p);
-  // cppcheck-suppress memleak
+void test__std__cbrt__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::cbrt(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fabsf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fabsf(x);
+void test__std__cbrt__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::cbrt(arg1);
 }
 
-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__cbrt__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::cbrt(arg1) > 10) || (std::cbrt(arg1) < 100)) {}
 }
 
-void test__std__fabsf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fabsf(arg1);
+void test__std__cbrt__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::cbrt(x);
 }
 
-void test__std__fabsf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::fabsf(arg1) > 10) || (std::fabsf(arg1) < 100)) {}
+void test__cbrtf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cbrtf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fabsf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fabsf(x);
+void test__cbrtf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cbrtf(arg1);
 }
 
-void test__fabsl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fabsl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cbrtf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cbrtf(arg1) > 10) || (cbrtf(arg1) < 100)) {}
 }
 
-void test__fabsl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fabsl(arg1);
+void test__cbrtf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cbrtf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fabsl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((fabsl(arg1) > 10) || (fabsl(arg1) < 100)) {}
+void test__cbrtf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cbrtf(x);
 }
 
-void test__fabsl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fabsl(p);
-  // cppcheck-suppress memleak
+void test__std__cbrtf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::cbrtf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fabsl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fabsl(x);
+void test__std__cbrtf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::cbrtf(arg1);
 }
 
-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__cbrtf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::cbrtf(arg1) > 10) || (std::cbrtf(arg1) < 100)) {}
 }
 
-void test__std__fabsl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fabsl(arg1);
+void test__std__cbrtf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::cbrtf(x);
 }
 
-void test__std__fabsl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::fabsl(arg1) > 10) || (std::fabsl(arg1) < 100)) {}
+void test__cbrtl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cbrtl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fabsl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fabsl(x);
+void test__cbrtl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cbrtl(arg1);
 }
 
-void test__fdim__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fdim(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cbrtl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cbrtl(arg1) > 10) || (cbrtl(arg1) < 100)) {}
 }
 
-void test__fdim__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fdim(arg1, arg2);
+void test__cbrtl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cbrtl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fdim__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((fdim(arg1, arg2) > 10) || (fdim(arg1, arg2) < 100)) {}
+void test__cbrtl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cbrtl(x);
 }
 
-void test__fdim__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fdim(p, arg2);
-  // 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__fdim__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fdim(x, arg2);
+void test__std__cbrtl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::cbrtl(arg1);
 }
 
-void test__fdim__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fdim(arg1, x);
+void test__std__cbrtl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::cbrtl(arg1) > 10) || (std::cbrtl(arg1) < 100)) {}
 }
 
-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__cbrtl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::cbrtl(x);
 }
 
-void test__std__fdim__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fdim(arg1, arg2);
+void test__cos__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cos(arg1);
+    }
+    // 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__cos__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cos(arg1);
 }
 
-void test__std__fdim__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fdim(x, arg2);
+void test__cos__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cos(arg1) > 10) || (cos(arg1) < 100)) {}
 }
 
-void test__std__fdim__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fdim(arg1, x);
+void test__cos__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cos(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fdimf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fdimf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cos__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cos(x);
 }
 
-void test__fdimf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fdimf(arg1, arg2);
+void test__std__cos__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::cos(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fdimf__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((fdimf(arg1, arg2) > 10) || (fdimf(arg1, arg2) < 100)) {}
+void test__std__cos__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::cos(arg1);
 }
 
-void test__fdimf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fdimf(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__cos__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::cos(arg1) > 10) || (std::cos(arg1) < 100)) {}
 }
 
-void test__fdimf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fdimf(x, arg2);
+void test__std__cos__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::cos(x);
 }
 
-void test__fdimf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fdimf(arg1, x);
+void test__cosf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cosf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__cosf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cosf(arg1);
 }
 
-void test__std__fdimf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fdimf(arg1, arg2);
+void test__cosf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cosf(arg1) > 10) || (cosf(arg1) < 100)) {}
 }
 
-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__cosf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cosf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__fdimf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fdimf(x, arg2);
+void test__cosf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cosf(x);
 }
 
-void test__std__fdimf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fdimf(arg1, 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__fdiml__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fdiml(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__cosf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::cosf(arg1);
 }
 
-void test__fdiml__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fdiml(arg1, arg2);
+void test__std__cosf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::cosf(arg1) > 10) || (std::cosf(arg1) < 100)) {}
 }
 
-void test__fdiml__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((fdiml(arg1, arg2) > 10) || (fdiml(arg1, arg2) < 100)) {}
+void test__std__cosf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::cosf(x);
 }
 
-void test__fdiml__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fdiml(p, arg2);
-  // cppcheck-suppress memleak
+void test__cosl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cosl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fdiml__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fdiml(x, arg2);
+void test__cosl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cosl(arg1);
 }
 
-void test__fdiml__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fdiml(arg1, x);
+void test__cosl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cosl(arg1) > 10) || (cosl(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__cosl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cosl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__fdiml__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fdiml(arg1, arg2);
+void test__cosl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cosl(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__std__cosl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::cosl(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__std__cosl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::cosl(arg1);
 }
 
-void test__std__fdiml__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fdiml(arg1, x);
+void test__std__cosl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::cosl(arg1) > 10) || (std::cosl(arg1) < 100)) {}
 }
 
-void test__fclose__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fclose(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__cosl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::cosl(x);
 }
 
-void test__fclose__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fclose(p);
+void test__ccos__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ccos(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fclose__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fclose(x);
+void test__ccos__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ccos(arg1);
 }
 
-void test__std__fclose__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::fclose(arg1); }
-  // 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__fclose__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fclose(p);
+void test__ccos__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ccos(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__fclose__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fclose(x);
+void test__ccos__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ccos(x);
 }
 
-void test__feof__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = feof(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ccosf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ccosf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__feof__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  feof(arg1);
+void test__ccosf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ccosf(arg1);
 }
 
-void test__feof__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = feof(p);
-  // cppcheck-suppress memleak
+void test__ccosf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ccosf(arg1) > 10) || (ccosf(arg1) < 100)) {}
 }
 
-void test__feof__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = feof(p);
+void test__ccosf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ccosf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__feof__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = feof(x);
+void test__ccosf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ccosf(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__ccosl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ccosl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__feof__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::feof(arg1);
+void test__ccosl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ccosl(arg1);
 }
 
-void test__std__feof__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::feof(p);
+void test__ccosl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ccosl(arg1) > 10) || (ccosl(arg1) < 100)) {}
 }
 
-void test__std__feof__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::feof(x);
+void test__ccosl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ccosl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ferror__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ferror(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ccosl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ccosl(x);
 }
 
-void test__ferror__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ferror(arg1);
+void test__cosh__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cosh(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ferror__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ferror(p);
-  // cppcheck-suppress memleak
+void test__cosh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cosh(arg1);
 }
 
-void test__ferror__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = ferror(p);
+void test__cosh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cosh(arg1) > 10) || (cosh(arg1) < 100)) {}
 }
 
-void test__ferror__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = ferror(x);
+void test__cosh__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cosh(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__ferror__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::ferror(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cosh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cosh(x);
 }
 
-void test__std__ferror__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ferror(arg1);
+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__ferror__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::ferror(p);
+void test__std__cosh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::cosh(arg1);
 }
 
-void test__std__ferror__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::ferror(x);
+void test__std__cosh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::cosh(arg1) > 10) || (std::cosh(arg1) < 100)) {}
 }
 
-void test__fflush__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fflush(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__cosh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::cosh(x);
 }
 
-void test__fflush__leakignore() {
-  char *p = malloc(10); *p=0;
-  fflush(p);
-  // cppcheck-suppress memleak
+void test__coshf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = coshf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fflush__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fflush(x);
+void test__coshf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    coshf(arg1);
 }
 
-void test__std__fflush__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::fflush(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__coshf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((coshf(arg1) > 10) || (coshf(arg1) < 100)) {}
 }
 
-void test__std__fflush__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fflush(x);
+void test__coshf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = coshf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fgetc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fgetc(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__coshf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = coshf(x);
 }
 
-void test__fgetc__leakignore() {
-  char *p = malloc(10); *p=0;
-  fgetc(p);
-  // cppcheck-suppress memleak
+void test__std__coshf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::coshf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fgetc__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fgetc(p);
+void test__std__coshf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::coshf(arg1);
 }
 
-void test__fgetc__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fgetc(x);
+void test__std__coshf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::coshf(arg1) > 10) || (std::coshf(arg1) < 100)) {}
 }
 
-void test__std__fgetc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::fgetc(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__coshf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::coshf(x);
 }
 
-void test__std__fgetc__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fgetc(p);
+void test__coshl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = coshl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fgetc__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fgetc(x);
+void test__coshl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    coshl(arg1);
 }
 
-void test__getc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; getc(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__coshl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((coshl(arg1) > 10) || (coshl(arg1) < 100)) {}
 }
 
-void test__getc__leakignore() {
-  char *p = malloc(10); *p=0;
-  getc(p);
-  // cppcheck-suppress memleak
+void test__coshl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = coshl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__getc__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getc(p);
+void test__coshl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = coshl(x);
 }
 
-void test__getc__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  getc(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__getc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::getc(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__coshl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::coshl(arg1);
 }
 
-void test__std__getc__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::getc(p);
+void test__std__coshl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::coshl(arg1) > 10) || (std::coshl(arg1) < 100)) {}
 }
 
-void test__std__getc__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::getc(x);
+void test__std__coshl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::coshl(x);
 }
 
-void test__fgetwc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fgetwc(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__fgetwc__leakignore() {
-  char *p = malloc(10); *p=0;
-  fgetwc(p);
-  // cppcheck-suppress memleak
+void test__ccosh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ccosh(arg1);
 }
 
-void test__fgetwc__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fgetwc(p);
+void test__ccosh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ccosh(arg1) > 10) || (ccosh(arg1) < 100)) {}
 }
 
-void test__fgetwc__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fgetwc(x);
+void test__ccosh__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ccosh(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__fgetwc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::fgetwc(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ccosh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ccosh(x);
 }
 
-void test__std__fgetwc__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fgetwc(p);
+void test__ccoshf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ccoshf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fgetwc__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fgetwc(x);
+void test__ccoshf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ccoshf(arg1);
 }
 
-void test__getwc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; getwc(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ccoshf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ccoshf(arg1) > 10) || (ccoshf(arg1) < 100)) {}
 }
 
-void test__getwc__leakignore() {
-  char *p = malloc(10); *p=0;
-  getwc(p);
-  // cppcheck-suppress memleak
+void test__ccoshf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ccoshf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__getwc__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getwc(p);
+void test__ccoshf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ccoshf(x);
 }
 
-void test__getwc__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  getwc(x);
+void test__ccoshl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ccoshl(arg1);
+    }
+    // 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__ccoshl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ccoshl(arg1);
 }
 
-void test__std__getwc__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::getwc(p);
+void test__ccoshl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ccoshl(arg1) > 10) || (ccoshl(arg1) < 100)) {}
 }
 
-void test__std__getwc__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::getwc(x);
+void test__ccoshl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ccoshl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fgetpos__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fgetpos(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ccoshl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ccoshl(x);
 }
 
-void test__fgetpos__leakignore() {
-  char *p = malloc(10); *p=0;
-  fgetpos(p, arg2);
-  // cppcheck-suppress memleak
+void test__ctime__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ctime(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fgetpos__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fgetpos(p, arg2);
+void test__ctime__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ctime(arg1);
 }
 
-void test__fgetpos__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fgetpos(x, arg2);
+void test__ctime__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ctime(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fgetpos__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fgetpos(arg1, p);
+void test__ctime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = ctime(NULL);
 }
 
-void test__std__fgetpos__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::fgetpos(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ctime__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = ctime(x);
 }
 
-void test__std__fgetpos__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fgetpos(p, arg2);
+void test__std__ctime__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::ctime(arg1);
+    }
+    // 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__ctime__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::ctime(arg1);
 }
 
-void test__std__fgetpos__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fgetpos(arg1, p);
+void test__std__ctime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::ctime(NULL);
 }
 
-void test__floor__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = floor(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__floor__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  floor(arg1);
+void test__difftime__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = difftime(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__floor__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((floor(arg1) > 10) || (floor(arg1) < 100)) {}
+void test__difftime__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    difftime(arg1, arg2);
 }
 
-void test__floor__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = floor(p);
-  // cppcheck-suppress memleak
+void test__difftime__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = difftime(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__floor__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = floor(x);
+void test__difftime__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = difftime(x, 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__difftime__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = difftime(arg1, x);
 }
 
-void test__std__floor__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::floor(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__std__floor__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::floor(arg1) > 10) || (std::floor(arg1) < 100)) {}
+void test__std__difftime__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::difftime(arg1, arg2);
 }
 
-void test__std__floor__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::floor(x);
+void test__std__difftime__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::difftime(x, arg2);
 }
 
-void test__floorf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = floorf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__difftime__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::difftime(arg1, x);
 }
 
-void test__floorf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  floorf(arg1);
+void test__div__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        div(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__floorf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((floorf(arg1) > 10) || (floorf(arg1) < 100)) {}
+void test__div__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((div(arg1, arg2) > 10) || (div(arg1, arg2) < 100)) {}
 }
 
-void test__floorf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = floorf(p);
-  // cppcheck-suppress memleak
+void test__div__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    div(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__floorf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = floorf(x);
+void test__div__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    div(x, arg2);
 }
 
-void test__std__floorf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::floorf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__div__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    div(arg1, x);
 }
 
-void test__std__floorf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::floorf(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__std__floorf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::floorf(arg1) > 10) || (std::floorf(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__std__floorf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::floorf(x);
+void test__std__div__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::div(x, arg2);
 }
 
-void test__floorl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = floorl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__div__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::div(arg1, x);
 }
 
-void test__floorl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  floorl(arg1);
+void test__imaxdiv__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        imaxdiv(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__floorl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((floorl(arg1) > 10) || (floorl(arg1) < 100)) {}
+void test__imaxdiv__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((imaxdiv(arg1, arg2) > 10) || (imaxdiv(arg1, arg2) < 100)) {}
 }
 
-void test__floorl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = floorl(p);
-  // cppcheck-suppress memleak
+void test__imaxdiv__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    imaxdiv(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__floorl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = floorl(x);
+void test__imaxdiv__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    imaxdiv(x, arg2);
 }
 
-void test__std__floorl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::floorl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__imaxdiv__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    imaxdiv(arg1, x);
 }
 
-void test__std__floorl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::floorl(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__std__floorl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::floorl(arg1) > 10) || (std::floorl(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__std__floorl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::floorl(x);
+void test__std__imaxdiv__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::imaxdiv(x, arg2);
 }
 
-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__imaxdiv__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::imaxdiv(arg1, x);
 }
 
-void test__fma__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fma(arg1, arg2, arg3);
+void test__exit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        exit(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__exit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    exit(x);
 }
 
-void test__fma__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fma(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__exit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::exit(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fma__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fma(x, arg2, arg3);
+void test__std__exit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::exit(x);
 }
 
-void test__fma__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fma(arg1, x, arg3);
+void test__erf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = erf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fma__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fma(arg1, arg2, x);
+void test__erf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    erf(arg1);
 }
 
-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__erf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((erf(arg1) > 10) || (erf(arg1) < 100)) {}
 }
 
-void test__std__fma__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fma(arg1, arg2, arg3);
+void test__erf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = erf(p);
+    // cppcheck-suppress memleak
 }
 
-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__erf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = erf(x);
 }
 
-void test__std__fma__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fma(x, arg2, arg3);
+void test__std__erf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::erf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fma__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fma(arg1, x, arg3);
+void test__std__erf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::erf(arg1);
 }
 
-void test__std__fma__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fma(arg1, arg2, x);
+void test__std__erf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::erf(arg1) > 10) || (std::erf(arg1) < 100)) {}
 }
 
-void test__fmaf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fmaf(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__erf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::erf(x);
 }
 
-void test__fmaf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fmaf(arg1, arg2, arg3);
+void test__erff__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = erff(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__erff__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    erff(arg1);
 }
 
-void test__fmaf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fmaf(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__erff__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((erff(arg1) > 10) || (erff(arg1) < 100)) {}
 }
 
-void test__fmaf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmaf(x, arg2, arg3);
+void test__erff__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = erff(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fmaf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmaf(arg1, x, arg3);
+void test__erff__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = erff(x);
 }
 
-void test__fmaf__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmaf(arg1, arg2, 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__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__erff__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::erff(arg1);
 }
 
-void test__std__fmaf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fmaf(arg1, arg2, arg3);
+void test__std__erff__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::erff(arg1) > 10) || (std::erff(arg1) < 100)) {}
 }
 
-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__std__erff__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::erff(x);
 }
 
-void test__std__fmaf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmaf(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__std__fmaf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmaf(arg1, x, arg3);
+void test__erfl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    erfl(arg1);
 }
 
-void test__std__fmaf__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmaf(arg1, arg2, x);
+void test__erfl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((erfl(arg1) > 10) || (erfl(arg1) < 100)) {}
 }
 
-void test__fmal__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fmal(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__fmal__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fmal(arg1, arg2, arg3);
+void test__erfl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = erfl(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__erfl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::erfl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fmal__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fmal(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__erfl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::erfl(arg1);
 }
 
-void test__fmal__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmal(x, arg2, arg3);
+void test__std__erfl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::erfl(arg1) > 10) || (std::erfl(arg1) < 100)) {}
 }
 
-void test__fmal__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmal(arg1, x, arg3);
+void test__std__erfl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::erfl(x);
 }
 
-void test__fmal__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmal(arg1, arg2, x);
+void test__erfc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = erfc(arg1);
+    }
+    // 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__erfc__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    erfc(arg1);
 }
 
-void test__std__fmal__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fmal(arg1, arg2, arg3);
+void test__erfc__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((erfc(arg1) > 10) || (erfc(arg1) < 100)) {}
 }
 
-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__erfc__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = erfc(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__fmal__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmal(x, arg2, arg3);
+void test__erfc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = erfc(x);
 }
 
-void test__std__fmal__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmal(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__std__fmal__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmal(arg1, arg2, x);
+void test__std__erfc__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::erfc(arg1);
 }
 
-void test__fmax__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fmax(arg1, arg2); }
-  // 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__fmax__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fmax(arg1, arg2);
+void test__std__erfc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::erfc(x);
 }
 
-void test__fmax__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((fmax(arg1, arg2) > 10) || (fmax(arg1, arg2) < 100)) {}
+void test__erfcf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = erfcf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fmax__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fmax(p, arg2);
-  // cppcheck-suppress memleak
+void test__erfcf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    erfcf(arg1);
 }
 
-void test__fmax__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmax(x, arg2);
+void test__erfcf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((erfcf(arg1) > 10) || (erfcf(arg1) < 100)) {}
 }
 
-void test__fmax__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmax(arg1, x);
+void test__erfcf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = erfcf(p);
+    // 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__erfcf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = erfcf(x);
 }
 
-void test__std__fmax__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fmax(arg1, 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__std__fmax__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::fmax(arg1, arg2) > 10) || (std::fmax(arg1, arg2) < 100)) {}
+void test__std__erfcf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::erfcf(arg1);
 }
 
-void test__std__fmax__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmax(x, arg2);
+void test__std__erfcf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::erfcf(arg1) > 10) || (std::erfcf(arg1) < 100)) {}
 }
 
-void test__std__fmax__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmax(arg1, x);
+void test__std__erfcf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::erfcf(x);
 }
 
-void test__fmaxf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fmaxf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__erfcl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = erfcl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fmaxf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fmaxf(arg1, arg2);
+void test__erfcl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    erfcl(arg1);
 }
 
-void test__fmaxf__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((fmaxf(arg1, arg2) > 10) || (fmaxf(arg1, arg2) < 100)) {}
+void test__erfcl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((erfcl(arg1) > 10) || (erfcl(arg1) < 100)) {}
 }
 
-void test__fmaxf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fmaxf(p, arg2);
-  // cppcheck-suppress memleak
+void test__erfcl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = erfcl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fmaxf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmaxf(x, arg2);
+void test__erfcl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = erfcl(x);
 }
 
-void test__fmaxf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmaxf(arg1, x);
+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__fmaxf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::fmaxf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__erfcl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::erfcl(arg1);
 }
 
-void test__std__fmaxf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fmaxf(arg1, arg2);
+void test__std__erfcl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::erfcl(arg1) > 10) || (std::erfcl(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__std__erfcl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::erfcl(x);
 }
 
-void test__std__fmaxf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmaxf(x, arg2);
+void test__carg__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = carg(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fmaxf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmaxf(arg1, x);
+void test__carg__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    carg(arg1);
 }
 
-void test__fmaxl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fmaxl(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__carg__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((carg(arg1) > 10) || (carg(arg1) < 100)) {}
 }
 
-void test__fmaxl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fmaxl(arg1, arg2);
+void test__carg__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = carg(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fmaxl__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((fmaxl(arg1, arg2) > 10) || (fmaxl(arg1, arg2) < 100)) {}
+void test__carg__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = carg(x);
 }
 
-void test__fmaxl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fmaxl(p, arg2);
-  // cppcheck-suppress memleak
+void test__cargf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cargf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fmaxl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmaxl(x, arg2);
+void test__cargf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cargf(arg1);
 }
 
-void test__fmaxl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmaxl(arg1, x);
+void test__cargf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cargf(arg1) > 10) || (cargf(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__cargf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cargf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__fmaxl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fmaxl(arg1, arg2);
+void test__cargf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cargf(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__cargl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cargl(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__cargl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cargl(arg1);
 }
 
-void test__std__fmaxl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmaxl(arg1, x);
+void test__cargl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cargl(arg1) > 10) || (cargl(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__cargl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cargl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fmin__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fmin(arg1, arg2);
+void test__cargl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cargl(x);
 }
 
-void test__fmin__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((fmin(arg1, arg2) > 10) || (fmin(arg1, arg2) < 100)) {}
+void test__exp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = exp(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__exp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    exp(arg1);
 }
 
-void test__fmin__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmin(x, arg2);
+void test__exp__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((exp(arg1) > 10) || (exp(arg1) < 100)) {}
 }
 
-void test__fmin__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmin(arg1, x);
+void test__exp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = exp(p);
+    // cppcheck-suppress memleak
 }
 
-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__exp__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = exp(x);
 }
 
-void test__std__fmin__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fmin(arg1, arg2);
+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__fmin__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::fmin(arg1, arg2) > 10) || (std::fmin(arg1, arg2) < 100)) {}
+void test__std__exp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::exp(arg1);
 }
 
-void test__std__fmin__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmin(x, arg2);
+void test__std__exp__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::exp(arg1) > 10) || (std::exp(arg1) < 100)) {}
 }
 
-void test__std__fmin__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmin(arg1, x);
+void test__std__exp__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::exp(x);
 }
 
-void test__fminf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fminf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__expf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = expf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fminf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fminf(arg1, arg2);
+void test__expf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    expf(arg1);
 }
 
-void test__fminf__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((fminf(arg1, arg2) > 10) || (fminf(arg1, arg2) < 100)) {}
+void test__expf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((expf(arg1) > 10) || (expf(arg1) < 100)) {}
 }
 
-void test__fminf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fminf(p, arg2);
-  // cppcheck-suppress memleak
+void test__expf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = expf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fminf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fminf(x, arg2);
+void test__expf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = expf(x);
 }
 
-void test__fminf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fminf(arg1, 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__fminf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::fminf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__expf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::expf(arg1);
 }
 
-void test__std__fminf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fminf(arg1, arg2);
+void test__std__expf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::expf(arg1) > 10) || (std::expf(arg1) < 100)) {}
 }
 
-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__std__expf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::expf(x);
 }
 
-void test__std__fminf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fminf(x, arg2);
+void test__expl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = expl(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__expl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    expl(arg1);
 }
 
-void test__fminl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fminl(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__expl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((expl(arg1) > 10) || (expl(arg1) < 100)) {}
 }
 
-void test__fminl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fminl(arg1, arg2);
+void test__expl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = expl(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__expl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = expl(x);
 }
 
-void test__fminl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fminl(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__expl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::expl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fminl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fminl(x, arg2);
+void test__std__expl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::expl(arg1);
 }
 
-void test__fminl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fminl(arg1, x);
+void test__std__expl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::expl(arg1) > 10) || (std::expl(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__std__expl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::expl(x);
 }
 
-void test__std__fminl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fminl(arg1, arg2);
+void test__cexp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cexp(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__cexp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cexp(arg1);
 }
 
-void test__std__fminl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fminl(x, arg2);
+void test__cexp__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cexp(arg1) > 10) || (cexp(arg1) < 100)) {}
 }
 
-void test__std__fminl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fminl(arg1, x);
+void test__cexp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cexp(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fmod__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fmod(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cexp__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cexp(x);
 }
 
-void test__fmod__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fmod(arg1, arg2);
+void test__cexpf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cexpf(arg1);
+    }
+    // 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__cexpf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cexpf(arg1);
 }
 
-void test__fmod__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fmod(p, arg2);
-  // cppcheck-suppress memleak
+void test__cexpf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cexpf(arg1) > 10) || (cexpf(arg1) < 100)) {}
 }
 
-void test__fmod__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmod(x, arg2);
+void test__cexpf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cexpf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fmod__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmod(arg1, x);
+void test__cexpf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cexpf(x);
 }
 
-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__cexpl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cexpl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fmod__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fmod(arg1, arg2);
+void test__cexpl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cexpl(arg1);
 }
 
-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__cexpl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cexpl(arg1) > 10) || (cexpl(arg1) < 100)) {}
 }
 
-void test__std__fmod__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmod(x, arg2);
+void test__cexpl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cexpl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__fmod__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmod(arg1, x);
+void test__cexpl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cexpl(x);
 }
 
-void test__fmodf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fmodf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cimag__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cimag(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fmodf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fmodf(arg1, arg2);
+void test__cimag__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cimag(arg1);
 }
 
-void test__fmodf__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((fmodf(arg1, arg2) > 10) || (fmodf(arg1, arg2) < 100)) {}
+void test__cimag__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cimag(arg1) > 10) || (cimag(arg1) < 100)) {}
 }
 
-void test__fmodf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fmodf(p, arg2);
-  // cppcheck-suppress memleak
+void test__cimag__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cimag(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fmodf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmodf(x, arg2);
+void test__cimag__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cimag(x);
 }
 
-void test__fmodf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmodf(arg1, x);
+void test__cimagf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cimagf(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__cimagf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cimagf(arg1);
 }
 
-void test__std__fmodf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fmodf(arg1, arg2);
+void test__cimagf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cimagf(arg1) > 10) || (cimagf(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__cimagf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cimagf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__fmodf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmodf(x, arg2);
+void test__cimagf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cimagf(x);
 }
 
-void test__std__fmodf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmodf(arg1, x);
+void test__cimagl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cimagl(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__cimagl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cimagl(arg1);
 }
 
-void test__fmodl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fmodl(arg1, arg2);
+void test__cimagl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cimagl(arg1) > 10) || (cimagl(arg1) < 100)) {}
 }
 
-void test__fmodl__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((fmodl(arg1, arg2) > 10) || (fmodl(arg1, arg2) < 100)) {}
+void test__cimagl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cimagl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fmodl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fmodl(p, arg2);
-  // cppcheck-suppress memleak
+void test__cimagl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cimagl(x);
 }
 
-void test__fmodl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmodl(x, arg2);
+void test__exp2__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = exp2(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fmodl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fmodl(arg1, x);
+void test__exp2__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    exp2(arg1);
 }
 
-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__exp2__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((exp2(arg1) > 10) || (exp2(arg1) < 100)) {}
 }
 
-void test__std__fmodl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fmodl(arg1, arg2);
+void test__exp2__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = exp2(p);
+    // cppcheck-suppress memleak
 }
 
-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__exp2__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = exp2(x);
 }
 
-void test__std__fmodl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmodl(x, 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__std__fmodl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fmodl(arg1, x);
+void test__std__exp2__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::exp2(arg1);
 }
 
-void test__fopen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fopen(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__exp2__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::exp2(arg1) > 10) || (std::exp2(arg1) < 100)) {}
 }
 
-void test__fopen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fopen(arg1, arg2);
+void test__std__exp2__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::exp2(x);
 }
 
-void test__fopen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = fopen(p, arg2);
+void test__exp2f__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = exp2f(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fopen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = fopen(x, arg2);
+void test__exp2f__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    exp2f(arg1);
 }
 
-void test__fopen__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = fopen(arg1, p);
+void test__exp2f__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((exp2f(arg1) > 10) || (exp2f(arg1) < 100)) {}
 }
 
-void test__fopen__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = fopen(arg1, x);
+void test__exp2f__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = exp2f(p);
+    // cppcheck-suppress memleak
 }
 
-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__exp2f__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = exp2f(x);
 }
 
-void test__std__fopen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fopen(arg1, arg2);
+void test__std__exp2f__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::exp2f(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fopen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::fopen(p, arg2);
+void test__std__exp2f__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::exp2f(arg1);
 }
 
-void test__std__fopen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::fopen(x, arg2);
+void test__std__exp2f__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::exp2f(arg1) > 10) || (std::exp2f(arg1) < 100)) {}
 }
 
-void test__std__fopen__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::fopen(arg1, p);
+void test__std__exp2f__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::exp2f(x);
 }
 
-void test__std__fopen__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::fopen(arg1, x);
+void test__exp2l__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = exp2l(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__exp2l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    exp2l(arg1);
 }
 
-void test__fopen_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fopen_s(p, arg2, arg3);
+void test__exp2l__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((exp2l(arg1) > 10) || (exp2l(arg1) < 100)) {}
 }
 
-void test__fopen_s__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fopen_s(arg1, p, arg3);
+void test__exp2l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = exp2l(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fopen_s__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fopen_s(arg1, x, arg3);
+void test__exp2l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = exp2l(x);
 }
 
-void test__fopen_s__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fopen_s(arg1, arg2, p);
+void test__std__exp2l__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::exp2l(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fopen_s__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fopen_s(arg1, arg2, x);
+void test__std__exp2l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::exp2l(arg1);
 }
 
-void test__fprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fprintf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__exp2l__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::exp2l(arg1) > 10) || (std::exp2l(arg1) < 100)) {}
 }
 
-void test__fprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  fprintf(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__exp2l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::exp2l(x);
 }
 
-void test__fprintf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fprintf(p, arg2);
+void test__expm1__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = expm1(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fprintf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fprintf(x, arg2);
+void test__expm1__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    expm1(arg1);
 }
 
-void test__fprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fprintf(arg1, x);
+void test__expm1__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((expm1(arg1) > 10) || (expm1(arg1) < 100)) {}
 }
 
-void test__std__fprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::fprintf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__expm1__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = expm1(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__fprintf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fprintf(p, arg2);
+void test__expm1__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = expm1(x);
 }
 
-void test__std__fprintf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fprintf(x, arg2);
+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__fprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fprintf(arg1, x);
+void test__std__expm1__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::expm1(arg1);
 }
 
-void test__vfprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; vfprintf(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__expm1__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::expm1(arg1) > 10) || (std::expm1(arg1) < 100)) {}
 }
 
-void test__vfprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  vfprintf(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__expm1__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::expm1(x);
 }
 
-void test__vfprintf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vfprintf(p, arg2, arg3);
+void test__expm1f__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = expm1f(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__vfprintf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  vfprintf(x, arg2, arg3);
+void test__expm1f__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    expm1f(arg1);
 }
 
-void test__vfprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  vfprintf(arg1, x, arg3);
+void test__expm1f__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((expm1f(arg1) > 10) || (expm1f(arg1) < 100)) {}
 }
 
-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__expm1f__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = expm1f(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__vfprintf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::vfprintf(p, arg2, arg3);
+void test__expm1f__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = expm1f(x);
 }
 
-void test__std__vfprintf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::vfprintf(x, arg2, 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__std__vfprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::vfprintf(arg1, x, arg3);
+void test__std__expm1f__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::expm1f(arg1);
 }
 
-void test__vfwprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; vfwprintf(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__expm1f__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::expm1f(arg1) > 10) || (std::expm1f(arg1) < 100)) {}
 }
 
-void test__vfwprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  vfwprintf(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__expm1f__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::expm1f(x);
 }
 
-void test__vfwprintf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vfwprintf(p, arg2, arg3);
+void test__expm1l__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = expm1l(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__vfwprintf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  vfwprintf(x, arg2, arg3);
+void test__expm1l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    expm1l(arg1);
 }
 
-void test__vfwprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  vfwprintf(arg1, x, arg3);
+void test__expm1l__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((expm1l(arg1) > 10) || (expm1l(arg1) < 100)) {}
 }
 
-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__expm1l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = expm1l(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__vfwprintf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::vfwprintf(p, arg2, arg3);
+void test__expm1l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = expm1l(x);
 }
 
-void test__std__vfwprintf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::vfwprintf(x, arg2, arg3);
+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__vfwprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::vfwprintf(arg1, x, arg3);
+void test__std__expm1l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::expm1l(arg1);
 }
 
-void test__fputc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fputc(arg1, arg2); }
-  // 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__fputc__leakignore() {
-  char *p = malloc(10); *p=0;
-  fputc(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__expm1l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::expm1l(x);
 }
 
-void test__fputc__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  fputc(!x, arg2);
+void test___Exit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _Exit(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fputc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fputc(x, arg2);
+void test___Exit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _Exit(x);
 }
 
-void test__fputc__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fputc(arg1, p);
+void test__quick_exit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        quick_exit(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fputc__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fputc(arg1, x);
+void test__quick_exit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    quick_exit(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__fabs__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fabs(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fputc__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::fputc(!x, arg2);
+void test__fabs__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fabs(arg1);
 }
 
-void test__std__fputc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fputc(x, arg2);
+void test__fabs__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fabs(arg1) > 10) || (fabs(arg1) < 100)) {}
 }
 
-void test__std__fputc__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fputc(arg1, p);
+void test__fabs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fabs(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__fputc__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fputc(arg1, x);
+void test__fabs__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fabs(x);
 }
 
-void test__fputwc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fputwc(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fabs__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::fabs(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fputwc__leakignore() {
-  char *p = malloc(10); *p=0;
-  fputwc(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__fabs__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fabs(arg1);
 }
 
-void test__fputwc__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  fputwc(!x, arg2);
+void test__std__fabs__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::fabs(arg1) > 10) || (std::fabs(arg1) < 100)) {}
 }
 
-void test__fputwc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fputwc(x, arg2);
+void test__std__fabs__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fabs(x);
 }
 
-void test__fputwc__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fputwc(arg1, p);
+void test__fabsf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fabsf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fputwc__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fputwc(arg1, x);
+void test__fabsf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fabsf(arg1);
 }
 
-void test__std__fputwc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::fputwc(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fabsf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fabsf(arg1) > 10) || (fabsf(arg1) < 100)) {}
 }
 
-void test__std__fputwc__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::fputwc(!x, arg2);
+void test__fabsf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fabsf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__fputwc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fputwc(x, arg2);
+void test__fabsf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fabsf(x);
 }
 
-void test__std__fputwc__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fputwc(arg1, p);
+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__fputwc__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fputwc(arg1, x);
+void test__std__fabsf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fabsf(arg1);
 }
 
-void test__fputs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fputs(arg1, arg2); }
-  // 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__fputs__leakignore() {
-  char *p = malloc(10); *p=0;
-  fputs(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__fabsf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fabsf(x);
 }
 
-void test__fputs__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fputs(p, arg2);
+void test__fabsl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fabsl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fputs__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fputs(x, arg2);
+void test__fabsl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fabsl(arg1);
 }
 
-void test__fputs__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fputs(arg1, p);
+void test__fabsl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fabsl(arg1) > 10) || (fabsl(arg1) < 100)) {}
 }
 
-void test__fputs__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fputs(arg1, x);
+void test__fabsl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fabsl(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__fabsl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fabsl(x);
 }
 
-void test__std__fputs__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fputs(p, arg2);
+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__fputs__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fputs(x, arg2);
+void test__std__fabsl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fabsl(arg1);
 }
 
-void test__std__fputs__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fputs(arg1, p);
+void test__std__fabsl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::fabsl(arg1) > 10) || (std::fabsl(arg1) < 100)) {}
 }
 
-void test__std__fputs__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fputs(arg1, x);
+void test__std__fabsl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fabsl(x);
 }
 
-void test__fputws__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fputws(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fdim__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fdim(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fputws__leakignore() {
-  char *p = malloc(10); *p=0;
-  fputws(p, arg2);
-  // cppcheck-suppress memleak
+void test__fdim__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fdim(arg1, arg2);
 }
 
-void test__fputws__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fputws(p, arg2);
+void test__fdim__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fdim(arg1, arg2) > 10) || (fdim(arg1, arg2) < 100)) {}
 }
 
-void test__fputws__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fputws(x, arg2);
+void test__fdim__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fdim(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__fputws__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fputws(arg1, p);
+void test__fdim__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fdim(x, arg2);
 }
 
-void test__fputws__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fputws(arg1, x);
+void test__fdim__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fdim(arg1, x);
 }
 
-void test__std__fputws__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::fputws(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__std__fputws__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fputws(p, arg2);
+void test__std__fdim__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fdim(arg1, arg2);
 }
 
-void test__std__fputws__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fputws(x, arg2);
+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__std__fputws__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fputws(arg1, p);
+void test__std__fdim__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fdim(x, arg2);
 }
 
-void test__std__fputws__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fputws(arg1, x);
+void test__std__fdim__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fdim(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__fdimf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fdimf(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__fdimf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fdimf(arg1, arg2);
 }
 
-void test__fread__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fread(p, arg2, arg3, arg4);
+void test__fdimf__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fdimf(arg1, arg2) > 10) || (fdimf(arg1, arg2) < 100)) {}
 }
 
-void test__fread__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fread(arg1, x, arg3, arg4);
+void test__fdimf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fdimf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__fread__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fread(arg1, arg2, x, arg4);
+void test__fdimf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fdimf(x, arg2);
 }
 
-void test__fread__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fread(arg1, arg2, arg3, p);
+void test__fdimf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fdimf(arg1, x);
 }
 
-void test__fread__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fread(arg1, arg2, arg3, x);
+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__fread__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::fread(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fdimf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fdimf(arg1, arg2);
 }
 
-void test__std__fread__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fread(p, arg2, arg3, arg4);
+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__std__fread__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fread(arg1, x, arg3, arg4);
+void test__std__fdimf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fdimf(x, arg2);
 }
 
-void test__std__fread__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fread(arg1, arg2, x, arg4);
+void test__std__fdimf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fdimf(arg1, x);
 }
 
-void test__std__fread__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fread(arg1, arg2, arg3, p);
+void test__fdiml__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fdiml(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fread__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fread(arg1, arg2, arg3, x);
+void test__fdiml__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fdiml(arg1, arg2);
 }
 
-void test__free__noreturn() {
-  int x = 1;
-  if (cond) { x=100; free(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fdiml__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fdiml(arg1, arg2) > 10) || (fdiml(arg1, arg2) < 100)) {}
 }
 
-void test__free__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  free(x);
+void test__fdiml__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fdiml(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__free__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::free(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fdiml__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fdiml(x, arg2);
 }
 
-void test__std__free__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::free(x);
+void test__fdiml__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fdiml(arg1, x);
 }
 
-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__fdiml__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::fdiml(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__freopen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  freopen(arg1, arg2, arg3);
+void test__std__fdiml__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fdiml(arg1, arg2);
 }
 
-void test__freopen__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = freopen(x, arg2, arg3);
+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__freopen__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = freopen(arg1, p, arg3);
+void test__std__fdiml__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fdiml(x, arg2);
 }
 
-void test__freopen__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = freopen(arg1, x, arg3);
+void test__std__fdiml__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fdiml(arg1, x);
 }
 
-void test__freopen__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = freopen(arg1, arg2, p);
+void test__fclose__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fclose(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__freopen__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = freopen(arg1, arg2, x);
+void test__fclose__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fclose(NULL);
 }
 
-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__fclose__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fclose(x);
 }
 
-void test__std__freopen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::freopen(arg1, arg2, arg3);
+void test__std__fclose__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::fclose(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__freopen__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::freopen(x, arg2, arg3);
+void test__std__fclose__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fclose(NULL);
 }
 
-void test__std__freopen__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::freopen(arg1, p, arg3);
+void test__std__fclose__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fclose(x);
 }
 
-void test__std__freopen__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::freopen(arg1, x, arg3);
+void test__feof__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = feof(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__freopen__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::freopen(arg1, arg2, p);
+void test__feof__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    feof(arg1);
 }
 
-void test__std__freopen__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::freopen(arg1, arg2, x);
+void test__feof__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = feof(p);
+    // cppcheck-suppress memleak
 }
 
-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__feof__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = feof(NULL);
 }
 
-void test__freopen_s__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  freopen_s(arg1, arg2, arg3, arg4);
+void test__feof__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = feof(x);
 }
 
-void test__freopen_s__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = freopen_s(x, arg2, arg3, arg4);
+void test__std__feof__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::feof(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__std__feof__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::feof(arg1);
 }
 
-void test__freopen_s__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = freopen_s(arg1, arg2, p, arg4);
+void test__std__feof__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::feof(NULL);
 }
 
-void test__freopen_s__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = freopen_s(arg1, arg2, x, arg4);
+void test__std__feof__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::feof(x);
 }
 
-void test__freopen_s__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = freopen_s(arg1, arg2, arg3, p);
+void test__ferror__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ferror(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__freopen_s__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = freopen_s(arg1, arg2, arg3, x);
+void test__ferror__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ferror(arg1);
 }
 
-void test__frexp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; frexp(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ferror__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ferror(p);
+    // cppcheck-suppress memleak
 }
 
-void test__frexp__leakignore() {
-  char *p = malloc(10); *p=0;
-  frexp(p, arg2);
-  // cppcheck-suppress memleak
+void test__ferror__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = ferror(NULL);
 }
 
-void test__frexp__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  frexp(x, arg2);
+void test__ferror__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = ferror(x);
 }
 
-void test__frexp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  frexp(arg1, p);
+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__frexp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::frexp(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__ferror__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::ferror(arg1);
 }
 
-void test__std__frexp__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::frexp(x, arg2);
+void test__std__ferror__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::ferror(NULL);
 }
 
-void test__std__frexp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::frexp(arg1, p);
+void test__std__ferror__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::ferror(x);
 }
 
-void test__frexpf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; frexpf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fflush__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fflush(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__fflush__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fflush(p);
+    // cppcheck-suppress memleak
 }
 
-void test__frexpf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  frexpf(x, arg2);
+void test__fflush__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fflush(x);
 }
 
-void test__frexpf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  frexpf(arg1, p);
+void test__std__fflush__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::fflush(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__fflush__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fflush(x);
 }
 
-void test__std__frexpf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::frexpf(x, arg2);
+void test__fgetc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fgetc(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__frexpf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::frexpf(arg1, p);
+void test__fgetc__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fgetc(p);
+    // cppcheck-suppress memleak
 }
-
-void test__frexpl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; frexpl(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+
+void test__fgetc__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fgetc(NULL);
 }
 
-void test__frexpl__leakignore() {
-  char *p = malloc(10); *p=0;
-  frexpl(p, arg2);
-  // cppcheck-suppress memleak
+void test__fgetc__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fgetc(x);
 }
 
-void test__frexpl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  frexpl(x, arg2);
+void test__std__fgetc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::fgetc(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__frexpl__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  frexpl(arg1, p);
+void test__std__fgetc__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fgetc(NULL);
 }
-
-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__fgetc__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fgetc(x);
 }
-
-void test__std__frexpl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::frexpl(x, arg2);
+
+void test__getc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        getc(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__frexpl__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::frexpl(arg1, p);
+void test__getc__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    getc(p);
+    // cppcheck-suppress memleak
 }
-
-void test__hypot__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = hypot(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+
+void test__getc__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getc(NULL);
 }
 
-void test__hypot__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  hypot(arg1, arg2, arg3);
+void test__getc__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    getc(x);
 }
 
-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__std__getc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::getc(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__hypot__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = hypot(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__getc__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::getc(NULL);
 }
 
-void test__hypot__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = hypot(x, arg2, arg3);
+void test__std__getc__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::getc(x);
 }
 
-void test__hypot__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = hypot(arg1, x, arg3);
+void test__fgetwc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fgetwc(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__hypot__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = hypot(arg1, arg2, x);
+void test__fgetwc__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fgetwc(p);
+    // cppcheck-suppress memleak
 }
 
-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__fgetwc__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fgetwc(NULL);
 }
 
-void test__std__hypot__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::hypot(arg1, arg2, arg3);
+void test__fgetwc__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fgetwc(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__std__fgetwc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::fgetwc(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__std__fgetwc__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fgetwc(NULL);
 }
 
-void test__std__hypot__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::hypot(arg1, x, arg3);
+void test__std__fgetwc__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fgetwc(x);
 }
 
-void test__std__hypot__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::hypot(arg1, arg2, x);
+void test__getwc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        getwc(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__hypotf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = hypotf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getwc__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    getwc(p);
+    // cppcheck-suppress memleak
 }
 
-void test__hypotf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  hypotf(arg1, arg2);
+void test__getwc__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getwc(NULL);
 }
 
-void test__hypotf__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((hypotf(arg1, arg2) > 10) || (hypotf(arg1, arg2) < 100)) {}
+void test__getwc__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    getwc(x);
 }
 
-void test__hypotf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = hypotf(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__getwc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::getwc(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__hypotf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = hypotf(x, arg2);
+void test__std__getwc__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::getwc(NULL);
 }
 
-void test__hypotf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = hypotf(arg1, x);
+void test__std__getwc__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::getwc(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__fgetpos__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fgetpos(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__hypotf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::hypotf(arg1, arg2);
+void test__fgetpos__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fgetpos(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__fgetpos__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fgetpos(NULL, arg2);
 }
 
-void test__std__hypotf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::hypotf(x, arg2);
+void test__fgetpos__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fgetpos(x, arg2);
 }
 
-void test__std__hypotf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::hypotf(arg1, x);
+void test__fgetpos__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fgetpos(arg1, NULL);
 }
 
-void test__hypotl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = hypotl(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__hypotl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  hypotl(arg1, arg2);
+void test__std__fgetpos__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fgetpos(NULL, arg2);
 }
 
-void test__hypotl__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((hypotl(arg1, arg2) > 10) || (hypotl(arg1, arg2) < 100)) {}
+void test__std__fgetpos__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fgetpos(x, arg2);
 }
 
-void test__hypotl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = hypotl(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__fgetpos__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fgetpos(arg1, NULL);
 }
 
-void test__hypotl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = hypotl(x, arg2);
+void test__floor__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = floor(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__hypotl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = hypotl(arg1, x);
+void test__floor__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    floor(arg1);
 }
 
-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__floor__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((floor(arg1) > 10) || (floor(arg1) < 100)) {}
 }
 
-void test__std__hypotl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::hypotl(arg1, arg2);
+void test__floor__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = floor(p);
+    // cppcheck-suppress memleak
 }
 
-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__floor__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = floor(x);
 }
 
-void test__std__hypotl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::hypotl(x, 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__std__hypotl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::hypotl(arg1, x);
+void test__std__floor__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::floor(arg1);
 }
 
-void test__fscanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fscanf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__floor__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::floor(arg1) > 10) || (std::floor(arg1) < 100)) {}
 }
 
-void test__fscanf__leakignore() {
-  char *p = malloc(10); *p=0;
-  fscanf(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__floor__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::floor(x);
 }
 
-void test__fscanf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fscanf(x, arg2);
+void test__floorf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = floorf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fscanf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fscanf(arg1, x);
+void test__floorf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    floorf(arg1);
 }
 
-void test__std__fscanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::fscanf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__floorf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((floorf(arg1) > 10) || (floorf(arg1) < 100)) {}
 }
 
-void test__std__fscanf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fscanf(x, arg2);
+void test__floorf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = floorf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__fscanf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fscanf(arg1, x);
+void test__floorf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = floorf(x);
 }
 
-void test__vfscanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; vfscanf(arg1, arg2, arg3); }
-  // 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__vfscanf__leakignore() {
-  char *p = malloc(10); *p=0;
-  vfscanf(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__floorf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::floorf(arg1);
 }
 
-void test__vfscanf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  vfscanf(x, arg2, arg3);
+void test__std__floorf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::floorf(arg1) > 10) || (std::floorf(arg1) < 100)) {}
 }
 
-void test__vfscanf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  vfscanf(arg1, x, arg3);
+void test__std__floorf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::floorf(x);
 }
 
-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__floorl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = floorl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__vfscanf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::vfscanf(x, arg2, arg3);
+void test__floorl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    floorl(arg1);
 }
 
-void test__std__vfscanf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::vfscanf(arg1, x, arg3);
+void test__floorl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((floorl(arg1) > 10) || (floorl(arg1) < 100)) {}
 }
 
-void test__vfwscanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; vfwscanf(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__floorl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = floorl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__vfwscanf__leakignore() {
-  char *p = malloc(10); *p=0;
-  vfwscanf(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__floorl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = floorl(x);
 }
 
-void test__vfwscanf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  vfwscanf(x, arg2, arg3);
+void test__std__floorl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::floorl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__vfwscanf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vfwscanf(arg1, p, arg3);
+void test__std__floorl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::floorl(arg1);
 }
 
-void test__vfwscanf__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  vfwscanf(arg1, x, arg3);
+void test__std__floorl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::floorl(arg1) > 10) || (std::floorl(arg1) < 100)) {}
 }
 
-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__floorl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::floorl(x);
 }
 
-void test__std__vfwscanf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::vfwscanf(x, arg2, arg3);
+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__vfwscanf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::vfwscanf(arg1, p, arg3);
+void test__fma__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fma(arg1, arg2, arg3);
 }
 
-void test__std__vfwscanf__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::vfwscanf(arg1, x, arg3);
+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__fseek__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fseek(arg1, arg2, arg3); }
-  // 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__fseek__leakignore() {
-  char *p = malloc(10); *p=0;
-  fseek(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__fma__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fma(x, arg2, arg3);
 }
 
-void test__fseek__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fseek(p, arg2, arg3);
+void test__fma__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fma(arg1, x, arg3);
 }
 
-void test__fseek__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fseek(x, arg2, arg3);
+void test__fma__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fma(arg1, arg2, x);
 }
 
-void test__fseek__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fseek(arg1, x, arg3);
+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__fseek__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fseek(arg1, arg2, x);
+void test__std__fma__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fma(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__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__fseek__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fseek(p, arg2, arg3);
+void test__std__fma__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fma(x, arg2, arg3);
 }
 
-void test__std__fseek__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fseek(x, arg2, arg3);
+void test__std__fma__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fma(arg1, x, arg3);
 }
 
-void test__std__fseek__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fseek(arg1, x, arg3);
+void test__std__fma__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fma(arg1, arg2, x);
 }
 
-void test__std__fseek__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fseek(arg1, arg2, 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__fsetpos__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fsetpos(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fmaf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fmaf(arg1, arg2, arg3);
 }
 
-void test__fsetpos__leakignore() {
-  char *p = malloc(10); *p=0;
-  fsetpos(p, arg2);
-  // cppcheck-suppress memleak
+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__fsetpos__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fsetpos(p, arg2);
+void test__fmaf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fmaf(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__fsetpos__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fsetpos(x, arg2);
+void test__fmaf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmaf(x, arg2, arg3);
 }
 
-void test__fsetpos__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fsetpos(arg1, p);
+void test__fmaf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmaf(arg1, x, arg3);
 }
 
-void test__fsetpos__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fsetpos(arg1, x);
+void test__fmaf__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmaf(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__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__fsetpos__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fsetpos(p, arg2);
+void test__std__fmaf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fmaf(arg1, arg2, arg3);
 }
 
-void test__std__fsetpos__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fsetpos(x, arg2);
+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__std__fsetpos__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fsetpos(arg1, p);
+void test__std__fmaf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmaf(x, arg2, arg3);
 }
 
-void test__std__fsetpos__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fsetpos(arg1, x);
+void test__std__fmaf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmaf(arg1, x, arg3);
 }
 
-void test__fgets__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fgets(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fmaf__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmaf(arg1, arg2, x);
 }
 
-void test__fgets__leakignore() {
-  char *p = malloc(10); *p=0;
-  fgets(p, arg2, arg3);
-  // 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__fgets__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fgets(p, arg2, arg3);
+void test__fmal__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fmal(arg1, arg2, arg3);
 }
 
-void test__fgets__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  fgets(arg1, !x, arg3);
+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__fgets__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fgets(arg1, x, arg3);
+void test__fmal__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fmal(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__fgets__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fgets(arg1, arg2, p);
+void test__fmal__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmal(x, arg2, arg3);
 }
 
-void test__fgets__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fgets(arg1, arg2, x);
+void test__fmal__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmal(arg1, x, arg3);
 }
 
-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__fmal__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmal(arg1, arg2, x);
 }
 
-void test__std__fgets__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fgets(p, arg2, arg3);
+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__std__fgets__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::fgets(arg1, !x, arg3);
+void test__std__fmal__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fmal(arg1, arg2, arg3);
 }
 
-void test__std__fgets__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fgets(arg1, x, arg3);
+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__std__fgets__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fgets(arg1, arg2, p);
+void test__std__fmal__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmal(x, arg2, arg3);
 }
 
-void test__std__fgets__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fgets(arg1, arg2, x);
+void test__std__fmal__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmal(arg1, x, arg3);
 }
 
-void test__fgetws__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fgetws(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fmal__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmal(arg1, arg2, x);
 }
 
-void test__fgetws__leakignore() {
-  char *p = malloc(10); *p=0;
-  fgetws(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__fmax__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fmax(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fgetws__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fgetws(p, arg2, arg3);
+void test__fmax__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fmax(arg1, arg2);
 }
 
-void test__fgetws__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  fgetws(arg1, !x, arg3);
+void test__fmax__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fmax(arg1, arg2) > 10) || (fmax(arg1, arg2) < 100)) {}
 }
 
-void test__fgetws__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fgetws(arg1, x, arg3);
+void test__fmax__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fmax(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__fgetws__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fgetws(arg1, arg2, p);
+void test__fmax__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmax(x, arg2);
 }
 
-void test__fgetws__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fgetws(arg1, arg2, x);
+void test__fmax__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmax(arg1, x);
 }
 
-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__fmax__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::fmax(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fgetws__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fgetws(p, arg2, arg3);
+void test__std__fmax__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fmax(arg1, arg2);
 }
 
-void test__std__fgetws__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::fgetws(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__std__fgetws__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fgetws(arg1, x, arg3);
+void test__std__fmax__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmax(x, arg2);
 }
 
-void test__std__fgetws__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fgetws(arg1, arg2, p);
+void test__std__fmax__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmax(arg1, x);
 }
 
-void test__std__fgetws__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fgetws(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__ftell__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ftell(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fmaxf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fmaxf(arg1, arg2);
 }
 
-void test__ftell__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ftell(arg1);
+void test__fmaxf__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fmaxf(arg1, arg2) > 10) || (fmaxf(arg1, arg2) < 100)) {}
 }
 
-void test__ftell__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ftell(p);
-  // cppcheck-suppress memleak
+void test__fmaxf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fmaxf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__ftell__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = ftell(p);
+void test__fmaxf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmaxf(x, arg2);
 }
 
-void test__ftell__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = ftell(x);
+void test__fmaxf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmaxf(arg1, 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__std__fmaxf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::fmaxf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__ftell__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ftell(arg1);
+void test__std__fmaxf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fmaxf(arg1, arg2);
 }
 
-void test__std__ftell__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::ftell(p);
+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__std__ftell__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::ftell(x);
+void test__std__fmaxf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmaxf(x, arg2);
 }
 
-void test__fwide__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fwide(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fmaxf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmaxf(arg1, x);
 }
 
-void test__fwide__leakignore() {
-  char *p = malloc(10); *p=0;
-  fwide(p, arg2);
-  // cppcheck-suppress memleak
+void test__fmaxl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fmaxl(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fwide__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fwide(p, arg2);
+void test__fmaxl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fmaxl(arg1, arg2);
 }
 
-void test__fwide__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fwide(x, arg2);
+void test__fmaxl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fmaxl(arg1, arg2) > 10) || (fmaxl(arg1, arg2) < 100)) {}
 }
 
-void test__fwide__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fwide(arg1, x);
+void test__fmaxl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fmaxl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__fwide__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::fwide(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fmaxl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmaxl(x, arg2);
 }
 
-void test__std__fwide__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fwide(p, arg2);
+void test__fmaxl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmaxl(arg1, x);
 }
 
-void test__std__fwide__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fwide(x, arg2);
+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__fwide__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fwide(arg1, x);
+void test__std__fmaxl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fmaxl(arg1, 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__std__fmaxl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::fmaxl(arg1, arg2) > 10) || (std::fmaxl(arg1, arg2) < 100)) {}
 }
 
-void test__fwrite__leakignore() {
-  char *p = malloc(10); *p=0;
-  fwrite(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__std__fmaxl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmaxl(x, arg2);
 }
 
-void test__fwrite__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fwrite(p, arg2, arg3, arg4);
+void test__std__fmaxl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmaxl(arg1, x);
 }
 
-void test__fwrite__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fwrite(x, arg2, arg3, arg4);
+void test__fmin__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fmin(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fwrite__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fwrite(arg1, x, arg3, arg4);
+void test__fmin__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fmin(arg1, arg2);
 }
 
-void test__fwrite__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fwrite(arg1, arg2, x, arg4);
+void test__fmin__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fmin(arg1, arg2) > 10) || (fmin(arg1, arg2) < 100)) {}
 }
 
-void test__fwrite__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fwrite(arg1, arg2, arg3, p);
+void test__fmin__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fmin(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__fwrite__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fwrite(arg1, arg2, arg3, x);
+void test__fmin__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmin(x, 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__fmin__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmin(arg1, x);
 }
 
-void test__std__fwrite__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fwrite(p, arg2, arg3, arg4);
+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__fwrite__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fwrite(x, arg2, arg3, arg4);
+void test__std__fmin__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fmin(arg1, arg2);
 }
 
-void test__std__fwrite__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fwrite(arg1, x, arg3, arg4);
+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__fwrite__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fwrite(arg1, arg2, x, arg4);
+void test__std__fmin__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmin(x, arg2);
 }
 
-void test__std__fwrite__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fwrite(arg1, arg2, arg3, p);
+void test__std__fmin__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmin(arg1, x);
 }
 
-void test__std__fwrite__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fwrite(arg1, arg2, arg3, x);
+void test__fminf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fminf(arg1, arg2);
+    }
+    // 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__fminf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fminf(arg1, arg2);
 }
 
-void test__mblen__leakignore() {
-  char *p = malloc(10); *p=0;
-  mblen(p, arg2);
-  // cppcheck-suppress memleak
+void test__fminf__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fminf(arg1, arg2) > 10) || (fminf(arg1, arg2) < 100)) {}
 }
 
-void test__mblen__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mblen(x, arg2);
+void test__fminf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fminf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__mblen__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mblen(arg1, x);
+void test__fminf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fminf(x, 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__fminf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fminf(arg1, x);
 }
 
-void test__std__mblen__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::mblen(x, arg2);
+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__std__mblen__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::mblen(arg1, x);
+void test__std__fminf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fminf(arg1, arg2);
 }
 
-void test__mbtowc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; mbtowc(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+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__mbtowc__leakignore() {
-  char *p = malloc(10); *p=0;
-  mbtowc(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__fminf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fminf(x, arg2);
 }
 
-void test__mbtowc__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mbtowc(arg1, x, arg3);
+void test__std__fminf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fminf(arg1, x);
 }
 
-void test__mbtowc__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mbtowc(arg1, arg2, x);
+void test__fminl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fminl(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__fminl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fminl(arg1, arg2);
 }
 
-void test__std__mbtowc__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::mbtowc(arg1, x, arg3);
+void test__fminl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fminl(arg1, arg2) > 10) || (fminl(arg1, arg2) < 100)) {}
 }
 
-void test__std__mbtowc__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::mbtowc(arg1, arg2, x);
+void test__fminl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fminl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__mbrlen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; mbrlen(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fminl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fminl(x, arg2);
 }
 
-void test__mbrlen__leakignore() {
-  char *p = malloc(10); *p=0;
-  mbrlen(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__fminl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fminl(arg1, x);
 }
 
-void test__mbrlen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mbrlen(p, arg2, arg3);
+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__mbrlen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  mbrlen(x, arg2, arg3);
+void test__std__fminl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fminl(arg1, arg2);
 }
 
-void test__mbrlen__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mbrlen(arg1, x, arg3);
+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__mbrlen__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mbrlen(arg1, arg2, x);
+void test__std__fminl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fminl(x, arg2);
 }
 
-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__fminl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fminl(arg1, x);
 }
 
-void test__std__mbrlen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::mbrlen(p, arg2, arg3);
+void test__fmod__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fmod(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__mbrlen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::mbrlen(x, arg2, arg3);
+void test__fmod__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fmod(arg1, arg2);
 }
 
-void test__std__mbrlen__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::mbrlen(arg1, x, arg3);
+void test__fmod__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fmod(arg1, arg2) > 10) || (fmod(arg1, arg2) < 100)) {}
 }
 
-void test__std__mbrlen__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::mbrlen(arg1, arg2, x);
+void test__fmod__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fmod(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__btowc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = btowc(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fmod__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmod(x, arg2);
 }
 
-void test__btowc__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  btowc(arg1);
+void test__fmod__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmod(arg1, x);
 }
 
-void test__btowc__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((btowc(arg1) > 10) || (btowc(arg1) < 100)) {}
+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__btowc__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = btowc(p);
-  // cppcheck-suppress memleak
+void test__std__fmod__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fmod(arg1, arg2);
 }
 
-void test__btowc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = btowc(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__btowc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::btowc(arg1); }
-  // 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__btowc__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::btowc(arg1);
+void test__std__fmod__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmod(arg1, x);
 }
 
-void test__std__btowc__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::btowc(arg1) > 10) || (std::btowc(arg1) < 100)) {}
+void test__fmodf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fmodf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__btowc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::btowc(x);
+void test__fmodf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fmodf(arg1, arg2);
 }
 
-void test__mbsinit__noreturn() {
-  int x = 1;
-  if (cond) { x=100; mbsinit(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__mbsinit__leakignore() {
-  char *p = malloc(10); *p=0;
-  mbsinit(p);
-  // cppcheck-suppress memleak
+void test__fmodf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fmodf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__mbsinit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mbsinit(x);
+void test__fmodf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmodf(x, arg2);
 }
 
-void test__std__mbsinit__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::mbsinit(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fmodf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmodf(arg1, x);
 }
 
-void test__std__mbsinit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::mbsinit(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__getwchar__noreturn() {
-  int x = 1;
-  if (cond) { x=100; getwchar(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fmodf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fmodf(arg1, arg2);
 }
 
-void test__getwchar__leakignore() {
-  char *p = malloc(10); *p=0;
-  getwchar();
-  // cppcheck-suppress memleak
+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__mbstowcs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; mbstowcs(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fmodf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmodf(x, arg2);
 }
 
-void test__mbstowcs__leakignore() {
-  char *p = malloc(10); *p=0;
-  mbstowcs(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__fmodf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmodf(arg1, x);
 }
 
-void test__mbstowcs__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mbstowcs(arg1, p, arg3);
+void test__fmodl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fmodl(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__mbstowcs__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  mbstowcs(arg1, x, arg3);
+void test__fmodl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fmodl(arg1, arg2);
 }
 
-void test__mbstowcs__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mbstowcs(arg1, arg2, x);
+void test__fmodl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fmodl(arg1, arg2) > 10) || (fmodl(arg1, arg2) < 100)) {}
 }
 
-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__fmodl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fmodl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__mbstowcs__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::mbstowcs(arg1, p, arg3);
+void test__fmodl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmodl(x, arg2);
 }
 
-void test__std__mbstowcs__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::mbstowcs(arg1, x, arg3);
+void test__fmodl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fmodl(arg1, x);
 }
 
-void test__std__mbstowcs__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::mbstowcs(arg1, arg2, 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__mbsrtowcs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; mbsrtowcs(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fmodl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fmodl(arg1, arg2);
 }
 
-void test__mbsrtowcs__leakignore() {
-  char *p = malloc(10); *p=0;
-  mbsrtowcs(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+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__mbsrtowcs__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mbsrtowcs(arg1, p, arg3, arg4);
+void test__std__fmodl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmodl(x, arg2);
 }
 
-void test__mbsrtowcs__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  mbsrtowcs(arg1, x, arg3, arg4);
+void test__std__fmodl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fmodl(arg1, x);
 }
 
-void test__mbsrtowcs__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mbsrtowcs(arg1, arg2, x, arg4);
+void test__fopen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fopen(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__mbsrtowcs__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mbsrtowcs(arg1, arg2, arg3, p);
+void test__fopen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fopen(arg1, 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__fopen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = fopen(NULL, arg2);
 }
 
-void test__std__mbsrtowcs__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::mbsrtowcs(arg1, p, arg3, arg4);
+void test__fopen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = fopen(x, arg2);
 }
 
-void test__std__mbsrtowcs__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::mbsrtowcs(arg1, x, arg3, arg4);
+void test__fopen__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = fopen(arg1, NULL);
 }
 
-void test__std__mbsrtowcs__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::mbsrtowcs(arg1, arg2, x, arg4);
+void test__fopen__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = fopen(arg1, x);
 }
 
-void test__std__mbsrtowcs__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::mbsrtowcs(arg1, arg2, arg3, p);
+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__wctob__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wctob(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fopen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fopen(arg1, arg2);
 }
 
-void test__wctob__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wctob(arg1);
+void test__std__fopen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::fopen(NULL, arg2);
 }
 
-void test__wctob__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((wctob(arg1) > 10) || (wctob(arg1) < 100)) {}
+void test__std__fopen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::fopen(x, arg2);
 }
 
-void test__wctob__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wctob(p);
-  // cppcheck-suppress memleak
+void test__std__fopen__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::fopen(arg1, NULL);
 }
 
-void test__wctob__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wctob(x);
+void test__std__fopen__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::fopen(arg1, 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__fopen_s__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fopen_s(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__wctob__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wctob(arg1);
+void test__fopen_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fopen_s(NULL, arg2, arg3);
 }
 
-void test__std__wctob__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::wctob(arg1) > 10) || (std::wctob(arg1) < 100)) {}
+void test__fopen_s__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fopen_s(arg1, NULL, arg3);
 }
 
-void test__std__wctob__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wctob(x);
+void test__fopen_s__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fopen_s(arg1, x, arg3);
 }
 
-void test__wctomb__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wctomb(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fopen_s__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fopen_s(arg1, arg2, NULL);
 }
 
-void test__wctomb__leakignore() {
-  char *p = malloc(10); *p=0;
-  wctomb(p, arg2);
-  // cppcheck-suppress memleak
+void test__fopen_s__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fopen_s(arg1, arg2, x);
 }
 
-void test__wctomb__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wctomb(x, arg2);
+void test__fprintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fprintf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wctomb__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wctomb(arg1, x);
+void test__fprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fprintf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wctomb__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::wctomb(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fprintf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fprintf(NULL, arg2);
 }
 
-void test__std__wctomb__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wctomb(x, arg2);
+void test__fprintf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fprintf(x, arg2);
 }
 
-void test__std__wctomb__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wctomb(arg1, x);
+void test__fprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fprintf(arg1, 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__fprintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::fprintf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcstombs__leakignore() {
-  char *p = malloc(10); *p=0;
-  wcstombs(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__fprintf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fprintf(NULL, arg2);
 }
 
-void test__wcstombs__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcstombs(arg1, p, arg3);
+void test__std__fprintf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fprintf(x, arg2);
 }
 
-void test__wcstombs__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcstombs(arg1, x, arg3);
+void test__std__fprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fprintf(arg1, x);
 }
 
-void test__wcstombs__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wcstombs(arg1, arg2, x);
+void test__vfprintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        vfprintf(arg1, arg2, arg3);
+    }
+    // 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__vfprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    vfprintf(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wcstombs__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcstombs(arg1, p, arg3);
+void test__vfprintf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vfprintf(NULL, arg2, arg3);
 }
 
-void test__std__wcstombs__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wcstombs(arg1, x, arg3);
+void test__vfprintf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    vfprintf(x, arg2, arg3);
 }
 
-void test__std__wcstombs__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wcstombs(arg1, arg2, x);
+void test__vfprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    vfprintf(arg1, x, arg3);
 }
 
-void test__getchar__noreturn() {
-  int x = 1;
-  if (cond) { x=100; getchar(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__getchar__leakignore() {
-  char *p = malloc(10); *p=0;
-  getchar();
-  // cppcheck-suppress memleak
+void test__std__vfprintf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::vfprintf(NULL, arg2, arg3);
 }
 
-void test__ungetc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; ungetc(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__vfprintf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::vfprintf(x, arg2, arg3);
 }
 
-void test__ungetc__leakignore() {
-  char *p = malloc(10); *p=0;
-  ungetc(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__vfprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::vfprintf(arg1, x, arg3);
 }
 
-void test__ungetc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ungetc(x, arg2);
+void test__vfwprintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        vfwprintf(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ungetc__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ungetc(arg1, p);
+void test__vfwprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    vfwprintf(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__ungetc__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  ungetc(arg1, x);
+void test__vfwprintf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vfwprintf(NULL, arg2, arg3);
 }
 
-void test__std__ungetc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::ungetc(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__ungetc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::ungetc(x, arg2);
+void test__vfwprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    vfwprintf(arg1, x, arg3);
 }
 
-void test__std__ungetc__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::ungetc(arg1, p);
+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__std__ungetc__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::ungetc(arg1, x);
+void test__std__vfwprintf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::vfwprintf(NULL, arg2, arg3);
 }
 
-void test__ungetwc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; ungetwc(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__vfwprintf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::vfwprintf(x, arg2, arg3);
 }
 
-void test__ungetwc__leakignore() {
-  char *p = malloc(10); *p=0;
-  ungetwc(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__vfwprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::vfwprintf(arg1, x, arg3);
 }
 
-void test__ungetwc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ungetwc(x, arg2);
+void test__fputc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fputc(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ungetwc__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ungetwc(arg1, p);
+void test__fputc__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fputc(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__ungetwc__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  ungetwc(arg1, x);
+void test__fputc__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    fputc(!x, arg2);
 }
 
-void test__std__ungetwc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::ungetwc(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fputc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fputc(x, arg2);
 }
 
-void test__std__ungetwc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::ungetwc(x, arg2);
+void test__fputc__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fputc(arg1, NULL);
 }
 
-void test__std__ungetwc__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::ungetwc(arg1, p);
+void test__fputc__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fputc(arg1, x);
 }
 
-void test__std__ungetwc__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::ungetwc(arg1, 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__getenv__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = getenv(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fputc__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::fputc(!x, arg2);
 }
 
-void test__getenv__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  getenv(arg1);
+void test__std__fputc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fputc(x, arg2);
 }
 
-void test__getenv__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = getenv(p);
-  // cppcheck-suppress memleak
+void test__std__fputc__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fputc(arg1, NULL);
 }
 
-void test__getenv__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = getenv(p);
+void test__std__fputc__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fputc(arg1, x);
 }
 
-void test__getenv__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = getenv(x);
+void test__fputwc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fputwc(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__getenv__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::getenv(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fputwc__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fputwc(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__getenv__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::getenv(arg1);
+void test__fputwc__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    fputwc(!x, arg2);
 }
 
-void test__std__getenv__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::getenv(p);
+void test__fputwc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fputwc(x, arg2);
 }
 
-void test__std__getenv__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::getenv(x);
+void test__fputwc__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fputwc(arg1, NULL);
 }
 
-void test__gets__noreturn() {
-  int x = 1;
-  if (cond) { x=100; gets(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fputwc__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fputwc(arg1, x);
 }
 
-void test__gets__leakignore() {
-  char *p = malloc(10); *p=0;
-  gets(p);
-  // cppcheck-suppress memleak
+void test__std__fputwc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::fputwc(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__gets__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  gets(p);
+void test__std__fputwc__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::fputwc(!x, arg2);
 }
 
-void test__std__gets__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::gets(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fputwc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fputwc(x, arg2);
 }
 
-void test__std__gets__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::gets(p);
+void test__std__fputwc__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fputwc(arg1, NULL);
 }
 
-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__fputwc__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fputwc(arg1, x);
 }
 
-void test__gets_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  gets_s(p, arg2);
-  // cppcheck-suppress memleak
+void test__fputs__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fputs(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__gets_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  gets_s(p, arg2);
+void test__fputs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fputs(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__gets_s__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  gets_s(arg1, !x);
+void test__fputs__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fputs(NULL, arg2);
 }
 
-void test__gets_s__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  gets_s(arg1, x);
+void test__fputs__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fputs(x, arg2);
 }
 
-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__fputs__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fputs(arg1, NULL);
 }
 
-void test__std__gets_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::gets_s(p, arg2);
+void test__fputs__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fputs(arg1, x);
 }
 
-void test__std__gets_s__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::gets_s(arg1, !x);
+void test__std__fputs__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::fputs(arg1, arg2);
+    }
+    // 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__std__fputs__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fputs(NULL, arg2);
 }
 
-void test__gmtime__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = gmtime(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fputs__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fputs(x, arg2);
 }
 
-void test__gmtime__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  gmtime(arg1);
+void test__std__fputs__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fputs(arg1, NULL);
 }
 
-void test__gmtime__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((gmtime(arg1) > 10) || (gmtime(arg1) < 100)) {}
+void test__std__fputs__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fputs(arg1, x);
 }
 
-void test__gmtime__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = gmtime(p);
-  // cppcheck-suppress memleak
+void test__fputws__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fputws(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__gmtime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = gmtime(p);
+void test__fputws__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fputws(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__gmtime__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = gmtime(x);
+void test__fputws__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fputws(NULL, arg2);
 }
 
-void test__std__gmtime__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::gmtime(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fputws__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fputws(x, arg2);
 }
 
-void test__std__gmtime__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::gmtime(arg1);
+void test__fputws__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fputws(arg1, NULL);
 }
 
-void test__std__gmtime__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::gmtime(arg1) > 10) || (std::gmtime(arg1) < 100)) {}
+void test__fputws__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fputws(arg1, x);
 }
 
-void test__std__gmtime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::gmtime(p);
+void test__std__fputws__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::fputws(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__gmtime__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::gmtime(x);
+void test__std__fputws__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fputws(NULL, arg2);
 }
 
-void test__isalnum__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isalnum(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fputws__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fputws(x, arg2);
 }
 
-void test__isalnum__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isalnum(arg1);
+void test__std__fputws__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fputws(arg1, NULL);
 }
 
-void test__isalnum__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isalnum(arg1) > 10) || (isalnum(arg1) < 100)) {}
+void test__std__fputws__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fputws(arg1, x);
 }
 
-void test__isalnum__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isalnum(p);
-  // cppcheck-suppress memleak
+void test__fread__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fread(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__isalnum__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isalnum(x);
+void test__fread__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fread(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__std__isalnum__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::isalnum(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fread__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fread(NULL, arg2, arg3, arg4);
 }
 
-void test__std__isalnum__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isalnum(arg1);
+void test__fread__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fread(arg1, x, arg3, arg4);
 }
 
-void test__std__isalnum__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::isalnum(arg1) > 10) || (std::isalnum(arg1) < 100)) {}
+void test__fread__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fread(arg1, arg2, x, arg4);
 }
 
-void test__std__isalnum__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isalnum(x);
+void test__fread__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fread(arg1, arg2, arg3, NULL);
 }
 
-void test__iswalnum__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = iswalnum(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fread__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fread(arg1, arg2, arg3, x);
 }
 
-void test__iswalnum__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  iswalnum(arg1);
+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__iswalnum__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((iswalnum(arg1) > 10) || (iswalnum(arg1) < 100)) {}
+void test__std__fread__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fread(NULL, arg2, arg3, arg4);
 }
 
-void test__iswalnum__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = iswalnum(p);
-  // cppcheck-suppress memleak
+void test__std__fread__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fread(arg1, x, arg3, arg4);
 }
 
-void test__iswalnum__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = iswalnum(x);
+void test__std__fread__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fread(arg1, arg2, x, arg4);
 }
 
-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__fread__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fread(arg1, arg2, arg3, NULL);
 }
 
-void test__std__iswalnum__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::iswalnum(arg1);
+void test__std__fread__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fread(arg1, arg2, arg3, x);
 }
 
-void test__std__iswalnum__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::iswalnum(arg1) > 10) || (std::iswalnum(arg1) < 100)) {}
+void test__free__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        free(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__iswalnum__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::iswalnum(x);
+void test__free__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    free(x);
 }
 
-void test__isalpha__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isalpha(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__isalpha__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isalpha(arg1);
+void test__std__free__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::free(x);
 }
 
-void test__isalpha__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isalpha(arg1) > 10) || (isalpha(arg1) < 100)) {}
+void test__freopen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = freopen(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__isalpha__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isalpha(p);
-  // cppcheck-suppress memleak
+void test__freopen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    freopen(arg1, arg2, arg3);
 }
 
-void test__isalpha__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isalpha(x);
+void test__freopen__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = freopen(x, arg2, arg3);
 }
 
-void test__std__isalpha__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::isalpha(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__freopen__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = freopen(arg1, NULL, arg3);
 }
 
-void test__std__isalpha__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isalpha(arg1);
+void test__freopen__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = freopen(arg1, x, arg3);
 }
 
-void test__std__isalpha__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::isalpha(arg1) > 10) || (std::isalpha(arg1) < 100)) {}
+void test__freopen__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = freopen(arg1, arg2, NULL);
 }
 
-void test__std__isalpha__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isalpha(x);
+void test__freopen__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = freopen(arg1, arg2, x);
 }
 
-void test__iswalpha__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = iswalpha(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__iswalpha__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  iswalpha(arg1);
+void test__std__freopen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::freopen(arg1, arg2, arg3);
 }
 
-void test__iswalpha__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((iswalpha(arg1) > 10) || (iswalpha(arg1) < 100)) {}
+void test__std__freopen__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::freopen(x, arg2, arg3);
 }
 
-void test__iswalpha__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = iswalpha(p);
-  // cppcheck-suppress memleak
+void test__std__freopen__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::freopen(arg1, NULL, arg3);
 }
 
-void test__iswalpha__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = iswalpha(x);
+void test__std__freopen__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::freopen(arg1, x, arg3);
 }
 
-void test__std__iswalpha__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::iswalpha(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__freopen__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::freopen(arg1, arg2, NULL);
 }
 
-void test__std__iswalpha__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::iswalpha(arg1);
+void test__std__freopen__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::freopen(arg1, arg2, x);
 }
 
-void test__std__iswalpha__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::iswalpha(arg1) > 10) || (std::iswalpha(arg1) < 100)) {}
+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__iswalpha__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::iswalpha(x);
+void test__freopen_s__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    freopen_s(arg1, arg2, arg3, arg4);
 }
 
-void test__isblank__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isblank(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__isblank__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isblank(arg1);
+void test__freopen_s__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = freopen_s(arg1, x, arg3, arg4);
 }
 
-void test__isblank__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isblank(arg1) > 10) || (isblank(arg1) < 100)) {}
+void test__freopen_s__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = freopen_s(arg1, arg2, NULL, arg4);
 }
 
-void test__isblank__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isblank(p);
-  // cppcheck-suppress memleak
+void test__freopen_s__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = freopen_s(arg1, arg2, x, arg4);
 }
 
-void test__isblank__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isblank(x);
+void test__freopen_s__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = freopen_s(arg1, arg2, arg3, 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__freopen_s__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = freopen_s(arg1, arg2, arg3, x);
 }
 
-void test__std__isblank__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isblank(arg1);
+void test__frexp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        frexp(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__frexp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    frexp(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__isblank__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isblank(x);
+void test__frexp__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    frexp(x, arg2);
 }
 
-void test__iswblank__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = iswblank(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__frexp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    frexp(arg1, NULL);
 }
 
-void test__iswblank__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  iswblank(arg1);
+void test__std__frexp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::frexp(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__iswblank__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((iswblank(arg1) > 10) || (iswblank(arg1) < 100)) {}
+void test__std__frexp__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::frexp(x, arg2);
 }
 
-void test__iswblank__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = iswblank(p);
-  // cppcheck-suppress memleak
+void test__std__frexp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::frexp(arg1, NULL);
 }
 
-void test__iswblank__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = iswblank(x);
+void test__frexpf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        frexpf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__iswblank__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::iswblank(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__std__iswblank__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::iswblank(arg1);
+void test__frexpf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    frexpf(x, arg2);
 }
 
-void test__std__iswblank__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::iswblank(arg1) > 10) || (std::iswblank(arg1) < 100)) {}
+void test__frexpf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    frexpf(arg1, NULL);
 }
 
-void test__std__iswblank__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::iswblank(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__iscntrl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = iscntrl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__frexpf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::frexpf(x, arg2);
 }
 
-void test__iscntrl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  iscntrl(arg1);
+void test__std__frexpf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::frexpf(arg1, NULL);
 }
 
-void test__iscntrl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((iscntrl(arg1) > 10) || (iscntrl(arg1) < 100)) {}
+void test__frexpl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        frexpl(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__iscntrl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = iscntrl(p);
-  // cppcheck-suppress memleak
+void test__frexpl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    frexpl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__iscntrl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = iscntrl(x);
+void test__frexpl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    frexpl(x, 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__frexpl__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    frexpl(arg1, NULL);
 }
 
-void test__std__iscntrl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::iscntrl(arg1);
+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__iscntrl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::iscntrl(arg1) > 10) || (std::iscntrl(arg1) < 100)) {}
+void test__std__frexpl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::frexpl(x, arg2);
 }
 
-void test__std__iscntrl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::iscntrl(x);
+void test__std__frexpl__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::frexpl(arg1, NULL);
 }
 
-void test__iswcntrl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = iswcntrl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__iswcntrl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  iswcntrl(arg1);
+void test__hypot__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    hypot(arg1, arg2, arg3);
 }
 
-void test__iswcntrl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((iswcntrl(arg1) > 10) || (iswcntrl(arg1) < 100)) {}
+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__iswcntrl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = iswcntrl(p);
-  // cppcheck-suppress memleak
+void test__hypot__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = hypot(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__iswcntrl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = iswcntrl(x);
+void test__hypot__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = hypot(x, arg2, arg3);
 }
 
-void test__std__iswcntrl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::iswcntrl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__hypot__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = hypot(arg1, x, arg3);
 }
 
-void test__std__iswcntrl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::iswcntrl(arg1);
+void test__hypot__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = hypot(arg1, arg2, x);
 }
 
-void test__std__iswcntrl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::iswcntrl(arg1) > 10) || (std::iswcntrl(arg1) < 100)) {}
+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__iswcntrl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::iswcntrl(x);
+void test__std__hypot__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::hypot(arg1, arg2, arg3);
 }
 
-void test__iswctype__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = iswctype(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__iswctype__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  iswctype(arg1, arg2);
+void test__std__hypot__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::hypot(x, arg2, arg3);
 }
 
-void test__iswctype__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((iswctype(arg1, arg2) > 10) || (iswctype(arg1, arg2) < 100)) {}
+void test__std__hypot__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::hypot(arg1, x, arg3);
 }
 
-void test__iswctype__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = iswctype(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__hypot__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::hypot(arg1, arg2, x);
 }
 
-void test__iswctype__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = iswctype(x, arg2);
+void test__hypotf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = hypotf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__iswctype__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = iswctype(arg1, x);
+void test__hypotf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    hypotf(arg1, 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__hypotf__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((hypotf(arg1, arg2) > 10) || (hypotf(arg1, arg2) < 100)) {}
 }
 
-void test__std__iswctype__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::iswctype(arg1, arg2);
+void test__hypotf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = hypotf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__hypotf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = hypotf(x, arg2);
 }
 
-void test__std__iswctype__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::iswctype(x, arg2);
+void test__hypotf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = hypotf(arg1, x);
 }
 
-void test__std__iswctype__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::iswctype(arg1, 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__isdigit__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isdigit(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__hypotf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::hypotf(arg1, arg2);
 }
 
-void test__isdigit__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isdigit(arg1);
+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__isdigit__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isdigit(arg1) > 10) || (isdigit(arg1) < 100)) {}
+void test__std__hypotf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::hypotf(x, arg2);
 }
 
-void test__isdigit__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isdigit(p);
-  // cppcheck-suppress memleak
+void test__std__hypotf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::hypotf(arg1, x);
 }
 
-void test__isdigit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isdigit(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__isdigit__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::isdigit(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__hypotl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    hypotl(arg1, arg2);
 }
 
-void test__std__isdigit__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isdigit(arg1);
+void test__hypotl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((hypotl(arg1, arg2) > 10) || (hypotl(arg1, arg2) < 100)) {}
 }
 
-void test__std__isdigit__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::isdigit(arg1) > 10) || (std::isdigit(arg1) < 100)) {}
+void test__hypotl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = hypotl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__isdigit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isdigit(x);
+void test__hypotl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = hypotl(x, arg2);
 }
 
-void test__iswdigit__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = iswdigit(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__hypotl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = hypotl(arg1, x);
 }
 
-void test__iswdigit__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  iswdigit(arg1);
+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__iswdigit__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((iswdigit(arg1) > 10) || (iswdigit(arg1) < 100)) {}
+void test__std__hypotl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::hypotl(arg1, arg2);
 }
 
-void test__iswdigit__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = iswdigit(p);
-  // cppcheck-suppress memleak
+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__iswdigit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = iswdigit(x);
+void test__std__hypotl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::hypotl(x, arg2);
 }
 
-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__hypotl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::hypotl(arg1, x);
 }
 
-void test__std__iswdigit__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::iswdigit(arg1);
+void test__fscanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fscanf(arg1, arg2);
+    }
+    // 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__fscanf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fscanf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__iswdigit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::iswdigit(x);
+void test__fscanf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fscanf(x, arg2);
 }
 
-void test__isgraph__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isgraph(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fscanf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fscanf(arg1, x);
 }
 
-void test__isgraph__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isgraph(arg1);
+void test__std__fscanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::fscanf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__isgraph__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isgraph(arg1) > 10) || (isgraph(arg1) < 100)) {}
+void test__std__fscanf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fscanf(x, arg2);
 }
 
-void test__isgraph__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isgraph(p);
-  // cppcheck-suppress memleak
+void test__std__fscanf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fscanf(arg1, x);
 }
 
-void test__isgraph__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isgraph(x);
+void test__vfscanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        vfscanf(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__isgraph__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::isgraph(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__vfscanf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    vfscanf(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__isgraph__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isgraph(arg1);
+void test__vfscanf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    vfscanf(x, arg2, arg3);
 }
 
-void test__std__isgraph__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::isgraph(arg1) > 10) || (std::isgraph(arg1) < 100)) {}
+void test__vfscanf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    vfscanf(arg1, x, arg3);
 }
 
-void test__std__isgraph__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isgraph(x);
+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__iswgraph__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = iswgraph(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__vfscanf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::vfscanf(arg1, x, arg3);
 }
 
-void test__iswgraph__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  iswgraph(arg1);
+void test__vfwscanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        vfwscanf(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__iswgraph__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((iswgraph(arg1) > 10) || (iswgraph(arg1) < 100)) {}
+void test__vfwscanf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    vfwscanf(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__iswgraph__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = iswgraph(p);
-  // cppcheck-suppress memleak
+void test__vfwscanf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    vfwscanf(x, arg2, arg3);
 }
 
-void test__iswgraph__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = iswgraph(x);
+void test__vfwscanf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vfwscanf(arg1, NULL, arg3);
 }
 
-void test__std__iswgraph__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::iswgraph(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__vfwscanf__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    vfwscanf(arg1, x, arg3);
 }
 
-void test__std__iswgraph__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::iswgraph(arg1);
+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__iswgraph__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::iswgraph(arg1) > 10) || (std::iswgraph(arg1) < 100)) {}
+void test__std__vfwscanf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::vfwscanf(x, arg2, arg3);
 }
 
-void test__std__iswgraph__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::iswgraph(x);
+void test__std__vfwscanf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::vfwscanf(arg1, NULL, arg3);
 }
 
-void test__islower__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = islower(arg1); }
-  // 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__islower__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  islower(arg1);
+void test__fseek__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fseek(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__islower__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((islower(arg1) > 10) || (islower(arg1) < 100)) {}
+void test__fseek__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fseek(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__islower__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = islower(p);
-  // cppcheck-suppress memleak
+void test__fseek__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fseek(NULL, arg2, arg3);
 }
 
-void test__islower__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = islower(x);
+void test__fseek__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fseek(x, arg2, arg3);
 }
 
-void test__std__islower__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::islower(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fseek__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fseek(arg1, x, arg3);
 }
 
-void test__std__islower__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::islower(arg1);
+void test__fseek__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fseek(arg1, arg2, x);
 }
 
-void test__std__islower__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::islower(arg1) > 10) || (std::islower(arg1) < 100)) {}
+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__islower__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::islower(x);
+void test__std__fseek__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fseek(NULL, arg2, arg3);
 }
 
-void test__iswlower__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = iswlower(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fseek__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fseek(x, arg2, arg3);
 }
 
-void test__iswlower__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  iswlower(arg1);
+void test__std__fseek__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fseek(arg1, x, arg3);
 }
 
-void test__iswlower__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((iswlower(arg1) > 10) || (iswlower(arg1) < 100)) {}
+void test__std__fseek__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fseek(arg1, arg2, x);
 }
 
-void test__iswlower__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = iswlower(p);
-  // cppcheck-suppress memleak
+void test__fsetpos__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fsetpos(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__iswlower__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = iswlower(x);
+void test__fsetpos__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fsetpos(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__iswlower__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::iswlower(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fsetpos__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fsetpos(NULL, arg2);
 }
 
-void test__std__iswlower__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::iswlower(arg1);
+void test__fsetpos__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fsetpos(x, arg2);
 }
 
-void test__std__iswlower__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::iswlower(arg1) > 10) || (std::iswlower(arg1) < 100)) {}
+void test__fsetpos__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fsetpos(arg1, NULL);
 }
 
-void test__std__iswlower__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::iswlower(x);
+void test__fsetpos__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fsetpos(arg1, x);
 }
 
-void test__isprint__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isprint(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__isprint__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isprint(arg1);
+void test__std__fsetpos__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fsetpos(NULL, arg2);
 }
 
-void test__isprint__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isprint(arg1) > 10) || (isprint(arg1) < 100)) {}
+void test__std__fsetpos__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fsetpos(x, arg2);
 }
 
-void test__isprint__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isprint(p);
-  // cppcheck-suppress memleak
+void test__std__fsetpos__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fsetpos(arg1, NULL);
 }
 
-void test__isprint__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isprint(x);
+void test__std__fsetpos__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fsetpos(arg1, x);
 }
 
-void test__std__isprint__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::isprint(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__isprint__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isprint(arg1);
+void test__fgets__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fgets(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__isprint__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::isprint(arg1) > 10) || (std::isprint(arg1) < 100)) {}
+void test__fgets__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fgets(NULL, arg2, arg3);
 }
 
-void test__std__isprint__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isprint(x);
+void test__fgets__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    fgets(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__fgets__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fgets(arg1, x, arg3);
 }
 
-void test__iswprint__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  iswprint(arg1);
+void test__fgets__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fgets(arg1, arg2, NULL);
 }
 
-void test__iswprint__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((iswprint(arg1) > 10) || (iswprint(arg1) < 100)) {}
+void test__fgets__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fgets(arg1, arg2, x);
 }
 
-void test__iswprint__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = iswprint(p);
-  // cppcheck-suppress memleak
+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__iswprint__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = iswprint(x);
+void test__std__fgets__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fgets(NULL, arg2, arg3);
 }
 
-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__fgets__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::fgets(arg1, !x, arg3);
 }
 
-void test__std__iswprint__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::iswprint(arg1);
+void test__std__fgets__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fgets(arg1, x, arg3);
 }
 
-void test__std__iswprint__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::iswprint(arg1) > 10) || (std::iswprint(arg1) < 100)) {}
+void test__std__fgets__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fgets(arg1, arg2, NULL);
 }
 
-void test__std__iswprint__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::iswprint(x);
+void test__std__fgets__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fgets(arg1, arg2, x);
 }
 
-void test__ispunct__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ispunct(arg1); }
-  // 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__ispunct__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ispunct(arg1);
+void test__fgetws__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fgetws(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__ispunct__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ispunct(arg1) > 10) || (ispunct(arg1) < 100)) {}
+void test__fgetws__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fgetws(NULL, arg2, arg3);
 }
 
-void test__ispunct__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ispunct(p);
-  // cppcheck-suppress memleak
+void test__fgetws__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    fgetws(arg1, !x, arg3);
 }
 
-void test__ispunct__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ispunct(x);
+void test__fgetws__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fgetws(arg1, x, arg3);
 }
 
-void test__std__ispunct__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::ispunct(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fgetws__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fgetws(arg1, arg2, NULL);
 }
 
-void test__std__ispunct__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ispunct(arg1);
+void test__fgetws__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fgetws(arg1, arg2, x);
 }
 
-void test__std__ispunct__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::ispunct(arg1) > 10) || (std::ispunct(arg1) < 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__std__ispunct__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::ispunct(x);
+void test__std__fgetws__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fgetws(NULL, arg2, arg3);
 }
 
-void test__iswpunct__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = iswpunct(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fgetws__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::fgetws(arg1, !x, arg3);
 }
 
-void test__iswpunct__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  iswpunct(arg1);
+void test__std__fgetws__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fgetws(arg1, x, arg3);
 }
 
-void test__iswpunct__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((iswpunct(arg1) > 10) || (iswpunct(arg1) < 100)) {}
+void test__std__fgetws__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fgetws(arg1, arg2, NULL);
 }
 
-void test__iswpunct__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = iswpunct(p);
-  // cppcheck-suppress memleak
+void test__std__fgetws__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fgetws(arg1, arg2, x);
 }
 
-void test__iswpunct__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = iswpunct(x);
+void test__ftell__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ftell(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__iswpunct__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::iswpunct(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ftell__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ftell(arg1);
 }
 
-void test__std__iswpunct__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::iswpunct(arg1);
+void test__ftell__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ftell(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__iswpunct__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::iswpunct(arg1) > 10) || (std::iswpunct(arg1) < 100)) {}
+void test__ftell__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = ftell(NULL);
 }
 
-void test__std__iswpunct__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::iswpunct(x);
+void test__ftell__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = ftell(x);
 }
 
-void test__isspace__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isspace(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__isspace__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isspace(arg1);
+void test__std__ftell__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::ftell(arg1);
 }
 
-void test__isspace__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isspace(arg1) > 10) || (isspace(arg1) < 100)) {}
+void test__std__ftell__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::ftell(NULL);
 }
 
-void test__isspace__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isspace(p);
-  // cppcheck-suppress memleak
+void test__std__ftell__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::ftell(x);
 }
 
-void test__isspace__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isspace(x);
+void test__fwide__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fwide(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__isspace__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::isspace(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fwide__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fwide(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__isspace__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isspace(arg1);
+void test__fwide__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fwide(NULL, arg2);
 }
 
-void test__std__isspace__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::isspace(arg1) > 10) || (std::isspace(arg1) < 100)) {}
+void test__fwide__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fwide(x, arg2);
 }
 
-void test__std__isspace__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isspace(x);
+void test__fwide__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fwide(arg1, x);
 }
 
-void test__iswspace__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = iswspace(arg1); }
-  // 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__iswspace__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  iswspace(arg1);
+void test__std__fwide__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fwide(NULL, arg2);
 }
 
-void test__iswspace__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((iswspace(arg1) > 10) || (iswspace(arg1) < 100)) {}
+void test__std__fwide__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fwide(x, arg2);
 }
 
-void test__iswspace__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = iswspace(p);
-  // cppcheck-suppress memleak
+void test__std__fwide__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fwide(arg1, x);
 }
 
-void test__iswspace__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = iswspace(x);
+void test__fwrite__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fwrite(arg1, arg2, arg3, arg4);
+    }
+    // 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__fwrite__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fwrite(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__std__iswspace__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::iswspace(arg1);
+void test__fwrite__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fwrite(NULL, arg2, arg3, arg4);
 }
 
-void test__std__iswspace__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::iswspace(arg1) > 10) || (std::iswspace(arg1) < 100)) {}
+void test__fwrite__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fwrite(x, arg2, arg3, arg4);
 }
 
-void test__std__iswspace__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::iswspace(x);
+void test__fwrite__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fwrite(arg1, x, arg3, arg4);
 }
 
-void test__isupper__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isupper(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fwrite__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    fwrite(arg1, arg2, x, arg4);
 }
 
-void test__isupper__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isupper(arg1);
+void test__fwrite__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fwrite(arg1, arg2, arg3, NULL);
 }
 
-void test__isupper__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isupper(arg1) > 10) || (isupper(arg1) < 100)) {}
+void test__fwrite__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fwrite(arg1, arg2, arg3, x);
 }
 
-void test__isupper__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isupper(p);
-  // cppcheck-suppress memleak
+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__isupper__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isupper(x);
+void test__std__fwrite__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fwrite(NULL, arg2, arg3, arg4);
 }
 
-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__fwrite__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fwrite(x, arg2, arg3, arg4);
 }
 
-void test__std__isupper__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isupper(arg1);
+void test__std__fwrite__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fwrite(arg1, x, arg3, arg4);
 }
 
-void test__std__isupper__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::isupper(arg1) > 10) || (std::isupper(arg1) < 100)) {}
+void test__std__fwrite__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fwrite(arg1, arg2, x, arg4);
 }
 
-void test__std__isupper__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isupper(x);
+void test__std__fwrite__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fwrite(arg1, arg2, arg3, NULL);
 }
 
-void test__iswupper__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = iswupper(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__fwrite__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fwrite(arg1, arg2, arg3, x);
 }
 
-void test__iswupper__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  iswupper(arg1);
+void test__mblen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        mblen(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__iswupper__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((iswupper(arg1) > 10) || (iswupper(arg1) < 100)) {}
+void test__mblen__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    mblen(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__iswupper__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = iswupper(p);
-  // cppcheck-suppress memleak
+void test__mblen__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mblen(x, arg2);
 }
 
-void test__iswupper__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = iswupper(x);
+void test__mblen__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mblen(arg1, x);
 }
 
-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__mblen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::mblen(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__iswupper__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::iswupper(arg1);
+void test__std__mblen__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::mblen(x, arg2);
 }
 
-void test__std__iswupper__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::iswupper(arg1) > 10) || (std::iswupper(arg1) < 100)) {}
+void test__std__mblen__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::mblen(arg1, x);
 }
 
-void test__std__iswupper__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::iswupper(x);
+void test__mbtowc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        mbtowc(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__isxdigit__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isxdigit(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__mbtowc__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    mbtowc(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__isxdigit__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isxdigit(arg1);
+void test__mbtowc__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mbtowc(arg1, x, arg3);
 }
 
-void test__isxdigit__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isxdigit(arg1) > 10) || (isxdigit(arg1) < 100)) {}
+void test__mbtowc__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mbtowc(arg1, arg2, x);
 }
 
-void test__isxdigit__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isxdigit(p);
-  // cppcheck-suppress memleak
+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__isxdigit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isxdigit(x);
+void test__std__mbtowc__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::mbtowc(arg1, x, arg3);
 }
 
-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__mbtowc__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::mbtowc(arg1, arg2, x);
 }
 
-void test__std__isxdigit__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isxdigit(arg1);
+void test__mbrlen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        mbrlen(arg1, arg2, arg3);
+    }
+    // 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__mbrlen__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    mbrlen(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__isxdigit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isxdigit(x);
+void test__mbrlen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    mbrlen(NULL, arg2, arg3);
 }
 
-void test__iswxdigit__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = iswxdigit(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__mbrlen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    mbrlen(x, arg2, arg3);
 }
 
-void test__iswxdigit__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  iswxdigit(arg1);
+void test__mbrlen__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mbrlen(arg1, x, arg3);
 }
 
-void test__iswxdigit__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((iswxdigit(arg1) > 10) || (iswxdigit(arg1) < 100)) {}
+void test__mbrlen__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mbrlen(arg1, arg2, x);
 }
 
-void test__iswxdigit__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = iswxdigit(p);
-  // cppcheck-suppress memleak
+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__iswxdigit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = iswxdigit(x);
+void test__std__mbrlen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::mbrlen(NULL, arg2, arg3);
 }
 
-void test__std__iswxdigit__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::iswxdigit(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__mbrlen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::mbrlen(x, arg2, arg3);
 }
 
-void test__std__iswxdigit__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::iswxdigit(arg1);
+void test__std__mbrlen__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::mbrlen(arg1, x, arg3);
 }
 
-void test__std__iswxdigit__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::iswxdigit(arg1) > 10) || (std::iswxdigit(arg1) < 100)) {}
+void test__std__mbrlen__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::mbrlen(arg1, arg2, x);
 }
 
-void test__std__iswxdigit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::iswxdigit(x);
+void test__btowc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = btowc(arg1);
+    }
+    // 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__btowc__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    btowc(arg1);
 }
 
-void test__towctrans__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  towctrans(arg1, arg2);
+void test__btowc__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((btowc(arg1) > 10) || (btowc(arg1) < 100)) {}
 }
 
-void test__towctrans__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((towctrans(arg1, arg2) > 10) || (towctrans(arg1, arg2) < 100)) {}
+void test__btowc__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = btowc(p);
+    // cppcheck-suppress memleak
 }
 
-void test__towctrans__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = towctrans(p, arg2);
-  // cppcheck-suppress memleak
+void test__btowc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = btowc(x);
 }
 
-void test__towctrans__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = towctrans(x, arg2);
+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__towctrans__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = towctrans(arg1, x);
+void test__std__btowc__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::btowc(arg1) > 10) || (std::btowc(arg1) < 100)) {}
 }
 
-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__std__btowc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::btowc(x);
 }
 
-void test__std__towctrans__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::towctrans(arg1, arg2);
+void test__mbsinit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        mbsinit(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
-
-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__mbsinit__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    mbsinit(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__towctrans__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::towctrans(x, arg2);
+void test__mbsinit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mbsinit(x);
 }
 
-void test__std__towctrans__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::towctrans(arg1, x);
+void test__std__mbsinit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::mbsinit(arg1);
+    }
+    // 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__mbsinit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::mbsinit(x);
 }
 
-void test__towlower__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  towlower(arg1);
+void test__getwchar__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        getwchar();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
-
-void test__towlower__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((towlower(arg1) > 10) || (towlower(arg1) < 100)) {}
+
+void test__getwchar__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    getwchar();
+    // cppcheck-suppress memleak
 }
-
-void test__towlower__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = towlower(p);
-  // cppcheck-suppress memleak
+
+void test__mbstowcs__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        mbstowcs(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__towlower__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = towlower(x);
+void test__mbstowcs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    mbstowcs(p, arg2, arg3);
+    // 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__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__towlower__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::towlower(arg1);
-}
+void test__mbstowcs__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mbstowcs(arg1, arg2, x);
+}
 
-void test__std__towlower__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::towlower(arg1) > 10) || (std::towlower(arg1) < 100)) {}
+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__towlower__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::towlower(x);
+void test__std__mbstowcs__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::mbstowcs(arg1, NULL, arg3);
 }
 
-void test__towupper__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = towupper(arg1); }
-  // 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__towupper__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  towupper(arg1);
+void test__std__mbstowcs__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::mbstowcs(arg1, arg2, x);
 }
 
-void test__towupper__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((towupper(arg1) > 10) || (towupper(arg1) < 100)) {}
+void test__mbsrtowcs__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        mbsrtowcs(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__towupper__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = towupper(p);
-  // cppcheck-suppress memleak
+void test__mbsrtowcs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    mbsrtowcs(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__towupper__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = towupper(x);
+void test__mbsrtowcs__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    mbsrtowcs(arg1, NULL, arg3, arg4);
 }
 
-void test__std__towupper__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::towupper(arg1); }
-  // 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__towupper__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::towupper(arg1);
+void test__mbsrtowcs__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mbsrtowcs(arg1, arg2, x, arg4);
 }
 
-void test__std__towupper__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::towupper(arg1) > 10) || (std::towupper(arg1) < 100)) {}
+void test__mbsrtowcs__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    mbsrtowcs(arg1, arg2, arg3, NULL);
 }
 
-void test__std__towupper__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::towupper(x);
+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__wctrans__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wctrans(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__mbsrtowcs__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::mbsrtowcs(arg1, NULL, arg3, arg4);
 }
 
-void test__wctrans__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wctrans(arg1);
+void test__std__mbsrtowcs__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::mbsrtowcs(arg1, x, arg3, arg4);
 }
 
-void test__wctrans__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((wctrans(arg1) > 10) || (wctrans(arg1) < 100)) {}
+void test__std__mbsrtowcs__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::mbsrtowcs(arg1, arg2, x, arg4);
 }
 
-void test__wctrans__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wctrans(p);
-  // cppcheck-suppress memleak
+void test__std__mbsrtowcs__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::mbsrtowcs(arg1, arg2, arg3, NULL);
 }
 
-void test__wctrans__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wctrans(p);
+void test__wctob__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wctob(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wctrans__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wctrans(x);
+void test__wctob__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wctob(arg1);
 }
 
-void test__std__wctrans__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::wctrans(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__wctrans__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wctrans(arg1);
+void test__wctob__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wctob(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wctrans__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::wctrans(arg1) > 10) || (std::wctrans(arg1) < 100)) {}
+void test__wctob__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = wctob(x);
 }
 
-void test__std__wctrans__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wctrans(p);
+void test__std__wctob__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::wctob(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__wctrans__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wctrans(x);
+void test__std__wctob__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wctob(arg1);
 }
 
-void test__wctype__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wctype(arg1); }
-  // 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__wctype__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wctype(arg1);
+void test__std__wctob__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wctob(x);
 }
 
-void test__wctype__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((wctype(arg1) > 10) || (wctype(arg1) < 100)) {}
+void test__wctomb__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wctomb(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wctype__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wctype(p);
-  // cppcheck-suppress memleak
+void test__wctomb__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wctomb(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__wctype__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wctype(p);
+void test__wctomb__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wctomb(x, arg2);
 }
 
-void test__wctype__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wctype(x);
+void test__wctomb__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wctomb(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__wctomb__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::wctomb(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__wctype__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wctype(arg1);
+void test__std__wctomb__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wctomb(x, arg2);
 }
 
-void test__std__wctype__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::wctype(arg1) > 10) || (std::wctype(arg1) < 100)) {}
-}
+void test__std__wctomb__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wctomb(arg1, x);
+}
 
-void test__std__wctype__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wctype(p);
+void test__wcstombs__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wcstombs(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__wctype__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wctype(x);
+void test__wcstombs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcstombs(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__cabs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cabs(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcstombs__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcstombs(arg1, NULL, arg3);
 }
 
-void test__cabs__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cabs(arg1);
+void test__wcstombs__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcstombs(arg1, x, arg3);
 }
 
-void test__cabs__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cabs(arg1) > 10) || (cabs(arg1) < 100)) {}
-}
+void test__wcstombs__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wcstombs(arg1, arg2, x);
+}
 
-void test__cabs__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cabs(p);
-  // 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__cabs__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cabs(x);
+void test__std__wcstombs__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcstombs(arg1, NULL, arg3);
 }
 
-void test__cabsf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cabsf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wcstombs__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wcstombs(arg1, x, arg3);
 }
 
-void test__cabsf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cabsf(arg1);
-}
+void test__std__wcstombs__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wcstombs(arg1, arg2, x);
+}
 
-void test__cabsf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cabsf(arg1) > 10) || (cabsf(arg1) < 100)) {}
+void test__getchar__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        getchar();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cabsf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cabsf(p);
-  // cppcheck-suppress memleak
+void test__getchar__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    getchar();
+    // cppcheck-suppress memleak
 }
 
-void test__cabsf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cabsf(x);
+void test__ungetc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        ungetc(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cabsl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cabsl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ungetc__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    ungetc(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__cabsl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cabsl(arg1);
+void test__ungetc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ungetc(x, arg2);
 }
 
-void test__cabsl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cabsl(arg1) > 10) || (cabsl(arg1) < 100)) {}
+void test__ungetc__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    ungetc(arg1, NULL);
 }
 
-void test__cabsl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cabsl(p);
-  // cppcheck-suppress memleak
+void test__ungetc__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    ungetc(arg1, x);
 }
 
-void test__cabsl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cabsl(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__cacos__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cacos(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__ungetc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::ungetc(x, arg2);
 }
 
-void test__cacos__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cacos(arg1);
+void test__std__ungetc__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::ungetc(arg1, NULL);
 }
 
-void test__cacos__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cacos(arg1) > 10) || (cacos(arg1) < 100)) {}
+void test__std__ungetc__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::ungetc(arg1, x);
 }
 
-void test__cacos__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cacos(p);
-  // cppcheck-suppress memleak
+void test__ungetwc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        ungetwc(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cacos__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cacos(x);
+void test__ungetwc__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    ungetwc(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__cacosf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cacosf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ungetwc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ungetwc(x, arg2);
 }
 
-void test__cacosf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cacosf(arg1);
+void test__ungetwc__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    ungetwc(arg1, NULL);
 }
 
-void test__cacosf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cacosf(arg1) > 10) || (cacosf(arg1) < 100)) {}
+void test__ungetwc__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    ungetwc(arg1, x);
 }
 
-void test__cacosf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cacosf(p);
-  // cppcheck-suppress memleak
+void test__std__ungetwc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::ungetwc(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cacosf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cacosf(x);
+void test__std__ungetwc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::ungetwc(x, arg2);
 }
 
-void test__cacosl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cacosl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__ungetwc__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::ungetwc(arg1, NULL);
 }
 
-void test__cacosl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cacosl(arg1);
+void test__std__ungetwc__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::ungetwc(arg1, x);
 }
 
-void test__cacosl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cacosl(arg1) > 10) || (cacosl(arg1) < 100)) {}
+void test__getenv__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = getenv(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__getenv__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    getenv(arg1);
 }
 
-void test__cacosl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cacosl(x);
+void test__getenv__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = getenv(p);
+    // cppcheck-suppress memleak
 }
 
-void test__cacosh__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cacosh(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getenv__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = getenv(NULL);
 }
 
-void test__cacosh__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cacosh(arg1);
+void test__getenv__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = getenv(x);
 }
 
-void test__cacosh__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cacosh(arg1) > 10) || (cacosh(arg1) < 100)) {}
+void test__std__getenv__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::getenv(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cacosh__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cacosh(p);
-  // cppcheck-suppress memleak
+void test__std__getenv__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::getenv(arg1);
 }
 
-void test__cacosh__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cacosh(x);
+void test__std__getenv__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::getenv(NULL);
 }
 
-void test__cacoshf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cacoshf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__getenv__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::getenv(x);
 }
 
-void test__cacoshf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cacoshf(arg1);
+void test__gets__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        gets(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__gets__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    gets(p);
+    // cppcheck-suppress memleak
 }
 
-void test__cacoshf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cacoshf(p);
-  // cppcheck-suppress memleak
+void test__gets__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    gets(NULL);
 }
 
-void test__cacoshf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cacoshf(x);
+void test__std__gets__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::gets(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cacoshl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cacoshl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__gets__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::gets(NULL);
 }
 
-void test__cacoshl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cacoshl(arg1);
+void test__gets_s__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        gets_s(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cacoshl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cacoshl(arg1) > 10) || (cacoshl(arg1) < 100)) {}
+void test__gets_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    gets_s(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__cacoshl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cacoshl(p);
-  // cppcheck-suppress memleak
+void test__gets_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    gets_s(NULL, arg2);
 }
 
-void test__cacoshl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cacoshl(x);
+void test__gets_s__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    gets_s(arg1, !x);
 }
 
-void test__labs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = labs(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__gets_s__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    gets_s(arg1, x);
 }
 
-void test__labs__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  labs(arg1);
+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__labs__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((labs(arg1) > 10) || (labs(arg1) < 100)) {}
+void test__std__gets_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::gets_s(NULL, arg2);
 }
 
-void test__labs__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = labs(p);
-  // cppcheck-suppress memleak
+void test__std__gets_s__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::gets_s(arg1, !x);
 }
 
-void test__labs__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = labs(x);
+void test__std__gets_s__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::gets_s(arg1, x);
 }
 
-void test__std__labs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::labs(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__gmtime__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = gmtime(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__labs__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::labs(arg1);
+void test__gmtime__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    gmtime(arg1);
 }
 
-void test__std__labs__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::labs(arg1) > 10) || (std::labs(arg1) < 100)) {}
+void test__gmtime__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((gmtime(arg1) > 10) || (gmtime(arg1) < 100)) {}
 }
 
-void test__std__labs__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::labs(x);
+void test__gmtime__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = gmtime(p);
+    // cppcheck-suppress memleak
 }
 
-void test__llabs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = llabs(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__gmtime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = gmtime(NULL);
 }
 
-void test__llabs__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  llabs(arg1);
+void test__gmtime__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = gmtime(x);
 }
 
-void test__llabs__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((llabs(arg1) > 10) || (llabs(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__llabs__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = llabs(p);
-  // cppcheck-suppress memleak
+void test__std__gmtime__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::gmtime(arg1);
 }
 
-void test__llabs__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = llabs(x);
+void test__std__gmtime__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::gmtime(arg1) > 10) || (std::gmtime(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__gmtime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::gmtime(NULL);
 }
 
-void test__std__llabs__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::llabs(arg1);
+void test__std__gmtime__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::gmtime(x);
 }
 
-void test__std__llabs__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::llabs(arg1) > 10) || (std::llabs(arg1) < 100)) {}
+void test__isalnum__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = isalnum(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__llabs__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::llabs(x);
+void test__isalnum__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isalnum(arg1);
 }
 
-void test__ldexp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ldexp(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__isalnum__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isalnum(arg1) > 10) || (isalnum(arg1) < 100)) {}
 }
 
-void test__ldexp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ldexp(arg1, arg2);
+void test__isalnum__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isalnum(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ldexp__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ldexp(arg1, arg2) > 10) || (ldexp(arg1, arg2) < 100)) {}
+void test__isalnum__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isalnum(x);
 }
 
-void test__ldexp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ldexp(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__isalnum__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::isalnum(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ldexp__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ldexp(x, arg2);
+void test__std__isalnum__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isalnum(arg1);
 }
 
-void test__ldexp__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ldexp(arg1, x);
+void test__std__isalnum__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::isalnum(arg1) > 10) || (std::isalnum(arg1) < 100)) {}
 }
 
-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__isalnum__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isalnum(x);
 }
 
-void test__std__ldexp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ldexp(arg1, arg2);
+void test__iswalnum__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = iswalnum(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__iswalnum__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    iswalnum(arg1);
 }
 
-void test__std__ldexp__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::ldexp(x, arg2);
+void test__iswalnum__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((iswalnum(arg1) > 10) || (iswalnum(arg1) < 100)) {}
 }
 
-void test__std__ldexp__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::ldexp(arg1, x);
+void test__iswalnum__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = iswalnum(p);
+    // cppcheck-suppress memleak
 }
 
-void test__ldexpf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ldexpf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__iswalnum__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = iswalnum(x);
 }
 
-void test__ldexpf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ldexpf(arg1, arg2);
+void test__std__iswalnum__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::iswalnum(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ldexpf__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ldexpf(arg1, arg2) > 10) || (ldexpf(arg1, arg2) < 100)) {}
+void test__std__iswalnum__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::iswalnum(arg1);
 }
 
-void test__ldexpf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ldexpf(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__iswalnum__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::iswalnum(arg1) > 10) || (std::iswalnum(arg1) < 100)) {}
 }
 
-void test__ldexpf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ldexpf(x, arg2);
+void test__std__iswalnum__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::iswalnum(x);
 }
 
-void test__ldexpf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ldexpf(arg1, x);
+void test__isalpha__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = isalpha(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__isalpha__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isalpha(arg1);
 }
 
-void test__std__ldexpf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ldexpf(arg1, arg2);
+void test__isalpha__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isalpha(arg1) > 10) || (isalpha(arg1) < 100)) {}
 }
 
-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__isalpha__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isalpha(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__ldexpf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::ldexpf(x, arg2);
+void test__isalpha__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isalpha(x);
 }
 
-void test__std__ldexpf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::ldexpf(arg1, 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__ldexpl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ldexpl(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__isalpha__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isalpha(arg1);
 }
 
-void test__ldexpl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ldexpl(arg1, arg2);
+void test__std__isalpha__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::isalpha(arg1) > 10) || (std::isalpha(arg1) < 100)) {}
 }
 
-void test__ldexpl__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ldexpl(arg1, arg2) > 10) || (ldexpl(arg1, arg2) < 100)) {}
+void test__std__isalpha__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isalpha(x);
 }
 
-void test__ldexpl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ldexpl(p, arg2);
-  // cppcheck-suppress memleak
+void test__iswalpha__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = iswalpha(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ldexpl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ldexpl(x, arg2);
+void test__iswalpha__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    iswalpha(arg1);
 }
 
-void test__ldexpl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ldexpl(arg1, x);
+void test__iswalpha__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((iswalpha(arg1) > 10) || (iswalpha(arg1) < 100)) {}
 }
 
-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__iswalpha__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = iswalpha(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__ldexpl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ldexpl(arg1, arg2);
+void test__iswalpha__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = iswalpha(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__iswalpha__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::iswalpha(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__ldexpl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::ldexpl(x, arg2);
+void test__std__iswalpha__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::iswalpha(arg1);
 }
 
-void test__std__ldexpl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::ldexpl(arg1, x);
+void test__std__iswalpha__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::iswalpha(arg1) > 10) || (std::iswalpha(arg1) < 100)) {}
 }
 
-void test__lgamma__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = lgamma(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__iswalpha__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::iswalpha(x);
 }
 
-void test__lgamma__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  lgamma(arg1);
+void test__isblank__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = isblank(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lgamma__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((lgamma(arg1) > 10) || (lgamma(arg1) < 100)) {}
+void test__isblank__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isblank(arg1);
 }
 
-void test__lgamma__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = lgamma(p);
-  // cppcheck-suppress memleak
+void test__isblank__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isblank(arg1) > 10) || (isblank(arg1) < 100)) {}
 }
 
-void test__lgamma__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = lgamma(x);
+void test__isblank__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isblank(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__lgamma__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::lgamma(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__isblank__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isblank(x);
 }
 
-void test__std__lgamma__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::lgamma(arg1);
+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__lgamma__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::lgamma(arg1) > 10) || (std::lgamma(arg1) < 100)) {}
+void test__std__isblank__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isblank(arg1);
 }
 
-void test__std__lgamma__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::lgamma(x);
+void test__std__isblank__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::isblank(arg1) > 10) || (std::isblank(arg1) < 100)) {}
 }
 
-void test__lgammaf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = lgammaf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__isblank__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isblank(x);
 }
 
-void test__lgammaf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  lgammaf(arg1);
+void test__iswblank__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = iswblank(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lgammaf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((lgammaf(arg1) > 10) || (lgammaf(arg1) < 100)) {}
+void test__iswblank__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    iswblank(arg1);
 }
 
-void test__lgammaf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = lgammaf(p);
-  // cppcheck-suppress memleak
+void test__iswblank__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((iswblank(arg1) > 10) || (iswblank(arg1) < 100)) {}
 }
 
-void test__lgammaf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = lgammaf(x);
+void test__iswblank__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = iswblank(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__lgammaf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::lgammaf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__iswblank__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = iswblank(x);
 }
 
-void test__std__lgammaf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::lgammaf(arg1);
+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__lgammaf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::lgammaf(arg1) > 10) || (std::lgammaf(arg1) < 100)) {}
+void test__std__iswblank__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::iswblank(arg1);
 }
 
-void test__std__lgammaf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::lgammaf(x);
+void test__std__iswblank__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::iswblank(arg1) > 10) || (std::iswblank(arg1) < 100)) {}
 }
 
-void test__lgammal__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = lgammal(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__iswblank__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::iswblank(x);
 }
 
-void test__lgammal__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  lgammal(arg1);
+void test__iscntrl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = iscntrl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lgammal__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((lgammal(arg1) > 10) || (lgammal(arg1) < 100)) {}
+void test__iscntrl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    iscntrl(arg1);
 }
 
-void test__lgammal__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = lgammal(p);
-  // cppcheck-suppress memleak
+void test__iscntrl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((iscntrl(arg1) > 10) || (iscntrl(arg1) < 100)) {}
 }
 
-void test__lgammal__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = lgammal(x);
+void test__iscntrl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = iscntrl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__lgammal__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::lgammal(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__iscntrl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = iscntrl(x);
 }
 
-void test__std__lgammal__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::lgammal(arg1);
+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__lgammal__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::lgammal(arg1) > 10) || (std::lgammal(arg1) < 100)) {}
+void test__std__iscntrl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::iscntrl(arg1);
 }
 
-void test__std__lgammal__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::lgammal(x);
+void test__std__iscntrl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::iscntrl(arg1) > 10) || (std::iscntrl(arg1) < 100)) {}
 }
 
-void test__rint__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = rint(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__iscntrl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::iscntrl(x);
 }
 
-void test__rint__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  rint(arg1);
+void test__iswcntrl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = iswcntrl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__rint__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((rint(arg1) > 10) || (rint(arg1) < 100)) {}
+void test__iswcntrl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    iswcntrl(arg1);
 }
 
-void test__rint__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = rint(p);
-  // cppcheck-suppress memleak
+void test__iswcntrl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((iswcntrl(arg1) > 10) || (iswcntrl(arg1) < 100)) {}
 }
 
-void test__rint__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = rint(x);
+void test__iswcntrl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = iswcntrl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__rint__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::rint(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__iswcntrl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = iswcntrl(x);
 }
 
-void test__std__rint__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::rint(arg1);
+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__rint__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::rint(arg1) > 10) || (std::rint(arg1) < 100)) {}
+void test__std__iswcntrl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::iswcntrl(arg1);
 }
 
-void test__std__rint__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::rint(x);
+void test__std__iswcntrl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::iswcntrl(arg1) > 10) || (std::iswcntrl(arg1) < 100)) {}
 }
 
-void test__rintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = rintf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__iswcntrl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::iswcntrl(x);
 }
 
-void test__rintf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  rintf(arg1);
+void test__iswctype__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = iswctype(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__rintf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((rintf(arg1) > 10) || (rintf(arg1) < 100)) {}
+void test__iswctype__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    iswctype(arg1, arg2);
 }
 
-void test__rintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = rintf(p);
-  // cppcheck-suppress memleak
+void test__iswctype__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((iswctype(arg1, arg2) > 10) || (iswctype(arg1, arg2) < 100)) {}
 }
 
-void test__rintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = rintf(x);
+void test__iswctype__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = iswctype(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__rintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::rintf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__iswctype__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = iswctype(x, arg2);
 }
 
-void test__std__rintf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::rintf(arg1);
+void test__iswctype__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = iswctype(arg1, x);
 }
 
-void test__std__rintf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::rintf(arg1) > 10) || (std::rintf(arg1) < 100)) {}
+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__rintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::rintf(x);
+void test__std__iswctype__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::iswctype(arg1, arg2);
 }
 
-void test__rintl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = rintl(arg1); }
-  // 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__rintl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  rintl(arg1);
+void test__std__iswctype__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::iswctype(x, arg2);
 }
 
-void test__rintl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((rintl(arg1) > 10) || (rintl(arg1) < 100)) {}
+void test__std__iswctype__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::iswctype(arg1, x);
 }
 
-void test__rintl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = rintl(p);
-  // cppcheck-suppress memleak
+void test__isdigit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = isdigit(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__rintl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = rintl(x);
+void test__isdigit__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isdigit(arg1);
 }
 
-void test__std__rintl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::rintl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__isdigit__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isdigit(arg1) > 10) || (isdigit(arg1) < 100)) {}
 }
 
-void test__std__rintl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::rintl(arg1);
+void test__isdigit__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isdigit(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__rintl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::rintl(arg1) > 10) || (std::rintl(arg1) < 100)) {}
+void test__isdigit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isdigit(x);
 }
 
-void test__std__rintl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::rintl(x);
+void test__std__isdigit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::isdigit(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lrint__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = lrint(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__isdigit__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isdigit(arg1);
 }
 
-void test__lrint__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  lrint(arg1);
+void test__std__isdigit__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::isdigit(arg1) > 10) || (std::isdigit(arg1) < 100)) {}
 }
 
-void test__lrint__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((lrint(arg1) > 10) || (lrint(arg1) < 100)) {}
+void test__std__isdigit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isdigit(x);
 }
 
-void test__lrint__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = lrint(p);
-  // cppcheck-suppress memleak
+void test__iswdigit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = iswdigit(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lrint__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = lrint(x);
+void test__iswdigit__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    iswdigit(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__iswdigit__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((iswdigit(arg1) > 10) || (iswdigit(arg1) < 100)) {}
 }
 
-void test__std__lrint__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::lrint(arg1);
+void test__iswdigit__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = iswdigit(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__iswdigit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = iswdigit(x);
 }
 
-void test__std__lrint__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::lrint(x);
+void test__std__iswdigit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::iswdigit(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lrintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = lrintf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__iswdigit__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::iswdigit(arg1);
 }
 
-void test__lrintf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  lrintf(arg1);
+void test__std__iswdigit__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::iswdigit(arg1) > 10) || (std::iswdigit(arg1) < 100)) {}
 }
 
-void test__lrintf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((lrintf(arg1) > 10) || (lrintf(arg1) < 100)) {}
+void test__std__iswdigit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::iswdigit(x);
 }
 
-void test__lrintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = lrintf(p);
-  // cppcheck-suppress memleak
+void test__isgraph__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = isgraph(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lrintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = lrintf(x);
+void test__isgraph__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isgraph(arg1);
 }
 
-void test__std__lrintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::lrintf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__isgraph__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isgraph(arg1) > 10) || (isgraph(arg1) < 100)) {}
 }
 
-void test__std__lrintf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::lrintf(arg1);
+void test__isgraph__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isgraph(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__lrintf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::lrintf(arg1) > 10) || (std::lrintf(arg1) < 100)) {}
+void test__isgraph__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isgraph(x);
 }
 
-void test__std__lrintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::lrintf(x);
+void test__std__isgraph__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::isgraph(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lrintl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = lrintl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__isgraph__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isgraph(arg1);
 }
 
-void test__lrintl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  lrintl(arg1);
+void test__std__isgraph__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::isgraph(arg1) > 10) || (std::isgraph(arg1) < 100)) {}
 }
 
-void test__lrintl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((lrintl(arg1) > 10) || (lrintl(arg1) < 100)) {}
+void test__std__isgraph__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isgraph(x);
 }
 
-void test__lrintl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = lrintl(p);
-  // cppcheck-suppress memleak
+void test__iswgraph__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = iswgraph(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lrintl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = lrintl(x);
+void test__iswgraph__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    iswgraph(arg1);
 }
 
-void test__std__lrintl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::lrintl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__iswgraph__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((iswgraph(arg1) > 10) || (iswgraph(arg1) < 100)) {}
 }
 
-void test__std__lrintl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::lrintl(arg1);
+void test__iswgraph__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = iswgraph(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__lrintl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::lrintl(arg1) > 10) || (std::lrintl(arg1) < 100)) {}
+void test__iswgraph__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = iswgraph(x);
 }
 
-void test__std__lrintl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::lrintl(x);
+void test__std__iswgraph__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::iswgraph(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__llrint__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = llrint(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__iswgraph__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::iswgraph(arg1);
 }
 
-void test__llrint__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  llrint(arg1);
+void test__std__iswgraph__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::iswgraph(arg1) > 10) || (std::iswgraph(arg1) < 100)) {}
 }
 
-void test__llrint__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((llrint(arg1) > 10) || (llrint(arg1) < 100)) {}
+void test__std__iswgraph__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::iswgraph(x);
 }
 
-void test__llrint__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = llrint(p);
-  // cppcheck-suppress memleak
+void test__islower__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = islower(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__llrint__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = llrint(x);
+void test__islower__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    islower(arg1);
 }
 
-void test__std__llrint__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::llrint(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__islower__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((islower(arg1) > 10) || (islower(arg1) < 100)) {}
 }
 
-void test__std__llrint__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::llrint(arg1);
+void test__islower__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = islower(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__llrint__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::llrint(arg1) > 10) || (std::llrint(arg1) < 100)) {}
+void test__islower__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = islower(x);
 }
 
-void test__std__llrint__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::llrint(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__llrintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = llrintf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__islower__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::islower(arg1);
 }
 
-void test__llrintf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  llrintf(arg1);
+void test__std__islower__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::islower(arg1) > 10) || (std::islower(arg1) < 100)) {}
 }
 
-void test__llrintf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((llrintf(arg1) > 10) || (llrintf(arg1) < 100)) {}
+void test__std__islower__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::islower(x);
 }
 
-void test__llrintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = llrintf(p);
-  // cppcheck-suppress memleak
+void test__iswlower__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = iswlower(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__llrintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = llrintf(x);
+void test__iswlower__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    iswlower(arg1);
 }
 
-void test__std__llrintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::llrintf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__iswlower__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((iswlower(arg1) > 10) || (iswlower(arg1) < 100)) {}
 }
 
-void test__std__llrintf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::llrintf(arg1);
+void test__iswlower__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = iswlower(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__llrintf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::llrintf(arg1) > 10) || (std::llrintf(arg1) < 100)) {}
+void test__iswlower__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = iswlower(x);
 }
 
-void test__std__llrintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::llrintf(x);
+void test__std__iswlower__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::iswlower(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__llrintl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = llrintl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__iswlower__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::iswlower(arg1);
 }
 
-void test__llrintl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  llrintl(arg1);
+void test__std__iswlower__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::iswlower(arg1) > 10) || (std::iswlower(arg1) < 100)) {}
 }
 
-void test__llrintl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((llrintl(arg1) > 10) || (llrintl(arg1) < 100)) {}
+void test__std__iswlower__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::iswlower(x);
 }
 
-void test__llrintl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = llrintl(p);
-  // cppcheck-suppress memleak
+void test__isprint__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = isprint(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__llrintl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = llrintl(x);
+void test__isprint__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isprint(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__isprint__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isprint(arg1) > 10) || (isprint(arg1) < 100)) {}
 }
 
-void test__std__llrintl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::llrintl(arg1);
+void test__isprint__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isprint(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__llrintl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::llrintl(arg1) > 10) || (std::llrintl(arg1) < 100)) {}
+void test__isprint__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isprint(x);
 }
 
-void test__std__llrintl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::llrintl(x);
+void test__std__isprint__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::isprint(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__llround__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = llround(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__isprint__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isprint(arg1);
 }
 
-void test__llround__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  llround(arg1);
+void test__std__isprint__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::isprint(arg1) > 10) || (std::isprint(arg1) < 100)) {}
 }
 
-void test__llround__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((llround(arg1) > 10) || (llround(arg1) < 100)) {}
+void test__std__isprint__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isprint(x);
 }
 
-void test__llround__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = llround(p);
-  // cppcheck-suppress memleak
+void test__iswprint__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = iswprint(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__llround__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = llround(x);
+void test__iswprint__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    iswprint(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__iswprint__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((iswprint(arg1) > 10) || (iswprint(arg1) < 100)) {}
 }
 
-void test__std__llround__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::llround(arg1);
+void test__iswprint__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = iswprint(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__llround__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::llround(arg1) > 10) || (std::llround(arg1) < 100)) {}
+void test__iswprint__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = iswprint(x);
 }
 
-void test__std__llround__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::llround(x);
+void test__std__iswprint__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::iswprint(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__llroundf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = llroundf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__iswprint__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::iswprint(arg1);
 }
 
-void test__llroundf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  llroundf(arg1);
+void test__std__iswprint__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::iswprint(arg1) > 10) || (std::iswprint(arg1) < 100)) {}
 }
 
-void test__llroundf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((llroundf(arg1) > 10) || (llroundf(arg1) < 100)) {}
+void test__std__iswprint__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::iswprint(x);
 }
 
-void test__llroundf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = llroundf(p);
-  // cppcheck-suppress memleak
+void test__ispunct__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ispunct(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__llroundf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = llroundf(x);
+void test__ispunct__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ispunct(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__ispunct__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ispunct(arg1) > 10) || (ispunct(arg1) < 100)) {}
 }
 
-void test__std__llroundf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::llroundf(arg1);
+void test__ispunct__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ispunct(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__llroundf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::llroundf(arg1) > 10) || (std::llroundf(arg1) < 100)) {}
+void test__ispunct__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ispunct(x);
 }
 
-void test__std__llroundf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::llroundf(x);
+void test__std__ispunct__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::ispunct(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__llroundl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = llroundl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__ispunct__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::ispunct(arg1);
 }
 
-void test__llroundl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  llroundl(arg1);
+void test__std__ispunct__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::ispunct(arg1) > 10) || (std::ispunct(arg1) < 100)) {}
 }
 
-void test__llroundl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((llroundl(arg1) > 10) || (llroundl(arg1) < 100)) {}
+void test__std__ispunct__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::ispunct(x);
 }
 
-void test__llroundl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = llroundl(p);
-  // cppcheck-suppress memleak
+void test__iswpunct__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = iswpunct(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__llroundl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = llroundl(x);
+void test__iswpunct__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    iswpunct(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__iswpunct__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((iswpunct(arg1) > 10) || (iswpunct(arg1) < 100)) {}
 }
 
-void test__std__llroundl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::llroundl(arg1);
+void test__iswpunct__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = iswpunct(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__llroundl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::llroundl(arg1) > 10) || (std::llroundl(arg1) < 100)) {}
+void test__iswpunct__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = iswpunct(x);
 }
 
-void test__std__llroundl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::llroundl(x);
+void test__std__iswpunct__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::iswpunct(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lround__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = lround(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__iswpunct__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::iswpunct(arg1);
 }
 
-void test__lround__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  lround(arg1);
+void test__std__iswpunct__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::iswpunct(arg1) > 10) || (std::iswpunct(arg1) < 100)) {}
 }
 
-void test__lround__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((lround(arg1) > 10) || (lround(arg1) < 100)) {}
+void test__std__iswpunct__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::iswpunct(x);
 }
 
-void test__lround__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = lround(p);
-  // cppcheck-suppress memleak
+void test__isspace__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = isspace(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lround__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = lround(x);
+void test__isspace__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isspace(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__isspace__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isspace(arg1) > 10) || (isspace(arg1) < 100)) {}
 }
 
-void test__std__lround__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::lround(arg1);
+void test__isspace__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isspace(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__lround__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::lround(arg1) > 10) || (std::lround(arg1) < 100)) {}
+void test__isspace__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isspace(x);
 }
 
-void test__std__lround__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::lround(x);
+void test__std__isspace__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::isspace(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lroundf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = lroundf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__isspace__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isspace(arg1);
 }
 
-void test__lroundf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  lroundf(arg1);
+void test__std__isspace__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::isspace(arg1) > 10) || (std::isspace(arg1) < 100)) {}
 }
 
-void test__lroundf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((lroundf(arg1) > 10) || (lroundf(arg1) < 100)) {}
+void test__std__isspace__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isspace(x);
 }
 
-void test__lroundf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = lroundf(p);
-  // cppcheck-suppress memleak
+void test__iswspace__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = iswspace(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__lroundf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = lroundf(x);
+void test__iswspace__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    iswspace(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__iswspace__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((iswspace(arg1) > 10) || (iswspace(arg1) < 100)) {}
 }
 
-void test__std__lroundf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::lroundf(arg1);
+void test__iswspace__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = iswspace(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__lroundf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::lroundf(arg1) > 10) || (std::lroundf(arg1) < 100)) {}
+void test__iswspace__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = iswspace(x);
 }
 
-void test__std__lroundf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::lroundf(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__lroundl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = lroundl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__iswspace__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::iswspace(arg1);
 }
 
-void test__lroundl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  lroundl(arg1);
+void test__std__iswspace__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::iswspace(arg1) > 10) || (std::iswspace(arg1) < 100)) {}
 }
 
-void test__lroundl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((lroundl(arg1) > 10) || (lroundl(arg1) < 100)) {}
+void test__std__iswspace__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::iswspace(x);
 }
 
-void test__lroundl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = lroundl(p);
-  // 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__lroundl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = lroundl(x);
+void test__isupper__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isupper(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__isupper__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isupper(arg1) > 10) || (isupper(arg1) < 100)) {}
 }
 
-void test__std__lroundl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::lroundl(arg1);
+void test__isupper__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isupper(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__lroundl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::lroundl(arg1) > 10) || (std::lroundl(arg1) < 100)) {}
+void test__isupper__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isupper(x);
 }
 
-void test__std__lroundl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::lroundl(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__rand__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = rand(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__isupper__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isupper(arg1);
 }
 
-void test__rand__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  rand();
+void test__std__isupper__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::isupper(arg1) > 10) || (std::isupper(arg1) < 100)) {}
 }
 
-void test__rand__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = rand();
-  // cppcheck-suppress memleak
+void test__std__isupper__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isupper(x);
 }
 
-void test__srand__noreturn() {
-  int x = 1;
-  if (cond) { x=100; srand(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__iswupper__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = iswupper(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__srand__leakignore() {
-  char *p = malloc(10); *p=0;
-  srand(p);
-  // cppcheck-suppress memleak
+void test__iswupper__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    iswupper(arg1);
 }
 
-void test__srand__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  srand(x);
+void test__iswupper__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((iswupper(arg1) > 10) || (iswupper(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__iswupper__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = iswupper(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__srand__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::srand(x);
+void test__iswupper__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = iswupper(x);
 }
 
-void test__ldiv__noreturn() {
-  int x = 1;
-  if (cond) { x=100; ldiv(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__iswupper__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::iswupper(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ldiv__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ldiv(arg1, arg2) > 10) || (ldiv(arg1, arg2) < 100)) {}
+void test__std__iswupper__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::iswupper(arg1);
 }
 
-void test__ldiv__leakignore() {
-  char *p = malloc(10); *p=0;
-  ldiv(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__iswupper__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::iswupper(arg1) > 10) || (std::iswupper(arg1) < 100)) {}
 }
 
-void test__ldiv__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ldiv(x, arg2);
+void test__std__iswupper__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::iswupper(x);
 }
 
-void test__ldiv__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ldiv(arg1, x);
+void test__isxdigit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = isxdigit(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__ldiv__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::ldiv(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__isxdigit__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isxdigit(arg1);
 }
 
-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__isxdigit__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isxdigit(arg1) > 10) || (isxdigit(arg1) < 100)) {}
 }
 
-void test__std__ldiv__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::ldiv(x, arg2);
+void test__isxdigit__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isxdigit(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__ldiv__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::ldiv(arg1, x);
+void test__isxdigit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isxdigit(x);
 }
 
-void test__lldiv__noreturn() {
-  int x = 1;
-  if (cond) { x=100; lldiv(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__isxdigit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::isxdigit(arg1);
+    }
+    // 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__isxdigit__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isxdigit(arg1);
 }
 
-void test__lldiv__leakignore() {
-  char *p = malloc(10); *p=0;
-  lldiv(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__isxdigit__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::isxdigit(arg1) > 10) || (std::isxdigit(arg1) < 100)) {}
 }
 
-void test__lldiv__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  lldiv(x, arg2);
+void test__std__isxdigit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isxdigit(x);
 }
 
-void test__lldiv__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  lldiv(arg1, x);
+void test__iswxdigit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = iswxdigit(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__iswxdigit__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    iswxdigit(arg1);
 }
 
-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__iswxdigit__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((iswxdigit(arg1) > 10) || (iswxdigit(arg1) < 100)) {}
 }
 
-void test__std__lldiv__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::lldiv(x, arg2);
+void test__iswxdigit__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = iswxdigit(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__lldiv__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::lldiv(arg1, x);
+void test__iswxdigit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = iswxdigit(x);
 }
 
-void test__localtime__noreturn() {
-  int x = 1;
-  if (cond) { x=100; localtime(arg1); }
-  // 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__localtime__leakignore() {
-  char *p = malloc(10); *p=0;
-  localtime(p);
-  // cppcheck-suppress memleak
+void test__std__iswxdigit__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::iswxdigit(arg1);
 }
 
-void test__localtime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  localtime(p);
+void test__std__iswxdigit__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::iswxdigit(arg1) > 10) || (std::iswxdigit(arg1) < 100)) {}
 }
 
-void test__localtime__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  localtime(x);
+void test__std__iswxdigit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::iswxdigit(x);
 }
 
-void test__std__localtime__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::localtime(arg1); }
-  // 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__localtime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::localtime(p);
+void test__towctrans__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    towctrans(arg1, arg2);
 }
 
-void test__std__localtime__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::localtime(x);
+void test__towctrans__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((towctrans(arg1, arg2) > 10) || (towctrans(arg1, arg2) < 100)) {}
 }
 
-void test__localtime_s__noreturn() {
-  int x = 1;
-  if (cond) { x=100; localtime_s(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__towctrans__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = towctrans(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__localtime_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  localtime_s(p, arg2);
-  // cppcheck-suppress memleak
+void test__towctrans__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = towctrans(x, arg2);
 }
 
-void test__localtime_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  localtime_s(p, arg2);
+void test__towctrans__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = towctrans(arg1, x);
 }
 
-void test__localtime_s__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  localtime_s(arg1, p);
+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__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__towctrans__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::towctrans(arg1, arg2);
 }
 
-void test__std__localtime_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::localtime_s(p, arg2);
+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__std__localtime_s__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::localtime_s(arg1, p);
+void test__std__towctrans__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::towctrans(x, arg2);
 }
 
-void test__log__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = log(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__towctrans__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::towctrans(arg1, x);
 }
 
-void test__log__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  log(arg1);
+void test__towlower__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = towlower(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__log__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = log(p);
-  // cppcheck-suppress memleak
+void test__towlower__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    towlower(arg1);
 }
 
-void test__log__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = log(x);
+void test__towlower__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((towlower(arg1) > 10) || (towlower(arg1) < 100)) {}
 }
 
-void test__std__log__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::log(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__towlower__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = towlower(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__log__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::log(arg1);
+void test__towlower__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = towlower(x);
 }
 
-void test__std__log__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::log(x);
+void test__std__towlower__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::towlower(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__towlower__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::towlower(arg1);
 }
 
-void test__logf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  logf(arg1);
+void test__std__towlower__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::towlower(arg1) > 10) || (std::towlower(arg1) < 100)) {}
 }
 
-void test__logf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = logf(p);
-  // cppcheck-suppress memleak
+void test__std__towlower__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::towlower(x);
 }
 
-void test__logf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = logf(x);
+void test__towupper__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = towupper(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__towupper__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    towupper(arg1);
 }
 
-void test__std__logf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::logf(arg1);
+void test__towupper__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((towupper(arg1) > 10) || (towupper(arg1) < 100)) {}
 }
 
-void test__std__logf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::logf(x);
+void test__towupper__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = towupper(p);
+    // cppcheck-suppress memleak
 }
 
-void test__logl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = logl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__towupper__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = towupper(x);
 }
 
-void test__logl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  logl(arg1);
+void test__std__towupper__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::towupper(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__std__towupper__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::towupper(arg1);
 }
 
-void test__logl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = logl(x);
+void test__std__towupper__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::towupper(arg1) > 10) || (std::towupper(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__std__towupper__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::towupper(x);
 }
 
-void test__std__logl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::logl(arg1);
+void test__wctrans__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wctrans(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__logl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::logl(x);
+void test__wctrans__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wctrans(arg1);
 }
 
-void test__clog__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = clog(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wctrans__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((wctrans(arg1) > 10) || (wctrans(arg1) < 100)) {}
 }
 
-void test__clog__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  clog(arg1);
+void test__wctrans__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wctrans(p);
+    // cppcheck-suppress memleak
 }
 
-void test__clog__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = clog(p);
-  // cppcheck-suppress memleak
+void test__wctrans__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wctrans(NULL);
 }
 
-void test__clog__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = clog(x);
+void test__wctrans__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wctrans(x);
 }
 
-void test__clogf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = clogf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__clogf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  clogf(arg1);
+void test__std__wctrans__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wctrans(arg1);
 }
 
-void test__clogf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = clogf(p);
-  // cppcheck-suppress memleak
+void test__std__wctrans__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::wctrans(arg1) > 10) || (std::wctrans(arg1) < 100)) {}
 }
 
-void test__clogf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = clogf(x);
+void test__std__wctrans__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wctrans(NULL);
 }
 
-void test__clogl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = clogl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wctrans__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wctrans(x);
 }
 
-void test__clogl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  clogl(arg1);
+void test__wctype__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wctype(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__clogl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = clogl(p);
-  // cppcheck-suppress memleak
+void test__wctype__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wctype(arg1);
 }
 
-void test__clogl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = clogl(x);
+void test__wctype__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((wctype(arg1) > 10) || (wctype(arg1) < 100)) {}
 }
 
-void test__conj__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = conj(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__conj__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  conj(arg1);
+void test__wctype__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wctype(NULL);
 }
 
-void test__conj__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = conj(p);
-  // cppcheck-suppress memleak
+void test__wctype__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wctype(x);
 }
 
-void test__conj__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = conj(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__conjf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = conjf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wctype__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wctype(arg1);
 }
 
-void test__conjf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  conjf(arg1);
+void test__std__wctype__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::wctype(arg1) > 10) || (std::wctype(arg1) < 100)) {}
 }
 
-void test__conjf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = conjf(p);
-  // cppcheck-suppress memleak
+void test__std__wctype__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wctype(NULL);
 }
 
-void test__conjf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = conjf(x);
+void test__std__wctype__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wctype(x);
 }
 
-void test__conjl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = conjl(arg1); }
-  // 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__conjl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  conjl(arg1);
+void test__cabs__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cabs(arg1);
 }
 
-void test__conjl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = conjl(p);
-  // cppcheck-suppress memleak
+void test__cabs__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cabs(arg1) > 10) || (cabs(arg1) < 100)) {}
 }
 
-void test__conjl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = conjl(x);
+void test__cabs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cabs(p);
+    // cppcheck-suppress memleak
 }
 
-void test__fpclassify__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = fpclassify(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cabs__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cabs(x);
 }
 
-void test__fpclassify__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  fpclassify(arg1);
+void test__cabsf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cabsf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__fpclassify__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((fpclassify(arg1) > 10) || (fpclassify(arg1) < 100)) {}
+void test__cabsf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cabsf(arg1);
 }
 
-void test__fpclassify__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = fpclassify(p);
-  // cppcheck-suppress memleak
+void test__cabsf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cabsf(arg1) > 10) || (cabsf(arg1) < 100)) {}
 }
 
-void test__fpclassify__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = fpclassify(x);
+void test__cabsf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cabsf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__fpclassify__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::fpclassify(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cabsf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cabsf(x);
 }
 
-void test__std__fpclassify__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::fpclassify(arg1);
+void test__cabsl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cabsl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fpclassify__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::fpclassify(arg1) > 10) || (std::fpclassify(arg1) < 100)) {}
+void test__cabsl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cabsl(arg1);
 }
 
-void test__std__fpclassify__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::fpclassify(x);
+void test__cabsl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cabsl(arg1) > 10) || (cabsl(arg1) < 100)) {}
 }
 
-void test__isfinite__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isfinite(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cabsl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cabsl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__isfinite__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isfinite(arg1);
+void test__cabsl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cabsl(x);
 }
 
-void test__isfinite__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isfinite(arg1) > 10) || (isfinite(arg1) < 100)) {}
+void test__cacos__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cacos(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__isfinite__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isfinite(p);
-  // cppcheck-suppress memleak
+void test__cacos__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cacos(arg1);
 }
 
-void test__isfinite__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isfinite(x);
+void test__cacos__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cacos(arg1) > 10) || (cacos(arg1) < 100)) {}
 }
 
-void test__std__isfinite__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::isfinite(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__std__isfinite__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isfinite(arg1);
+void test__cacos__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cacos(x);
 }
 
-void test__std__isfinite__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::isfinite(arg1) > 10) || (std::isfinite(arg1) < 100)) {}
+void test__cacosf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cacosf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__isfinite__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isfinite(x);
+void test__cacosf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cacosf(arg1);
 }
 
-void test__isgreater__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isgreater(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cacosf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cacosf(arg1) > 10) || (cacosf(arg1) < 100)) {}
 }
 
-void test__isgreater__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isgreater(arg1, arg2);
+void test__cacosf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cacosf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__isgreater__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isgreater(arg1, arg2) > 10) || (isgreater(arg1, arg2) < 100)) {}
+void test__cacosf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cacosf(x);
 }
 
-void test__isgreater__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isgreater(p, arg2);
-  // cppcheck-suppress memleak
+void test__cacosl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cacosl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__isgreater__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isgreater(x, arg2);
+void test__cacosl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cacosl(arg1);
 }
 
-void test__isgreater__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isgreater(arg1, x);
+void test__cacosl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cacosl(arg1) > 10) || (cacosl(arg1) < 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__cacosl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cacosl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__isgreater__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isgreater(arg1, arg2);
+void test__cacosl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cacosl(x);
 }
 
-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__cacosh__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cacosh(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__isgreater__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isgreater(x, arg2);
+void test__cacosh__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cacosh(arg1);
 }
 
-void test__std__isgreater__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isgreater(arg1, x);
+void test__cacosh__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cacosh(arg1) > 10) || (cacosh(arg1) < 100)) {}
 }
 
-void test__isgreaterequal__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isgreaterequal(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cacosh__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cacosh(p);
+    // cppcheck-suppress memleak
 }
 
-void test__isgreaterequal__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isgreaterequal(arg1, arg2);
+void test__cacosh__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cacosh(x);
 }
 
-void test__isgreaterequal__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isgreaterequal(arg1, arg2) > 10) || (isgreaterequal(arg1, arg2) < 100)) {}
+void test__cacoshf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cacoshf(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__cacoshf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cacoshf(arg1);
 }
 
-void test__isgreaterequal__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isgreaterequal(x, arg2);
+void test__cacoshf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cacoshf(arg1) > 10) || (cacoshf(arg1) < 100)) {}
 }
 
-void test__isgreaterequal__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isgreaterequal(arg1, x);
+void test__cacoshf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cacoshf(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__cacoshf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cacoshf(x);
 }
 
-void test__std__isgreaterequal__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isgreaterequal(arg1, arg2);
+void test__cacoshl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cacoshl(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__cacoshl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cacoshl(arg1);
 }
 
-void test__std__isgreaterequal__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isgreaterequal(x, arg2);
+void test__cacoshl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cacoshl(arg1) > 10) || (cacoshl(arg1) < 100)) {}
 }
 
-void test__std__isgreaterequal__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isgreaterequal(arg1, x);
+void test__cacoshl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cacoshl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__isinf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isinf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cacoshl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cacoshl(x);
 }
 
-void test__isinf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isinf(arg1);
+void test__labs__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = labs(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__isinf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isinf(arg1) > 10) || (isinf(arg1) < 100)) {}
+void test__labs__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    labs(arg1);
 }
 
-void test__isinf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isinf(p);
-  // cppcheck-suppress memleak
+void test__labs__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((labs(arg1) > 10) || (labs(arg1) < 100)) {}
 }
 
-void test__isinf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isinf(x);
+void test__labs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = labs(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__isinf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::isinf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__labs__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = labs(x);
 }
 
-void test__std__isinf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isinf(arg1);
+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__isinf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::isinf(arg1) > 10) || (std::isinf(arg1) < 100)) {}
+void test__std__labs__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::labs(arg1);
 }
 
-void test__std__isinf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isinf(x);
+void test__std__labs__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::labs(arg1) > 10) || (std::labs(arg1) < 100)) {}
 }
 
-void test__logb__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = logb(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__labs__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::labs(x);
 }
 
-void test__logb__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  logb(arg1);
+void test__llabs__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = llabs(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__logb__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((logb(arg1) > 10) || (logb(arg1) < 100)) {}
+void test__llabs__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    llabs(arg1);
 }
 
-void test__logb__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = logb(p);
-  // cppcheck-suppress memleak
+void test__llabs__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((llabs(arg1) > 10) || (llabs(arg1) < 100)) {}
 }
 
-void test__logb__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = logb(x);
+void test__llabs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = llabs(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__logb__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::logb(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__llabs__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = llabs(x);
 }
 
-void test__std__logb__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::logb(arg1);
+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__logb__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::logb(arg1) > 10) || (std::logb(arg1) < 100)) {}
+void test__std__llabs__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::llabs(arg1);
 }
 
-void test__std__logb__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::logb(x);
+void test__std__llabs__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::llabs(arg1) > 10) || (std::llabs(arg1) < 100)) {}
 }
 
-void test__logbf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = logbf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__llabs__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::llabs(x);
 }
 
-void test__logbf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  logbf(arg1);
+void test__ldexp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ldexp(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__logbf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((logbf(arg1) > 10) || (logbf(arg1) < 100)) {}
+void test__ldexp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ldexp(arg1, arg2);
 }
 
-void test__logbf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = logbf(p);
-  // cppcheck-suppress memleak
+void test__ldexp__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ldexp(arg1, arg2) > 10) || (ldexp(arg1, arg2) < 100)) {}
 }
 
-void test__logbf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = logbf(x);
+void test__ldexp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ldexp(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__logbf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::logbf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ldexp__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ldexp(x, arg2);
 }
 
-void test__std__logbf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::logbf(arg1);
+void test__ldexp__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ldexp(arg1, x);
 }
 
-void test__std__logbf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::logbf(arg1) > 10) || (std::logbf(arg1) < 100)) {}
+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__logbf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::logbf(x);
+void test__std__ldexp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::ldexp(arg1, arg2);
 }
 
-void test__logbl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = logbl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__logbl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  logbl(arg1);
+void test__std__ldexp__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::ldexp(x, arg2);
 }
 
-void test__logbl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((logbl(arg1) > 10) || (logbl(arg1) < 100)) {}
+void test__std__ldexp__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::ldexp(arg1, x);
 }
 
-void test__logbl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = logbl(p);
-  // cppcheck-suppress memleak
+void test__ldexpf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ldexpf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__logbl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = logbl(x);
+void test__ldexpf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ldexpf(arg1, 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__ldexpf__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ldexpf(arg1, arg2) > 10) || (ldexpf(arg1, arg2) < 100)) {}
 }
 
-void test__std__logbl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::logbl(arg1);
+void test__ldexpf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ldexpf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__logbl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::logbl(arg1) > 10) || (std::logbl(arg1) < 100)) {}
+void test__ldexpf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ldexpf(x, arg2);
 }
 
-void test__std__logbl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::logbl(x);
+void test__ldexpf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ldexpf(arg1, x);
 }
 
-void test__isless__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isless(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__isless__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isless(arg1, arg2);
+void test__std__ldexpf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::ldexpf(arg1, arg2);
 }
 
-void test__isless__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isless(arg1, arg2) > 10) || (isless(arg1, arg2) < 100)) {}
+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__isless__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isless(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__ldexpf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::ldexpf(x, arg2);
 }
 
-void test__isless__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isless(x, arg2);
+void test__std__ldexpf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::ldexpf(arg1, x);
 }
 
-void test__isless__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isless(arg1, 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__isless__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::isless(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ldexpl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ldexpl(arg1, arg2);
 }
 
-void test__std__isless__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isless(arg1, arg2);
+void test__ldexpl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ldexpl(arg1, arg2) > 10) || (ldexpl(arg1, arg2) < 100)) {}
 }
 
-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__ldexpl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ldexpl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__isless__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isless(x, arg2);
+void test__ldexpl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ldexpl(x, arg2);
 }
 
-void test__std__isless__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isless(arg1, x);
+void test__ldexpl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ldexpl(arg1, 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__ldexpl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::ldexpl(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__islessequal__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  islessequal(arg1, arg2);
+void test__std__ldexpl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::ldexpl(arg1, arg2);
 }
 
-void test__islessequal__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((islessequal(arg1, arg2) > 10) || (islessequal(arg1, arg2) < 100)) {}
+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__islessequal__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = islessequal(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__ldexpl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::ldexpl(x, arg2);
 }
 
-void test__islessequal__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = islessequal(x, arg2);
+void test__std__ldexpl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::ldexpl(arg1, x);
 }
 
-void test__islessequal__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = islessequal(arg1, x);
+void test__lgamma__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = lgamma(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__lgamma__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    lgamma(arg1);
 }
 
-void test__std__islessequal__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::islessequal(arg1, arg2);
+void test__lgamma__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((lgamma(arg1) > 10) || (lgamma(arg1) < 100)) {}
 }
 
-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__lgamma__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = lgamma(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__islessequal__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::islessequal(x, arg2);
+void test__lgamma__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = lgamma(x);
 }
 
-void test__std__islessequal__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::islessequal(arg1, 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__islessgreater__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = islessgreater(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__lgamma__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::lgamma(arg1);
 }
 
-void test__islessgreater__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  islessgreater(arg1, arg2);
+void test__std__lgamma__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::lgamma(arg1) > 10) || (std::lgamma(arg1) < 100)) {}
 }
 
-void test__islessgreater__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((islessgreater(arg1, arg2) > 10) || (islessgreater(arg1, arg2) < 100)) {}
+void test__std__lgamma__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::lgamma(x);
 }
 
-void test__islessgreater__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = islessgreater(p, arg2);
-  // cppcheck-suppress memleak
+void test__lgammaf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = lgammaf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__islessgreater__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = islessgreater(x, arg2);
+void test__lgammaf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    lgammaf(arg1);
 }
 
-void test__islessgreater__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = islessgreater(arg1, x);
+void test__lgammaf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((lgammaf(arg1) > 10) || (lgammaf(arg1) < 100)) {}
 }
 
-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__lgammaf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = lgammaf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__islessgreater__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::islessgreater(arg1, arg2);
+void test__lgammaf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = lgammaf(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__lgammaf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::lgammaf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__islessgreater__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::islessgreater(x, arg2);
+void test__std__lgammaf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::lgammaf(arg1);
 }
 
-void test__std__islessgreater__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::islessgreater(arg1, x);
+void test__std__lgammaf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::lgammaf(arg1) > 10) || (std::lgammaf(arg1) < 100)) {}
 }
 
-void test__nan__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = nan(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__lgammaf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::lgammaf(x);
 }
 
-void test__nan__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  nan(arg1);
+void test__lgammal__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = lgammal(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__nan__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((nan(arg1) > 10) || (nan(arg1) < 100)) {}
+void test__lgammal__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    lgammal(arg1);
 }
 
-void test__nan__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = nan(p);
-  // cppcheck-suppress memleak
+void test__lgammal__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((lgammal(arg1) > 10) || (lgammal(arg1) < 100)) {}
 }
 
-void test__nan__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = nan(p);
+void test__lgammal__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = lgammal(p);
+    // cppcheck-suppress memleak
 }
 
-void test__nan__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = nan(x);
+void test__lgammal__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = lgammal(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__lgammal__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::lgammal(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__nan__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::nan(arg1);
+void test__std__lgammal__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::lgammal(arg1);
 }
 
-void test__std__nan__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::nan(arg1) > 10) || (std::nan(arg1) < 100)) {}
+void test__std__lgammal__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::lgammal(arg1) > 10) || (std::lgammal(arg1) < 100)) {}
 }
 
-void test__std__nan__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::nan(p);
+void test__std__lgammal__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::lgammal(x);
 }
 
-void test__std__nan__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::nan(x);
+void test__rint__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = rint(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__nanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = nanf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__rint__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    rint(arg1);
 }
 
-void test__nanf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  nanf(arg1);
+void test__rint__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((rint(arg1) > 10) || (rint(arg1) < 100)) {}
 }
 
-void test__nanf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((nanf(arg1) > 10) || (nanf(arg1) < 100)) {}
+void test__rint__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = rint(p);
+    // cppcheck-suppress memleak
 }
 
-void test__nanf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = nanf(p);
-  // cppcheck-suppress memleak
+void test__rint__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = rint(x);
 }
 
-void test__nanf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = nanf(p);
+void test__std__rint__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::rint(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__nanf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = nanf(x);
+void test__std__rint__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::rint(arg1);
 }
 
-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__rint__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::rint(arg1) > 10) || (std::rint(arg1) < 100)) {}
 }
 
-void test__std__nanf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::nanf(arg1);
+void test__std__rint__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::rint(x);
 }
 
-void test__std__nanf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::nanf(arg1) > 10) || (std::nanf(arg1) < 100)) {}
+void test__rintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = rintf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__nanf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::nanf(p);
+void test__rintf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    rintf(arg1);
 }
 
-void test__std__nanf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::nanf(x);
+void test__rintf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((rintf(arg1) > 10) || (rintf(arg1) < 100)) {}
 }
 
-void test__nanl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = nanl(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__nanl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  nanl(arg1);
+void test__rintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = rintf(x);
 }
 
-void test__nanl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((nanl(arg1) > 10) || (nanl(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__nanl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = nanl(p);
-  // cppcheck-suppress memleak
+void test__std__rintf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::rintf(arg1);
 }
 
-void test__nanl__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = nanl(p);
+void test__std__rintf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::rintf(arg1) > 10) || (std::rintf(arg1) < 100)) {}
 }
 
-void test__nanl__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = nanl(x);
+void test__std__rintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::rintf(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__rintl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = rintl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__nanl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::nanl(arg1);
+void test__rintl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    rintl(arg1);
 }
 
-void test__std__nanl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::nanl(arg1) > 10) || (std::nanl(arg1) < 100)) {}
+void test__rintl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((rintl(arg1) > 10) || (rintl(arg1) < 100)) {}
 }
 
-void test__std__nanl__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::nanl(p);
+void test__rintl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = rintl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__nanl__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::nanl(x);
+void test__rintl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = rintl(x);
 }
 
-void test__isnan__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isnan(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__rintl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::rintl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__isnan__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isnan(arg1);
+void test__std__rintl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::rintl(arg1);
 }
 
-void test__isnan__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isnan(arg1) > 10) || (isnan(arg1) < 100)) {}
+void test__std__rintl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::rintl(arg1) > 10) || (std::rintl(arg1) < 100)) {}
 }
 
-void test__isnan__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isnan(p);
-  // cppcheck-suppress memleak
+void test__std__rintl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::rintl(x);
 }
 
-void test__isnan__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isnan(x);
+void test__lrint__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = lrint(arg1);
+    }
+    // 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__lrint__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    lrint(arg1);
 }
 
-void test__std__isnan__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isnan(arg1);
+void test__lrint__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((lrint(arg1) > 10) || (lrint(arg1) < 100)) {}
 }
 
-void test__std__isnan__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::isnan(arg1) > 10) || (std::isnan(arg1) < 100)) {}
+void test__lrint__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = lrint(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__isnan__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isnan(x);
+void test__lrint__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = lrint(x);
 }
 
-void test__isnormal__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = isnormal(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__lrint__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::lrint(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__isnormal__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isnormal(arg1);
+void test__std__lrint__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::lrint(arg1);
 }
 
-void test__isnormal__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isnormal(arg1) > 10) || (isnormal(arg1) < 100)) {}
+void test__std__lrint__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::lrint(arg1) > 10) || (std::lrint(arg1) < 100)) {}
 }
 
-void test__isnormal__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isnormal(p);
-  // cppcheck-suppress memleak
+void test__std__lrint__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::lrint(x);
 }
 
-void test__isnormal__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isnormal(x);
+void test__lrintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = lrintf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__isnormal__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::isnormal(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__lrintf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    lrintf(arg1);
 }
 
-void test__std__isnormal__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isnormal(arg1);
+void test__lrintf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((lrintf(arg1) > 10) || (lrintf(arg1) < 100)) {}
 }
 
-void test__std__isnormal__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::isnormal(arg1) > 10) || (std::isnormal(arg1) < 100)) {}
+void test__lrintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = lrintf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__isnormal__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isnormal(x);
+void test__lrintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = lrintf(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__lrintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::lrintf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__isunordered__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  isunordered(arg1, arg2);
+void test__std__lrintf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::lrintf(arg1);
 }
 
-void test__isunordered__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((isunordered(arg1, arg2) > 10) || (isunordered(arg1, arg2) < 100)) {}
+void test__std__lrintf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::lrintf(arg1) > 10) || (std::lrintf(arg1) < 100)) {}
 }
 
-void test__isunordered__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = isunordered(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__lrintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::lrintf(x);
 }
 
-void test__isunordered__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isunordered(x, arg2);
+void test__lrintl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = lrintl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__isunordered__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = isunordered(arg1, x);
+void test__lrintl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    lrintl(arg1);
 }
 
-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__lrintl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((lrintl(arg1) > 10) || (lrintl(arg1) < 100)) {}
 }
 
-void test__std__isunordered__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::isunordered(arg1, arg2);
+void test__lrintl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = lrintl(p);
+    // cppcheck-suppress memleak
 }
 
-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__lrintl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = lrintl(x);
 }
 
-void test__std__isunordered__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isunordered(x, arg2);
+void test__std__lrintl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::lrintl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__isunordered__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::isunordered(arg1, x);
+void test__std__lrintl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::lrintl(arg1);
 }
 
-void test__ilogb__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ilogb(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__lrintl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::lrintl(arg1) > 10) || (std::lrintl(arg1) < 100)) {}
 }
 
-void test__ilogb__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ilogb(arg1);
+void test__std__lrintl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::lrintl(x);
 }
 
-void test__ilogb__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ilogb(arg1) > 10) || (ilogb(arg1) < 100)) {}
+void test__llrint__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = llrint(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ilogb__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ilogb(p);
-  // cppcheck-suppress memleak
+void test__llrint__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    llrint(arg1);
 }
 
-void test__ilogb__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ilogb(x);
+void test__llrint__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((llrint(arg1) > 10) || (llrint(arg1) < 100)) {}
 }
 
-void test__std__ilogb__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::ilogb(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__std__ilogb__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ilogb(arg1);
+void test__llrint__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = llrint(x);
 }
 
-void test__std__ilogb__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::ilogb(arg1) > 10) || (std::ilogb(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__std__ilogb__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::ilogb(x);
+void test__std__llrint__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::llrint(arg1);
 }
 
-void test__ilogbf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ilogbf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__llrint__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::llrint(arg1) > 10) || (std::llrint(arg1) < 100)) {}
 }
 
-void test__ilogbf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ilogbf(arg1);
+void test__std__llrint__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::llrint(x);
 }
 
-void test__ilogbf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ilogbf(arg1) > 10) || (ilogbf(arg1) < 100)) {}
+void test__llrintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = llrintf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ilogbf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ilogbf(p);
-  // cppcheck-suppress memleak
+void test__llrintf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    llrintf(arg1);
 }
 
-void test__ilogbf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ilogbf(x);
+void test__llrintf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((llrintf(arg1) > 10) || (llrintf(arg1) < 100)) {}
 }
 
-void test__std__ilogbf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::ilogbf(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__std__ilogbf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ilogbf(arg1);
+void test__llrintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = llrintf(x);
 }
 
-void test__std__ilogbf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::ilogbf(arg1) > 10) || (std::ilogbf(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__std__ilogbf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::ilogbf(x);
+void test__std__llrintf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::llrintf(arg1);
 }
 
-void test__ilogbl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = ilogbl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__llrintf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::llrintf(arg1) > 10) || (std::llrintf(arg1) < 100)) {}
 }
 
-void test__ilogbl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  ilogbl(arg1);
+void test__std__llrintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::llrintf(x);
 }
 
-void test__ilogbl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((ilogbl(arg1) > 10) || (ilogbl(arg1) < 100)) {}
+void test__llrintl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = llrintl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ilogbl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = ilogbl(p);
-  // cppcheck-suppress memleak
+void test__llrintl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    llrintl(arg1);
 }
 
-void test__ilogbl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = ilogbl(x);
+void test__llrintl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((llrintl(arg1) > 10) || (llrintl(arg1) < 100)) {}
 }
 
-void test__std__ilogbl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::ilogbl(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__std__ilogbl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ilogbl(arg1);
+void test__llrintl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = llrintl(x);
 }
 
-void test__std__ilogbl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::ilogbl(arg1) > 10) || (std::ilogbl(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__std__ilogbl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::ilogbl(x);
+void test__std__llrintl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::llrintl(arg1);
 }
 
-void test__log10__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = log10(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__llrintl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::llrintl(arg1) > 10) || (std::llrintl(arg1) < 100)) {}
 }
 
-void test__log10__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  log10(arg1);
+void test__std__llrintl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::llrintl(x);
 }
 
-void test__log10__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((log10(arg1) > 10) || (log10(arg1) < 100)) {}
+void test__llround__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = llround(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__log10__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = log10(p);
-  // cppcheck-suppress memleak
+void test__llround__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    llround(arg1);
 }
 
-void test__log10__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = log10(x);
+void test__llround__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((llround(arg1) > 10) || (llround(arg1) < 100)) {}
 }
 
-void test__std__log10__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::log10(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__std__log10__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::log10(arg1);
+void test__llround__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = llround(x);
 }
 
-void test__std__log10__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::log10(arg1) > 10) || (std::log10(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__std__log10__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::log10(x);
+void test__std__llround__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::llround(arg1);
 }
 
-void test__log10f__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = log10f(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__llround__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::llround(arg1) > 10) || (std::llround(arg1) < 100)) {}
 }
 
-void test__log10f__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  log10f(arg1);
+void test__std__llround__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::llround(x);
 }
 
-void test__log10f__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((log10f(arg1) > 10) || (log10f(arg1) < 100)) {}
+void test__llroundf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = llroundf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__log10f__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = log10f(p);
-  // cppcheck-suppress memleak
+void test__llroundf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    llroundf(arg1);
 }
 
-void test__log10f__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = log10f(x);
+void test__llroundf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((llroundf(arg1) > 10) || (llroundf(arg1) < 100)) {}
 }
 
-void test__std__log10f__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::log10f(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__std__log10f__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::log10f(arg1);
+void test__llroundf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = llroundf(x);
 }
 
-void test__std__log10f__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::log10f(arg1) > 10) || (std::log10f(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__std__log10f__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::log10f(x);
+void test__std__llroundf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::llroundf(arg1);
 }
 
-void test__log10l__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = log10l(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__llroundf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::llroundf(arg1) > 10) || (std::llroundf(arg1) < 100)) {}
 }
 
-void test__log10l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  log10l(arg1);
+void test__std__llroundf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::llroundf(x);
 }
 
-void test__log10l__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((log10l(arg1) > 10) || (log10l(arg1) < 100)) {}
+void test__llroundl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = llroundl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__log10l__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = log10l(p);
-  // cppcheck-suppress memleak
+void test__llroundl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    llroundl(arg1);
 }
 
-void test__log10l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = log10l(x);
+void test__llroundl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((llroundl(arg1) > 10) || (llroundl(arg1) < 100)) {}
 }
 
-void test__std__log10l__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::log10l(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__std__log10l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::log10l(arg1);
+void test__llroundl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = llroundl(x);
 }
 
-void test__std__log10l__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::log10l(arg1) > 10) || (std::log10l(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__std__log10l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::log10l(x);
+void test__std__llroundl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::llroundl(arg1);
 }
 
-void test__log1p__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = log1p(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__llroundl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::llroundl(arg1) > 10) || (std::llroundl(arg1) < 100)) {}
 }
 
-void test__log1p__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  log1p(arg1);
+void test__std__llroundl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::llroundl(x);
 }
 
-void test__log1p__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((log1p(arg1) > 10) || (log1p(arg1) < 100)) {}
+void test__lround__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = lround(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__log1p__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = log1p(p);
-  // cppcheck-suppress memleak
+void test__lround__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    lround(arg1);
 }
 
-void test__log1p__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = log1p(x);
+void test__lround__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((lround(arg1) > 10) || (lround(arg1) < 100)) {}
 }
 
-void test__std__log1p__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::log1p(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__std__log1p__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::log1p(arg1);
+void test__lround__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = lround(x);
 }
 
-void test__std__log1p__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::log1p(arg1) > 10) || (std::log1p(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__std__log1p__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::log1p(x);
+void test__std__lround__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::lround(arg1);
 }
 
-void test__log1pf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = log1pf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__lround__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::lround(arg1) > 10) || (std::lround(arg1) < 100)) {}
 }
 
-void test__log1pf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  log1pf(arg1);
+void test__std__lround__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::lround(x);
 }
 
-void test__log1pf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((log1pf(arg1) > 10) || (log1pf(arg1) < 100)) {}
+void test__lroundf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = lroundf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__log1pf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = log1pf(p);
-  // cppcheck-suppress memleak
+void test__lroundf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    lroundf(arg1);
 }
 
-void test__log1pf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = log1pf(x);
+void test__lroundf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((lroundf(arg1) > 10) || (lroundf(arg1) < 100)) {}
 }
 
-void test__std__log1pf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::log1pf(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__std__log1pf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::log1pf(arg1);
+void test__lroundf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = lroundf(x);
 }
 
-void test__std__log1pf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::log1pf(arg1) > 10) || (std::log1pf(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__std__log1pf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::log1pf(x);
+void test__std__lroundf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::lroundf(arg1);
 }
 
-void test__log1pl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = log1pl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__lroundf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::lroundf(arg1) > 10) || (std::lroundf(arg1) < 100)) {}
 }
 
-void test__log1pl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  log1pl(arg1);
+void test__std__lroundf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::lroundf(x);
 }
 
-void test__log1pl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((log1pl(arg1) > 10) || (log1pl(arg1) < 100)) {}
+void test__lroundl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = lroundl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__log1pl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = log1pl(p);
-  // cppcheck-suppress memleak
+void test__lroundl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    lroundl(arg1);
 }
 
-void test__log1pl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = log1pl(x);
+void test__lroundl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((lroundl(arg1) > 10) || (lroundl(arg1) < 100)) {}
 }
 
-void test__std__log1pl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::log1pl(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__std__log1pl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::log1pl(arg1);
+void test__lroundl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = lroundl(x);
 }
 
-void test__std__log1pl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::log1pl(arg1) > 10) || (std::log1pl(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__std__log1pl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::log1pl(x);
+void test__std__lroundl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::lroundl(arg1);
 }
 
-void test__log2__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = log2(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__lroundl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::lroundl(arg1) > 10) || (std::lroundl(arg1) < 100)) {}
 }
 
-void test__log2__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  log2(arg1);
+void test__std__lroundl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::lroundl(x);
 }
 
-void test__log2__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((log2(arg1) > 10) || (log2(arg1) < 100)) {}
+void test__rand__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = rand();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__log2__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = log2(p);
-  // cppcheck-suppress memleak
+void test__rand__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    rand();
 }
 
-void test__log2__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = log2(x);
+void test__rand__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = rand();
+    // 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__srand__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        srand(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__log2__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::log2(arg1);
+void test__srand__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    srand(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__log2__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::log2(arg1) > 10) || (std::log2(arg1) < 100)) {}
+void test__srand__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    srand(x);
 }
 
-void test__std__log2__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::log2(x);
+void test__std__srand__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::srand(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__log2f__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = log2f(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__srand__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::srand(x);
 }
 
-void test__log2f__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  log2f(arg1);
+void test__ldiv__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        ldiv(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__ldiv__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ldiv(arg1, arg2) > 10) || (ldiv(arg1, arg2) < 100)) {}
 }
 
-void test__log2f__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = log2f(p);
-  // cppcheck-suppress memleak
+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__log2f__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = log2f(x);
+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__std__log2f__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::log2f(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+
+void test__std__ldiv__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::ldiv(x, arg2);
 }
 
-void test__std__log2f__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::log2f(arg1);
+void test__std__ldiv__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::ldiv(arg1, x);
 }
 
-void test__std__log2f__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::log2f(arg1) > 10) || (std::log2f(arg1) < 100)) {}
+void test__lldiv__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        lldiv(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__log2f__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::log2f(x);
+void test__lldiv__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((lldiv(arg1, arg2) > 10) || (lldiv(arg1, arg2) < 100)) {}
 }
 
-void test__log2l__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = log2l(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__lldiv__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    lldiv(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__log2l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  log2l(arg1);
+void test__lldiv__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    lldiv(x, arg2);
 }
 
-void test__log2l__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((log2l(arg1) > 10) || (log2l(arg1) < 100)) {}
+void test__lldiv__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    lldiv(arg1, x);
 }
 
-void test__log2l__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = log2l(p);
-  // cppcheck-suppress memleak
+void test__std__lldiv__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::lldiv(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__log2l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = log2l(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__std__log2l__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::log2l(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__lldiv__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::lldiv(x, arg2);
 }
 
-void test__std__log2l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::log2l(arg1);
+void test__std__lldiv__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::lldiv(arg1, x);
 }
 
-void test__std__log2l__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::log2l(arg1) > 10) || (std::log2l(arg1) < 100)) {}
+void test__localtime__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        localtime(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__log2l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::log2l(x);
+void test__localtime__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    localtime(p);
+    // cppcheck-suppress memleak
 }
 
-void test__nearbyint__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = nearbyint(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__localtime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    localtime(NULL);
 }
 
-void test__nearbyint__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  nearbyint(arg1);
+void test__localtime__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    localtime(x);
 }
 
-void test__nearbyint__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((nearbyint(arg1) > 10) || (nearbyint(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__nearbyint__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = nearbyint(p);
-  // cppcheck-suppress memleak
+void test__std__localtime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::localtime(NULL);
 }
 
-void test__nearbyint__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = nearbyint(x);
+void test__std__localtime__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::localtime(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__localtime_s__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        localtime_s(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__nearbyint__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::nearbyint(arg1);
+void test__localtime_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    localtime_s(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__nearbyint__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::nearbyint(arg1) > 10) || (std::nearbyint(arg1) < 100)) {}
+void test__localtime_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    localtime_s(NULL, arg2);
 }
 
-void test__std__nearbyint__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::nearbyint(x);
+void test__localtime_s__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    localtime_s(arg1, NULL);
 }
 
-void test__nearbyintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = nearbyintf(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__nearbyintf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  nearbyintf(arg1);
+void test__std__localtime_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::localtime_s(NULL, arg2);
 }
 
-void test__nearbyintf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((nearbyintf(arg1) > 10) || (nearbyintf(arg1) < 100)) {}
+void test__std__localtime_s__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::localtime_s(arg1, NULL);
 }
 
-void test__nearbyintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = nearbyintf(p);
-  // cppcheck-suppress memleak
+void test__log__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = log(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__nearbyintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = nearbyintf(x);
+void test__log__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    log(arg1);
 }
 
-void test__std__nearbyintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::nearbyintf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__log__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = log(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__nearbyintf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::nearbyintf(arg1);
+void test__log__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = log(x);
 }
 
-void test__std__nearbyintf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::nearbyintf(arg1) > 10) || (std::nearbyintf(arg1) < 100)) {}
+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__nearbyintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::nearbyintf(x);
+void test__std__log__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::log(arg1);
 }
 
-void test__nearbyintl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = nearbyintl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__log__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::log(x);
 }
 
-void test__nearbyintl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  nearbyintl(arg1);
+void test__logf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = logf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__nearbyintl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((nearbyintl(arg1) > 10) || (nearbyintl(arg1) < 100)) {}
+void test__logf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    logf(arg1);
 }
 
-void test__nearbyintl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = nearbyintl(p);
-  // cppcheck-suppress memleak
+void test__logf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = logf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__nearbyintl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = nearbyintl(x);
+void test__logf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = logf(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__std__logf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::logf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__nearbyintl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::nearbyintl(arg1);
+void test__std__logf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::logf(arg1);
 }
 
-void test__std__nearbyintl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::nearbyintl(arg1) > 10) || (std::nearbyintl(arg1) < 100)) {}
+void test__std__logf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::logf(x);
 }
 
-void test__std__nearbyintl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::nearbyintl(x);
+void test__logl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = logl(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__logl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    logl(arg1);
 }
 
-void test__nextafter__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  nextafter(arg1, arg2);
+void test__logl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = logl(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__logl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = logl(x);
 }
 
-void test__nextafter__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = nextafter(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__logl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::logl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__nextafter__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = nextafter(x, arg2);
+void test__std__logl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::logl(arg1);
 }
 
-void test__nextafter__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = nextafter(arg1, x);
+void test__std__logl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::logl(x);
 }
 
-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__clog__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = clog(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__nextafter__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::nextafter(arg1, arg2);
+void test__clog__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    clog(arg1);
 }
 
-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__clog__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = clog(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__nextafter__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::nextafter(x, arg2);
+void test__clog__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = clog(x);
 }
 
-void test__std__nextafter__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::nextafter(arg1, x);
+void test__clogf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = clogf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__nextafterf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = nextafterf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__clogf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    clogf(arg1);
 }
 
-void test__nextafterf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  nextafterf(arg1, arg2);
+void test__clogf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = clogf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__nextafterf__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((nextafterf(arg1, arg2) > 10) || (nextafterf(arg1, arg2) < 100)) {}
+void test__clogf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = clogf(x);
 }
 
-void test__nextafterf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = nextafterf(p, arg2);
-  // cppcheck-suppress memleak
+void test__clogl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = clogl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__nextafterf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = nextafterf(x, arg2);
+void test__clogl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    clogl(arg1);
 }
 
-void test__nextafterf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = nextafterf(arg1, x);
+void test__clogl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = clogl(p);
+    // cppcheck-suppress memleak
 }
 
-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__clogl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = clogl(x);
 }
 
-void test__std__nextafterf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::nextafterf(arg1, arg2);
+void test__conj__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = conj(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__conj__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    conj(arg1);
 }
 
-void test__std__nextafterf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::nextafterf(x, arg2);
+void test__conj__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = conj(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__nextafterf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::nextafterf(arg1, x);
+void test__conj__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = conj(x);
 }
 
-void test__nextafterl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = nextafterl(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__conjf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = conjf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__nextafterl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  nextafterl(arg1, arg2);
+void test__conjf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    conjf(arg1);
 }
 
-void test__nextafterl__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((nextafterl(arg1, arg2) > 10) || (nextafterl(arg1, arg2) < 100)) {}
+void test__conjf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = conjf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__nextafterl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = nextafterl(p, arg2);
-  // cppcheck-suppress memleak
+void test__conjf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = conjf(x);
 }
 
-void test__nextafterl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = nextafterl(x, arg2);
+void test__conjl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = conjl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__nextafterl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = nextafterl(arg1, x);
+void test__conjl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    conjl(arg1);
 }
 
-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__conjl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = conjl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__nextafterl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::nextafterl(arg1, arg2);
+void test__conjl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = conjl(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__fpclassify__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = fpclassify(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__nextafterl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::nextafterl(x, arg2);
+void test__fpclassify__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    fpclassify(arg1);
 }
 
-void test__std__nextafterl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::nextafterl(arg1, x);
+void test__fpclassify__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((fpclassify(arg1) > 10) || (fpclassify(arg1) < 100)) {}
 }
 
-void test__nexttoward__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = nexttoward(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__fpclassify__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = fpclassify(p);
+    // cppcheck-suppress memleak
 }
 
-void test__nexttoward__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  nexttoward(arg1, arg2);
+void test__fpclassify__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = fpclassify(x);
 }
 
-void test__nexttoward__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((nexttoward(arg1, arg2) > 10) || (nexttoward(arg1, arg2) < 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__nexttoward__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = nexttoward(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__fpclassify__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::fpclassify(arg1);
 }
 
-void test__nexttoward__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = nexttoward(x, arg2);
+void test__std__fpclassify__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::fpclassify(arg1) > 10) || (std::fpclassify(arg1) < 100)) {}
 }
 
-void test__nexttoward__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = nexttoward(arg1, x);
+void test__std__fpclassify__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::fpclassify(x);
 }
 
-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__isfinite__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = isfinite(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__nexttoward__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::nexttoward(arg1, arg2);
+void test__isfinite__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isfinite(arg1);
 }
 
-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__isfinite__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isfinite(arg1) > 10) || (isfinite(arg1) < 100)) {}
 }
 
-void test__std__nexttoward__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::nexttoward(x, arg2);
+void test__isfinite__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isfinite(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__nexttoward__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::nexttoward(arg1, x);
+void test__isfinite__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isfinite(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__isfinite__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::isfinite(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__nexttowardf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  nexttowardf(arg1, arg2);
+void test__std__isfinite__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isfinite(arg1);
 }
 
-void test__nexttowardf__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((nexttowardf(arg1, arg2) > 10) || (nexttowardf(arg1, arg2) < 100)) {}
+void test__std__isfinite__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::isfinite(arg1) > 10) || (std::isfinite(arg1) < 100)) {}
 }
 
-void test__nexttowardf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = nexttowardf(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__isfinite__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isfinite(x);
 }
 
-void test__nexttowardf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = nexttowardf(x, arg2);
+void test__isgreater__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = isgreater(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__nexttowardf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = nexttowardf(arg1, x);
+void test__isgreater__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isgreater(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__isgreater__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isgreater(arg1, arg2) > 10) || (isgreater(arg1, arg2) < 100)) {}
 }
 
-void test__std__nexttowardf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::nexttowardf(arg1, arg2);
+void test__isgreater__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isgreater(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__isgreater__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isgreater(x, arg2);
 }
 
-void test__std__nexttowardf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::nexttowardf(x, arg2);
+void test__isgreater__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isgreater(arg1, x);
 }
 
-void test__std__nexttowardf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::nexttowardf(arg1, x);
+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__nexttowardl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = nexttowardl(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__isgreater__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isgreater(arg1, arg2);
 }
 
-void test__nexttowardl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  nexttowardl(arg1, 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__nexttowardl__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((nexttowardl(arg1, arg2) > 10) || (nexttowardl(arg1, arg2) < 100)) {}
+void test__std__isgreater__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isgreater(x, arg2);
 }
 
-void test__nexttowardl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = nexttowardl(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__isgreater__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isgreater(arg1, x);
 }
 
-void test__nexttowardl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = nexttowardl(x, arg2);
+void test__isgreaterequal__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = isgreaterequal(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__nexttowardl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = nexttowardl(arg1, x);
+void test__isgreaterequal__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isgreaterequal(arg1, arg2);
 }
 
-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__isgreaterequal__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isgreaterequal(arg1, arg2) > 10) || (isgreaterequal(arg1, arg2) < 100)) {}
 }
 
-void test__std__nexttowardl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::nexttowardl(arg1, arg2);
+void test__isgreaterequal__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isgreaterequal(p, arg2);
+    // 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__isgreaterequal__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isgreaterequal(x, arg2);
 }
 
-void test__std__nexttowardl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::nexttowardl(x, arg2);
+void test__isgreaterequal__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isgreaterequal(arg1, x);
 }
 
-void test__std__nexttowardl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::nexttowardl(arg1, x);
+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__longjmp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; longjmp(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__isgreaterequal__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isgreaterequal(arg1, arg2);
 }
 
-void test__longjmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  longjmp(p, arg2);
-  // cppcheck-suppress memleak
+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__longjmp__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  longjmp(x, arg2);
+void test__std__isgreaterequal__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isgreaterequal(x, arg2);
 }
 
-void test__longjmp__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  longjmp(arg1, x);
+void test__std__isgreaterequal__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isgreaterequal(arg1, 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__isinf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = isinf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__longjmp__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::longjmp(x, arg2);
+void test__isinf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isinf(arg1);
 }
 
-void test__std__longjmp__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::longjmp(arg1, x);
+void test__isinf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isinf(arg1) > 10) || (isinf(arg1) < 100)) {}
 }
 
-void test__malloc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = malloc(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__isinf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isinf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__malloc__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  malloc(arg1);
+void test__isinf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isinf(x);
 }
 
-void test__malloc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = malloc(x);
+void test__std__isinf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::isinf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__isinf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isinf(arg1);
 }
 
-void test__std__malloc__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::malloc(arg1);
+void test__std__isinf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::isinf(arg1) > 10) || (std::isinf(arg1) < 100)) {}
 }
 
-void test__std__malloc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::malloc(x);
+void test__std__isinf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isinf(x);
 }
 
-void test__alloca__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = alloca(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__logb__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = logb(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__alloca__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  alloca(arg1);
+void test__logb__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    logb(arg1);
 }
 
-void test__alloca__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = alloca(x);
+void test__logb__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((logb(arg1) > 10) || (logb(arg1) < 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__logb__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = logb(p);
+    // cppcheck-suppress memleak
 }
 
-void test__memchr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  memchr(arg1, arg2, arg3);
+void test__logb__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = logb(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__logb__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::logb(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__memchr__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = memchr(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__logb__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::logb(arg1);
 }
 
-void test__memchr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = memchr(p, arg2, arg3);
+void test__std__logb__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::logb(arg1) > 10) || (std::logb(arg1) < 100)) {}
 }
 
-void test__memchr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = memchr(x, arg2, arg3);
+void test__std__logb__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::logb(x);
 }
 
-void test__memchr__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = memchr(arg1, !x, arg3);
+void test__logbf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = logbf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__memchr__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = memchr(arg1, x, arg3);
+void test__logbf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    logbf(arg1);
 }
 
-void test__memchr__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = memchr(arg1, arg2, !x);
+void test__logbf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((logbf(arg1) > 10) || (logbf(arg1) < 100)) {}
 }
 
-void test__memchr__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = memchr(arg1, arg2, x);
+void test__logbf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = logbf(p);
+    // cppcheck-suppress memleak
 }
 
-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__logbf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = logbf(x);
 }
 
-void test__std__memchr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::memchr(arg1, arg2, arg3);
+void test__std__logbf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::logbf(arg1);
+    }
+    // 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__logbf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::logbf(arg1);
 }
 
-void test__std__memchr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::memchr(p, arg2, arg3);
+void test__std__logbf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::logbf(arg1) > 10) || (std::logbf(arg1) < 100)) {}
 }
 
-void test__std__memchr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::memchr(x, arg2, arg3);
+void test__std__logbf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::logbf(x);
 }
 
-void test__std__memchr__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = std::memchr(arg1, !x, arg3);
+void test__logbl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = logbl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__memchr__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::memchr(arg1, x, arg3);
+void test__logbl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    logbl(arg1);
 }
 
-void test__std__memchr__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = std::memchr(arg1, arg2, !x);
+void test__logbl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((logbl(arg1) > 10) || (logbl(arg1) < 100)) {}
 }
 
-void test__std__memchr__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::memchr(arg1, arg2, x);
+void test__logbl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = logbl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wmemchr__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wmemchr(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__logbl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = logbl(x);
 }
 
-void test__wmemchr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wmemchr(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__wmemchr__pure(int arg1,int arg2,int arg3) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((wmemchr(arg1, arg2, arg3) > 10) || (wmemchr(arg1, arg2, arg3) < 100)) {}
+void test__std__logbl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::logbl(arg1);
 }
 
-void test__wmemchr__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wmemchr(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__wmemchr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wmemchr(p, arg2, arg3);
+void test__std__logbl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::logbl(x);
 }
 
-void test__wmemchr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wmemchr(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__wmemchr__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = wmemchr(arg1, !x, arg3);
+void test__isless__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isless(arg1, arg2);
 }
 
-void test__wmemchr__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wmemchr(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__wmemchr__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = wmemchr(arg1, arg2, !x);
+void test__isless__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isless(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__wmemchr__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wmemchr(arg1, arg2, x);
+void test__isless__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isless(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__isless__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isless(arg1, x);
 }
 
-void test__std__wmemchr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wmemchr(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__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__std__isless__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isless(arg1, arg2);
 }
 
-void test__std__wmemchr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wmemchr(p, 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__wmemchr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wmemchr(x, arg2, arg3);
+void test__std__isless__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isless(x, arg2);
 }
 
-void test__std__wmemchr__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = std::wmemchr(arg1, !x, arg3);
+void test__std__isless__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isless(arg1, x);
 }
 
-void test__std__wmemchr__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wmemchr(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__wmemchr__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = std::wmemchr(arg1, arg2, !x);
+void test__islessequal__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    islessequal(arg1, arg2);
 }
 
-void test__std__wmemchr__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wmemchr(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__memcmp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = memcmp(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__memcmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  memcmp(arg1, arg2, arg3);
+void test__islessequal__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = islessequal(x, arg2);
 }
 
-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__islessequal__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = islessequal(arg1, x);
 }
 
-void test__memcmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = memcmp(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__memcmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = memcmp(p, arg2, arg3);
+void test__std__islessequal__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::islessequal(arg1, arg2);
 }
 
-void test__memcmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = memcmp(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__memcmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = memcmp(arg1, p, arg3);
+void test__std__islessequal__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::islessequal(x, arg2);
 }
 
-void test__memcmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = memcmp(arg1, x, arg3);
+void test__std__islessequal__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::islessequal(arg1, x);
 }
 
-void test__memcmp__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = memcmp(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__memcmp__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = memcmp(arg1, arg2, x);
+void test__islessgreater__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    islessgreater(arg1, arg2);
 }
 
-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__islessgreater__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((islessgreater(arg1, arg2) > 10) || (islessgreater(arg1, arg2) < 100)) {}
 }
 
-void test__std__memcmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::memcmp(arg1, arg2, arg3);
+void test__islessgreater__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = islessgreater(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__islessgreater__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = islessgreater(x, arg2);
 }
 
-void test__std__memcmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::memcmp(p, arg2, arg3);
+void test__islessgreater__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = islessgreater(arg1, x);
 }
 
-void test__std__memcmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::memcmp(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__memcmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::memcmp(arg1, p, arg3);
+void test__std__islessgreater__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::islessgreater(arg1, arg2);
 }
 
-void test__std__memcmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::memcmp(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__memcmp__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = std::memcmp(arg1, arg2, !x);
+void test__std__islessgreater__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::islessgreater(x, arg2);
 }
 
-void test__std__memcmp__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::memcmp(arg1, arg2, x);
+void test__std__islessgreater__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::islessgreater(arg1, x);
 }
 
-void test__wmemcmp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wmemcmp(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__wmemcmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wmemcmp(arg1, arg2, arg3);
+void test__nan__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    nan(arg1);
 }
 
-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__nan__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((nan(arg1) > 10) || (nan(arg1) < 100)) {}
 }
 
-void test__wmemcmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wmemcmp(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__nan__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = nan(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wmemcmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wmemcmp(p, arg2, arg3);
+void test__nan__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = nan(NULL);
 }
 
-void test__wmemcmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wmemcmp(x, arg2, arg3);
+void test__nan__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = nan(x);
 }
 
-void test__wmemcmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wmemcmp(arg1, p, 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__wmemcmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wmemcmp(arg1, x, arg3);
+void test__std__nan__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::nan(arg1);
 }
 
-void test__wmemcmp__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = wmemcmp(arg1, arg2, !x);
+void test__std__nan__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::nan(arg1) > 10) || (std::nan(arg1) < 100)) {}
 }
 
-void test__wmemcmp__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wmemcmp(arg1, arg2, x);
+void test__std__nan__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::nan(NULL);
 }
 
-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__nan__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::nan(x);
 }
 
-void test__std__wmemcmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wmemcmp(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__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__nanf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    nanf(arg1);
 }
 
-void test__std__wmemcmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wmemcmp(p, arg2, arg3);
+void test__nanf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((nanf(arg1) > 10) || (nanf(arg1) < 100)) {}
 }
 
-void test__std__wmemcmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wmemcmp(x, arg2, arg3);
+void test__nanf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = nanf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wmemcmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wmemcmp(arg1, p, arg3);
+void test__nanf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = nanf(NULL);
 }
 
-void test__std__wmemcmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wmemcmp(arg1, x, arg3);
+void test__nanf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = nanf(x);
 }
 
-void test__std__wmemcmp__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = std::wmemcmp(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__wmemcmp__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wmemcmp(arg1, arg2, x);
+void test__std__nanf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::nanf(arg1);
 }
 
-void test__memcpy__noreturn() {
-  int x = 1;
-  if (cond) { x=100; memcpy(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__memcpy__leakignore() {
-  char *p = malloc(10); *p=0;
-  memcpy(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__nanf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::nanf(NULL);
 }
 
-void test__memcpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  memcpy(p, arg2, arg3);
+void test__std__nanf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::nanf(x);
 }
 
-void test__memcpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  memcpy(arg1, p, arg3);
+void test__nanl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = nanl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__memcpy__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  memcpy(arg1, x, arg3);
+void test__nanl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    nanl(arg1);
 }
 
-void test__memcpy__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  memcpy(arg1, arg2, !x);
+void test__nanl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((nanl(arg1) > 10) || (nanl(arg1) < 100)) {}
 }
 
-void test__memcpy__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  memcpy(arg1, arg2, x);
+void test__nanl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = nanl(p);
+    // cppcheck-suppress memleak
 }
 
-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__nanl__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = nanl(NULL);
 }
 
-void test__std__memcpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::memcpy(p, arg2, arg3);
+void test__nanl__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = nanl(x);
 }
 
-void test__std__memcpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::memcpy(arg1, p, arg3);
+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__memcpy__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::memcpy(arg1, x, arg3);
+void test__std__nanl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::nanl(arg1);
 }
 
-void test__std__memcpy__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::memcpy(arg1, arg2, !x);
+void test__std__nanl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::nanl(arg1) > 10) || (std::nanl(arg1) < 100)) {}
 }
 
-void test__std__memcpy__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::memcpy(arg1, arg2, x);
+void test__std__nanl__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::nanl(NULL);
 }
 
-void test__wmemcpy__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wmemcpy(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__nanl__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::nanl(x);
 }
 
-void test__wmemcpy__leakignore() {
-  char *p = malloc(10); *p=0;
-  wmemcpy(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__isnan__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = isnan(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wmemcpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wmemcpy(p, arg2, arg3);
+void test__isnan__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isnan(arg1);
 }
 
-void test__wmemcpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wmemcpy(arg1, p, arg3);
+void test__isnan__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isnan(arg1) > 10) || (isnan(arg1) < 100)) {}
 }
 
-void test__wmemcpy__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wmemcpy(arg1, x, arg3);
+void test__isnan__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isnan(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wmemcpy__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  wmemcpy(arg1, arg2, !x);
+void test__isnan__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isnan(x);
 }
 
-void test__wmemcpy__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wmemcpy(arg1, arg2, 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__std__wmemcpy__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::wmemcpy(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__isnan__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isnan(arg1);
 }
 
-void test__std__wmemcpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wmemcpy(p, arg2, arg3);
+void test__std__isnan__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::isnan(arg1) > 10) || (std::isnan(arg1) < 100)) {}
 }
 
-void test__std__wmemcpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wmemcpy(arg1, p, arg3);
+void test__std__isnan__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isnan(x);
 }
 
-void test__std__wmemcpy__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wmemcpy(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__std__wmemcpy__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::wmemcpy(arg1, arg2, !x);
+void test__isnormal__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isnormal(arg1);
 }
 
-void test__std__wmemcpy__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wmemcpy(arg1, arg2, x);
+void test__isnormal__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isnormal(arg1) > 10) || (isnormal(arg1) < 100)) {}
 }
 
-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__isnormal__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isnormal(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__isnormal__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isnormal(x);
 }
 
-void test__memcpy_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  memcpy_s(p, arg2, arg3, arg4);
+void test__std__isnormal__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::isnormal(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__memcpy_s__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  memcpy_s(arg1, !x, arg3, arg4);
+void test__std__isnormal__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isnormal(arg1);
 }
 
-void test__memcpy_s__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  memcpy_s(arg1, x, arg3, arg4);
+void test__std__isnormal__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::isnormal(arg1) > 10) || (std::isnormal(arg1) < 100)) {}
 }
 
-void test__memcpy_s__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  memcpy_s(arg1, arg2, p, arg4);
+void test__std__isnormal__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isnormal(x);
 }
 
-void test__memcpy_s__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  memcpy_s(arg1, arg2, x, arg4);
+void test__isunordered__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = isunordered(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__memcpy_s__arg4__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  memcpy_s(arg1, arg2, arg3, !x);
+void test__isunordered__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    isunordered(arg1, arg2);
 }
 
-void test__memcpy_s__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  memcpy_s(arg1, arg2, arg3, x);
+void test__isunordered__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((isunordered(arg1, arg2) > 10) || (isunordered(arg1, arg2) < 100)) {}
 }
 
-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__isunordered__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = isunordered(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__wmemcpy_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  wmemcpy_s(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__isunordered__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isunordered(x, arg2);
 }
 
-void test__wmemcpy_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wmemcpy_s(p, arg2, arg3, arg4);
+void test__isunordered__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = isunordered(arg1, x);
 }
 
-void test__wmemcpy_s__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  wmemcpy_s(arg1, !x, arg3, arg4);
+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__wmemcpy_s__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wmemcpy_s(arg1, x, arg3, arg4);
+void test__std__isunordered__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::isunordered(arg1, arg2);
 }
 
-void test__wmemcpy_s__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wmemcpy_s(arg1, arg2, p, arg4);
+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__wmemcpy_s__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wmemcpy_s(arg1, arg2, x, arg4);
+void test__std__isunordered__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isunordered(x, arg2);
 }
 
-void test__wmemcpy_s__arg4__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  wmemcpy_s(arg1, arg2, arg3, !x);
+void test__std__isunordered__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::isunordered(arg1, x);
 }
 
-void test__wmemcpy_s__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wmemcpy_s(arg1, arg2, arg3, x);
+void test__ilogb__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ilogb(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__memmove__noreturn() {
-  int x = 1;
-  if (cond) { x=100; memmove(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ilogb__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ilogb(arg1);
 }
 
-void test__memmove__leakignore() {
-  char *p = malloc(10); *p=0;
-  memmove(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__ilogb__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ilogb(arg1) > 10) || (ilogb(arg1) < 100)) {}
 }
 
-void test__memmove__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  memmove(p, arg2, arg3);
+void test__ilogb__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ilogb(p);
+    // cppcheck-suppress memleak
 }
 
-void test__memmove__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  memmove(arg1, p, arg3);
+void test__ilogb__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ilogb(x);
 }
 
-void test__memmove__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  memmove(arg1, x, arg3);
+void test__std__ilogb__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::ilogb(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__memmove__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  memmove(arg1, arg2, !x);
+void test__std__ilogb__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::ilogb(arg1);
 }
 
-void test__memmove__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  memmove(arg1, arg2, x);
+void test__std__ilogb__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::ilogb(arg1) > 10) || (std::ilogb(arg1) < 100)) {}
 }
 
-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__std__ilogb__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::ilogb(x);
 }
 
-void test__std__memmove__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::memmove(p, arg2, arg3);
+void test__ilogbf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ilogbf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__memmove__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::memmove(arg1, p, arg3);
+void test__ilogbf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ilogbf(arg1);
 }
 
-void test__std__memmove__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::memmove(arg1, x, arg3);
+void test__ilogbf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ilogbf(arg1) > 10) || (ilogbf(arg1) < 100)) {}
 }
 
-void test__std__memmove__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::memmove(arg1, arg2, !x);
+void test__ilogbf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ilogbf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__memmove__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::memmove(arg1, arg2, x);
+void test__ilogbf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ilogbf(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__ilogbf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::ilogbf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wmemmove__leakignore() {
-  char *p = malloc(10); *p=0;
-  wmemmove(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__ilogbf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::ilogbf(arg1);
 }
 
-void test__wmemmove__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wmemmove(p, arg2, arg3);
+void test__std__ilogbf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::ilogbf(arg1) > 10) || (std::ilogbf(arg1) < 100)) {}
 }
 
-void test__wmemmove__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wmemmove(arg1, p, arg3);
+void test__std__ilogbf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::ilogbf(x);
 }
 
-void test__wmemmove__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wmemmove(arg1, x, arg3);
+void test__ilogbl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ilogbl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wmemmove__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  wmemmove(arg1, arg2, !x);
+void test__ilogbl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ilogbl(arg1);
 }
 
-void test__wmemmove__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wmemmove(arg1, arg2, x);
+void test__ilogbl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((ilogbl(arg1) > 10) || (ilogbl(arg1) < 100)) {}
 }
 
-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__ilogbl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ilogbl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wmemmove__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wmemmove(p, arg2, arg3);
+void test__ilogbl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ilogbl(x);
 }
 
-void test__std__wmemmove__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wmemmove(arg1, p, 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__std__wmemmove__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wmemmove(arg1, x, arg3);
+void test__std__ilogbl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::ilogbl(arg1);
 }
 
-void test__std__wmemmove__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::wmemmove(arg1, arg2, !x);
+void test__std__ilogbl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::ilogbl(arg1) > 10) || (std::ilogbl(arg1) < 100)) {}
 }
 
-void test__std__wmemmove__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wmemmove(arg1, arg2, x);
+void test__std__ilogbl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::ilogbl(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__log10__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = log10(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__log10__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    log10(arg1);
 }
 
-void test__memset_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  memset_s(p, arg2, arg3, arg4);
+void test__log10__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((log10(arg1) > 10) || (log10(arg1) < 100)) {}
 }
 
-void test__memset_s__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  memset_s(arg1, x, arg3, arg4);
+void test__log10__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = log10(p);
+    // cppcheck-suppress memleak
 }
 
-void test__memset_s__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  memset_s(arg1, arg2, x, arg4);
+void test__log10__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = log10(x);
 }
 
-void test__memset_s__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  memset_s(arg1, arg2, arg3, 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__memset__noreturn() {
-  int x = 1;
-  if (cond) { x=100; memset(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__log10__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::log10(arg1);
 }
 
-void test__memset__leakignore() {
-  char *p = malloc(10); *p=0;
-  memset(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__memset__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  memset(p, arg2, arg3);
+void test__std__log10__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::log10(x);
 }
 
-void test__memset__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  memset(arg1, x, arg3);
+void test__log10f__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = log10f(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__memset__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  memset(arg1, arg2, !x);
+void test__log10f__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    log10f(arg1);
 }
 
-void test__memset__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  memset(arg1, arg2, x);
+void test__log10f__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((log10f(arg1) > 10) || (log10f(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__log10f__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = log10f(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__memset__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::memset(p, arg2, arg3);
+void test__log10f__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = log10f(x);
 }
 
-void test__std__memset__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::memset(arg1, x, 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__memset__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::memset(arg1, arg2, !x);
+void test__std__log10f__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::log10f(arg1);
 }
 
-void test__std__memset__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::memset(arg1, arg2, x);
+void test__std__log10f__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::log10f(arg1) > 10) || (std::log10f(arg1) < 100)) {}
 }
 
-void test__wmemset__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wmemset(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__log10f__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::log10f(x);
 }
 
-void test__wmemset__leakignore() {
-  char *p = malloc(10); *p=0;
-  wmemset(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__log10l__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = log10l(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wmemset__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wmemset(p, arg2, arg3);
+void test__log10l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    log10l(arg1);
 }
 
-void test__wmemset__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wmemset(arg1, x, arg3);
+void test__log10l__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((log10l(arg1) > 10) || (log10l(arg1) < 100)) {}
 }
 
-void test__wmemset__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  wmemset(arg1, arg2, !x);
+void test__log10l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = log10l(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wmemset__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wmemset(arg1, arg2, x);
+void test__log10l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = log10l(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__log10l__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::log10l(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__wmemset__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wmemset(p, arg2, arg3);
+void test__std__log10l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::log10l(arg1);
 }
 
-void test__std__wmemset__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wmemset(arg1, x, arg3);
+void test__std__log10l__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::log10l(arg1) > 10) || (std::log10l(arg1) < 100)) {}
 }
 
-void test__std__wmemset__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::wmemset(arg1, arg2, !x);
+void test__std__log10l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::log10l(x);
 }
 
-void test__std__wmemset__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wmemset(arg1, arg2, x);
+void test__log1p__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = log1p(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__mktime__noreturn() {
-  int x = 1;
-  if (cond) { x=100; mktime(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__log1p__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    log1p(arg1);
 }
 
-void test__mktime__leakignore() {
-  char *p = malloc(10); *p=0;
-  mktime(p);
-  // cppcheck-suppress memleak
+void test__log1p__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((log1p(arg1) > 10) || (log1p(arg1) < 100)) {}
 }
 
-void test__mktime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mktime(p);
+void test__log1p__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = log1p(p);
+    // cppcheck-suppress memleak
 }
 
-void test__mktime__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  mktime(x);
+void test__log1p__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = log1p(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__log1p__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::log1p(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__mktime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::mktime(p);
+void test__std__log1p__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::log1p(arg1);
 }
 
-void test__std__mktime__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::mktime(x);
+void test__std__log1p__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::log1p(arg1) > 10) || (std::log1p(arg1) < 100)) {}
 }
 
-void test__mkxtime__noreturn() {
-  int x = 1;
-  if (cond) { x=100; mkxtime(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__log1p__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::log1p(x);
 }
 
-void test__mkxtime__leakignore() {
-  char *p = malloc(10); *p=0;
-  mkxtime(p);
-  // cppcheck-suppress memleak
+void test__log1pf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = log1pf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__mkxtime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mkxtime(p);
+void test__log1pf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    log1pf(arg1);
 }
 
-void test__mkxtime__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  mkxtime(x);
+void test__log1pf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((log1pf(arg1) > 10) || (log1pf(arg1) < 100)) {}
 }
 
-void test__modf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; modf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__log1pf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = log1pf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__modf__leakignore() {
-  char *p = malloc(10); *p=0;
-  modf(p, arg2);
-  // cppcheck-suppress memleak
+void test__log1pf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = log1pf(x);
 }
 
-void test__modf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  modf(x, arg2);
+void test__std__log1pf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::log1pf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__modf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  modf(arg1, p);
+void test__std__log1pf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::log1pf(arg1);
 }
 
-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__log1pf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::log1pf(arg1) > 10) || (std::log1pf(arg1) < 100)) {}
 }
 
-void test__std__modf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::modf(x, arg2);
+void test__std__log1pf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::log1pf(x);
 }
 
-void test__std__modf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::modf(arg1, p);
+void test__log1pl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = log1pl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__modff__noreturn() {
-  int x = 1;
-  if (cond) { x=100; modff(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__log1pl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    log1pl(arg1);
 }
 
-void test__modff__leakignore() {
-  char *p = malloc(10); *p=0;
-  modff(p, arg2);
-  // cppcheck-suppress memleak
+void test__log1pl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((log1pl(arg1) > 10) || (log1pl(arg1) < 100)) {}
 }
 
-void test__modff__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  modff(x, arg2);
+void test__log1pl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = log1pl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__modff__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  modff(arg1, p);
+void test__log1pl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = log1pl(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__log1pl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::log1pl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__modff__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::modff(x, arg2);
+void test__std__log1pl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::log1pl(arg1);
 }
 
-void test__std__modff__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::modff(arg1, p);
+void test__std__log1pl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::log1pl(arg1) > 10) || (std::log1pl(arg1) < 100)) {}
 }
 
-void test__modfl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; modfl(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__log1pl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::log1pl(x);
 }
 
-void test__modfl__leakignore() {
-  char *p = malloc(10); *p=0;
-  modfl(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__modfl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  modfl(x, arg2);
+void test__log2__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    log2(arg1);
 }
 
-void test__modfl__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  modfl(arg1, p);
+void test__log2__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((log2(arg1) > 10) || (log2(arg1) < 100)) {}
 }
 
-void test__std__modfl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::modfl(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__modfl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::modfl(x, arg2);
+void test__log2__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = log2(x);
 }
 
-void test__std__modfl__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::modfl(arg1, p);
+void test__std__log2__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::log2(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__perror__noreturn() {
-  int x = 1;
-  if (cond) { x=100; perror(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__log2__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::log2(arg1);
 }
 
-void test__perror__leakignore() {
-  char *p = malloc(10); *p=0;
-  perror(p);
-  // cppcheck-suppress memleak
+void test__std__log2__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::log2(arg1) > 10) || (std::log2(arg1) < 100)) {}
 }
 
-void test__perror__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  perror(x);
+void test__std__log2__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::log2(x);
 }
 
-void test__std__perror__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::perror(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__log2f__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = log2f(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__perror__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::perror(x);
+void test__log2f__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    log2f(arg1);
 }
 
-void test__pow__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = pow(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__pow__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  pow(arg1, arg2);
+void test__log2f__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = log2f(p);
+    // cppcheck-suppress memleak
 }
 
-void test__pow__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((pow(arg1, arg2) > 10) || (pow(arg1, arg2) < 100)) {}
+void test__log2f__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = log2f(x);
 }
 
-void test__pow__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = pow(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__log2f__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::log2f(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__pow__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = pow(x, arg2);
+void test__std__log2f__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::log2f(arg1);
 }
 
-void test__pow__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = pow(arg1, x);
+void test__std__log2f__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::log2f(arg1) > 10) || (std::log2f(arg1) < 100)) {}
 }
 
-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__std__log2f__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::log2f(x);
 }
 
-void test__std__pow__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::pow(arg1, arg2);
+void test__log2l__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = log2l(arg1);
+    }
+    // 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__log2l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    log2l(arg1);
 }
 
-void test__std__pow__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::pow(x, arg2);
+void test__log2l__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((log2l(arg1) > 10) || (log2l(arg1) < 100)) {}
 }
 
-void test__std__pow__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::pow(arg1, x);
+void test__log2l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = log2l(p);
+    // cppcheck-suppress memleak
 }
 
-void test__powf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = powf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__log2l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = log2l(x);
 }
 
-void test__powf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  powf(arg1, 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__powf__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((powf(arg1, arg2) > 10) || (powf(arg1, arg2) < 100)) {}
+void test__std__log2l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::log2l(arg1);
 }
 
-void test__powf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = powf(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__log2l__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::log2l(arg1) > 10) || (std::log2l(arg1) < 100)) {}
 }
 
-void test__powf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = powf(x, arg2);
+void test__std__log2l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::log2l(x);
 }
 
-void test__powf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = powf(arg1, x);
+void test__nearbyint__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = nearbyint(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__nearbyint__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    nearbyint(arg1);
 }
 
-void test__std__powf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::powf(arg1, arg2);
+void test__nearbyint__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((nearbyint(arg1) > 10) || (nearbyint(arg1) < 100)) {}
 }
 
-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__nearbyint__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = nearbyint(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__powf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::powf(x, arg2);
+void test__nearbyint__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = nearbyint(x);
 }
 
-void test__std__powf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::powf(arg1, 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__powl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = powl(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__nearbyint__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::nearbyint(arg1);
 }
 
-void test__powl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  powl(arg1, arg2);
+void test__std__nearbyint__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::nearbyint(arg1) > 10) || (std::nearbyint(arg1) < 100)) {}
 }
 
-void test__powl__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((powl(arg1, arg2) > 10) || (powl(arg1, arg2) < 100)) {}
+void test__std__nearbyint__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::nearbyint(x);
 }
 
-void test__powl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = powl(p, arg2);
-  // cppcheck-suppress memleak
+void test__nearbyintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = nearbyintf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__powl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = powl(x, arg2);
+void test__nearbyintf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    nearbyintf(arg1);
 }
 
-void test__powl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = powl(arg1, x);
+void test__nearbyintf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((nearbyintf(arg1) > 10) || (nearbyintf(arg1) < 100)) {}
 }
 
-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__nearbyintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = nearbyintf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__powl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::powl(arg1, arg2);
+void test__nearbyintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = nearbyintf(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__nearbyintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::nearbyintf(arg1);
+    }
+    // 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__nearbyintf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::nearbyintf(arg1);
 }
 
-void test__std__powl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::powl(arg1, x);
+void test__std__nearbyintf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::nearbyintf(arg1) > 10) || (std::nearbyintf(arg1) < 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__nearbyintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::nearbyintf(x);
 }
 
-void test__cpow__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cpow(arg1, arg2);
+void test__nearbyintl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = nearbyintl(arg1);
+    }
+    // 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__nearbyintl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    nearbyintl(arg1);
 }
 
-void test__cpow__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cpow(p, arg2);
-  // cppcheck-suppress memleak
+void test__nearbyintl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((nearbyintl(arg1) > 10) || (nearbyintl(arg1) < 100)) {}
 }
 
-void test__cpow__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cpow(x, arg2);
+void test__nearbyintl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = nearbyintl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__cpow__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cpow(arg1, x);
+void test__nearbyintl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = nearbyintl(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__nearbyintl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::nearbyintl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cpowf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cpowf(arg1, arg2);
+void test__std__nearbyintl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::nearbyintl(arg1);
 }
 
-void test__cpowf__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cpowf(arg1, arg2) > 10) || (cpowf(arg1, arg2) < 100)) {}
+void test__std__nearbyintl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::nearbyintl(arg1) > 10) || (std::nearbyintl(arg1) < 100)) {}
 }
 
-void test__cpowf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cpowf(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__nearbyintl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::nearbyintl(x);
 }
 
-void test__cpowf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cpowf(x, arg2);
+void test__nextafter__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = nextafter(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__cpowf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cpowf(arg1, x);
+void test__nextafter__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    nextafter(arg1, arg2);
 }
 
-void test__cpowl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = cpowl(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__nextafter__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((nextafter(arg1, arg2) > 10) || (nextafter(arg1, arg2) < 100)) {}
 }
 
-void test__cpowl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  cpowl(arg1, arg2);
+void test__nextafter__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = nextafter(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__cpowl__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((cpowl(arg1, arg2) > 10) || (cpowl(arg1, arg2) < 100)) {}
+void test__nextafter__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = nextafter(x, arg2);
 }
 
-void test__cpowl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = cpowl(p, arg2);
-  // cppcheck-suppress memleak
+void test__nextafter__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = nextafter(arg1, x);
 }
 
-void test__cpowl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cpowl(x, arg2);
+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__cpowl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = cpowl(arg1, x);
+void test__std__nextafter__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::nextafter(arg1, arg2);
 }
 
-void test__remainder__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = remainder(arg1, arg2); }
-  // 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__remainder__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  remainder(arg1, arg2);
+void test__std__nextafter__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::nextafter(x, arg2);
 }
 
-void test__remainder__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((remainder(arg1, arg2) > 10) || (remainder(arg1, arg2) < 100)) {}
+void test__std__nextafter__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::nextafter(arg1, x);
 }
 
-void test__remainder__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = remainder(p, arg2);
-  // cppcheck-suppress memleak
+void test__nextafterf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = nextafterf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__remainder__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = remainder(x, arg2);
+void test__nextafterf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    nextafterf(arg1, arg2);
 }
 
-void test__remainder__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = remainder(arg1, x);
+void test__nextafterf__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((nextafterf(arg1, arg2) > 10) || (nextafterf(arg1, arg2) < 100)) {}
 }
 
-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__nextafterf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = nextafterf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__remainder__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::remainder(arg1, arg2);
+void test__nextafterf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = nextafterf(x, 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__nextafterf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = nextafterf(arg1, x);
 }
 
-void test__std__remainder__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::remainder(x, arg2);
+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__remainder__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::remainder(arg1, x);
+void test__std__nextafterf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::nextafterf(arg1, arg2);
 }
 
-void test__remainderf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = remainderf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+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__remainderf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  remainderf(arg1, arg2);
+void test__std__nextafterf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::nextafterf(x, arg2);
 }
 
-void test__remainderf__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((remainderf(arg1, arg2) > 10) || (remainderf(arg1, arg2) < 100)) {}
+void test__std__nextafterf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::nextafterf(arg1, x);
 }
 
-void test__remainderf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = remainderf(p, arg2);
-  // cppcheck-suppress memleak
+void test__nextafterl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = nextafterl(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__remainderf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = remainderf(x, arg2);
+void test__nextafterl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    nextafterl(arg1, arg2);
 }
 
-void test__remainderf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = remainderf(arg1, x);
+void test__nextafterl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((nextafterl(arg1, arg2) > 10) || (nextafterl(arg1, arg2) < 100)) {}
 }
 
-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__nextafterl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = nextafterl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__remainderf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::remainderf(arg1, arg2);
+void test__nextafterl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = nextafterl(x, 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__nextafterl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = nextafterl(arg1, x);
 }
 
-void test__std__remainderf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::remainderf(x, 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__std__remainderf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::remainderf(arg1, x);
+void test__std__nextafterl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::nextafterl(arg1, 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__nextafterl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::nextafterl(arg1, arg2) > 10) || (std::nextafterl(arg1, arg2) < 100)) {}
 }
 
-void test__remainderl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  remainderl(arg1, arg2);
+void test__std__nextafterl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::nextafterl(x, arg2);
 }
 
-void test__remainderl__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((remainderl(arg1, arg2) > 10) || (remainderl(arg1, arg2) < 100)) {}
+void test__std__nextafterl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::nextafterl(arg1, x);
 }
 
-void test__remainderl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = remainderl(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__remainderl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = remainderl(x, arg2);
+void test__nexttoward__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    nexttoward(arg1, arg2);
 }
 
-void test__remainderl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = remainderl(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__remainderl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::remainderl(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__remainderl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::remainderl(arg1, arg2);
+void test__nexttoward__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = nexttoward(x, 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__nexttoward__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = nexttoward(arg1, x);
 }
 
-void test__std__remainderl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::remainderl(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__remainderl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::remainderl(arg1, x);
+void test__std__nexttoward__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::nexttoward(arg1, 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__std__nexttoward__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::nexttoward(arg1, arg2) > 10) || (std::nexttoward(arg1, arg2) < 100)) {}
 }
 
-void test__remquo__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  remquo(arg1, arg2, arg3);
+void test__std__nexttoward__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::nexttoward(x, arg2);
 }
 
-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__nexttoward__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::nexttoward(arg1, x);
 }
 
-void test__remquo__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = remquo(p, arg2, arg3);
-  // 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__remquo__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = remquo(x, arg2, arg3);
+void test__nexttowardf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    nexttowardf(arg1, arg2);
 }
 
-void test__remquo__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = remquo(arg1, x, arg3);
+void test__nexttowardf__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((nexttowardf(arg1, arg2) > 10) || (nexttowardf(arg1, arg2) < 100)) {}
 }
 
-void test__remquo__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = remquo(arg1, arg2, p);
+void test__nexttowardf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = nexttowardf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__nexttowardf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = nexttowardf(x, arg2);
 }
 
-void test__std__remquo__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::remquo(arg1, arg2, arg3);
+void test__nexttowardf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = nexttowardf(arg1, x);
 }
 
-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__std__nexttowardf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::nexttowardf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__remquo__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::remquo(x, arg2, arg3);
+void test__std__nexttowardf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::nexttowardf(arg1, arg2);
 }
 
-void test__std__remquo__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::remquo(arg1, x, arg3);
+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__std__remquo__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::remquo(arg1, arg2, p);
+void test__std__nexttowardf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::nexttowardf(x, arg2);
 }
 
-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__nexttowardf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::nexttowardf(arg1, x);
 }
 
-void test__remquof__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  remquof(arg1, arg2, arg3);
+void test__nexttowardl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = nexttowardl(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__nexttowardl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    nexttowardl(arg1, arg2);
 }
 
-void test__remquof__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = remquof(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__nexttowardl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((nexttowardl(arg1, arg2) > 10) || (nexttowardl(arg1, arg2) < 100)) {}
 }
 
-void test__remquof__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = remquof(x, arg2, arg3);
+void test__nexttowardl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = nexttowardl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__remquof__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = remquof(arg1, x, arg3);
+void test__nexttowardl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = nexttowardl(x, arg2);
 }
 
-void test__remquof__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = remquof(arg1, arg2, p);
+void test__nexttowardl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = nexttowardl(arg1, 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__std__nexttowardl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::nexttowardl(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__remquof__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::remquof(arg1, arg2, arg3);
+void test__std__nexttowardl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::nexttowardl(arg1, arg2);
 }
 
-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__std__nexttowardl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::nexttowardl(arg1, arg2) > 10) || (std::nexttowardl(arg1, arg2) < 100)) {}
 }
 
-void test__std__remquof__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::remquof(x, arg2, arg3);
+void test__std__nexttowardl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::nexttowardl(x, arg2);
 }
 
-void test__std__remquof__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::remquof(arg1, x, arg3);
+void test__std__nexttowardl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::nexttowardl(arg1, x);
 }
 
-void test__std__remquof__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::remquof(arg1, arg2, p);
+void test__longjmp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        longjmp(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__remquol__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = remquol(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__remquol__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  remquol(arg1, arg2, arg3);
+void test__longjmp__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    longjmp(x, arg2);
 }
 
-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__longjmp__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    longjmp(arg1, x);
 }
 
-void test__remquol__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = remquol(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__longjmp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::longjmp(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__remquol__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = remquol(x, arg2, arg3);
+void test__std__longjmp__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::longjmp(x, arg2);
 }
 
-void test__remquol__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = remquol(arg1, x, arg3);
+void test__std__longjmp__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::longjmp(arg1, x);
 }
 
-void test__remquol__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = remquol(arg1, arg2, p);
+void test__malloc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = malloc(arg1);
+    }
+    // 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__malloc__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    malloc(arg1);
 }
 
-void test__std__remquol__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::remquol(arg1, arg2, arg3);
+void test__malloc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = malloc(x);
 }
 
-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__malloc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::malloc(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__remquol__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::remquol(x, arg2, arg3);
+void test__std__malloc__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::malloc(arg1);
 }
 
-void test__std__remquol__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::remquol(arg1, x, arg3);
+void test__std__malloc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::malloc(x);
 }
 
-void test__std__remquol__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::remquol(arg1, arg2, p);
+void test__alloca__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = alloca(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__printf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; printf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__alloca__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    alloca(arg1);
 }
 
-void test__printf__leakignore() {
-  char *p = malloc(10); *p=0;
-  printf(p);
-  // cppcheck-suppress memleak
+void test__alloca__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = alloca(x);
 }
 
-void test__printf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  printf(x);
+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__printf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::printf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__memchr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    memchr(arg1, arg2, arg3);
 }
 
-void test__std__printf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::printf(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__vprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; vprintf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__memchr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = memchr(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__vprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  vprintf(p, arg2);
-  // cppcheck-suppress memleak
+void test__memchr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = memchr(NULL, arg2, arg3);
 }
 
-void test__vprintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  vprintf(x, arg2);
+void test__memchr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = memchr(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__memchr__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = memchr(arg1, !x, arg3);
 }
 
-void test__std__vprintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::vprintf(x, arg2);
+void test__memchr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = memchr(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__memchr__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = memchr(arg1, arg2, !x);
 }
 
-void test__vwprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  vwprintf(p, arg2);
-  // cppcheck-suppress memleak
+void test__memchr__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = memchr(arg1, arg2, x);
 }
 
-void test__vwprintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  vwprintf(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__std__vwprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::vwprintf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__memchr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::memchr(arg1, arg2, arg3);
 }
 
-void test__std__vwprintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::vwprintf(x, arg2);
+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__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__memchr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::memchr(NULL, arg2, arg3);
 }
 
-void test__bsearch__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  bsearch(arg1, arg2, arg3, arg4, arg5);
+void test__std__memchr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::memchr(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__memchr__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = std::memchr(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__memchr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::memchr(arg1, x, arg3);
 }
 
-void test__bsearch__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = bsearch(p, arg2, arg3, arg4, arg5);
+void test__std__memchr__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = std::memchr(arg1, arg2, !x);
 }
 
-void test__bsearch__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = bsearch(x, arg2, arg3, arg4, arg5);
+void test__std__memchr__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::memchr(arg1, arg2, x);
 }
 
-void test__bsearch__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = bsearch(arg1, p, arg3, arg4, arg5);
+void test__wmemchr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wmemchr(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__wmemchr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wmemchr(arg1, arg2, arg3);
 }
 
-void test__bsearch__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = bsearch(arg1, arg2, x, arg4, arg5);
+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__bsearch__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = bsearch(arg1, arg2, arg3, x, arg5);
+void test__wmemchr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wmemchr(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__bsearch__arg5__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = bsearch(arg1, arg2, arg3, arg4, p);
+void test__wmemchr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wmemchr(NULL, arg2, arg3);
 }
 
-void test__bsearch__arg5__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = bsearch(arg1, arg2, arg3, arg4, x);
+void test__wmemchr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wmemchr(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__wmemchr__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = wmemchr(arg1, !x, arg3);
 }
 
-void test__std__bsearch__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::bsearch(arg1, arg2, arg3, arg4, arg5);
+void test__wmemchr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = wmemchr(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__wmemchr__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = wmemchr(arg1, arg2, !x);
 }
 
-void test__std__bsearch__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::bsearch(p, arg2, arg3, arg4, arg5);
+void test__wmemchr__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = wmemchr(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__wmemchr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::wmemchr(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__bsearch__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::bsearch(arg1, p, arg3, arg4, arg5);
+void test__std__wmemchr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wmemchr(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__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__std__bsearch__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::bsearch(arg1, arg2, x, arg4, arg5);
+void test__std__wmemchr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wmemchr(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__wmemchr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wmemchr(x, arg2, arg3);
 }
 
-void test__std__bsearch__arg5__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::bsearch(arg1, arg2, arg3, arg4, p);
+void test__std__wmemchr__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = std::wmemchr(arg1, !x, arg3);
 }
 
-void test__std__bsearch__arg5__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::bsearch(arg1, arg2, arg3, arg4, x);
+void test__std__wmemchr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wmemchr(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__wmemchr__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = std::wmemchr(arg1, arg2, !x);
 }
 
-void test__qsort__leakignore() {
-  char *p = malloc(10); *p=0;
-  qsort(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__std__wmemchr__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wmemchr(arg1, arg2, x);
 }
 
-void test__qsort__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  qsort(p, arg2, arg3, arg4);
+void test__memcmp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = memcmp(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__memcmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    memcmp(arg1, arg2, arg3);
 }
 
-void test__qsort__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  qsort(arg1, x, arg3, arg4);
+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__qsort__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  qsort(arg1, arg2, x, arg4);
+void test__memcmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = memcmp(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__qsort__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  qsort(arg1, arg2, arg3, p);
+void test__memcmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = memcmp(NULL, arg2, arg3);
 }
 
-void test__qsort__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  qsort(arg1, arg2, arg3, x);
+void test__memcmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = memcmp(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__memcmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = memcmp(arg1, NULL, arg3);
 }
 
-void test__std__qsort__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::qsort(p, arg2, arg3, arg4);
+void test__memcmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = memcmp(arg1, x, arg3);
 }
 
-void test__std__qsort__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::qsort(x, arg2, arg3, arg4);
+void test__memcmp__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = memcmp(arg1, arg2, !x);
 }
 
-void test__std__qsort__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::qsort(arg1, x, arg3, arg4);
+void test__memcmp__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = memcmp(arg1, arg2, x);
 }
 
-void test__std__qsort__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::qsort(arg1, arg2, x, arg4);
+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__qsort__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::qsort(arg1, arg2, arg3, p);
+void test__std__memcmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::memcmp(arg1, arg2, arg3);
 }
 
-void test__std__qsort__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::qsort(arg1, arg2, arg3, 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__putc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; putc(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__memcmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::memcmp(NULL, arg2, arg3);
 }
 
-void test__putc__leakignore() {
-  char *p = malloc(10); *p=0;
-  putc(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__memcmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::memcmp(x, arg2, arg3);
 }
 
-void test__putc__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  putc(!x, arg2);
+void test__std__memcmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::memcmp(arg1, NULL, arg3);
 }
 
-void test__putc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  putc(x, arg2);
+void test__std__memcmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::memcmp(arg1, x, arg3);
 }
 
-void test__putc__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  putc(arg1, p);
+void test__std__memcmp__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = std::memcmp(arg1, arg2, !x);
 }
 
-void test__putc__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  putc(arg1, x);
+void test__std__memcmp__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::memcmp(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__wmemcmp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wmemcmp(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__putc__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::putc(!x, arg2);
+void test__wmemcmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wmemcmp(arg1, arg2, arg3);
 }
 
-void test__std__putc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::putc(x, arg2);
+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__putc__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::putc(arg1, p);
+void test__wmemcmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wmemcmp(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__putc__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::putc(arg1, x);
+void test__wmemcmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wmemcmp(NULL, arg2, arg3);
 }
 
-void test__putwc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; putwc(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wmemcmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wmemcmp(x, arg2, arg3);
 }
 
-void test__putwc__leakignore() {
-  char *p = malloc(10); *p=0;
-  putwc(p, arg2);
-  // cppcheck-suppress memleak
+void test__wmemcmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wmemcmp(arg1, NULL, arg3);
 }
 
-void test__putwc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  putwc(x, arg2);
+void test__wmemcmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wmemcmp(arg1, x, arg3);
 }
 
-void test__putwc__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  putwc(arg1, p);
+void test__wmemcmp__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = wmemcmp(arg1, arg2, !x);
 }
 
-void test__putwc__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  putwc(arg1, x);
+void test__wmemcmp__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = wmemcmp(arg1, arg2, x);
 }
 
-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__wmemcmp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::wmemcmp(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__putwc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::putwc(x, arg2);
+void test__std__wmemcmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wmemcmp(arg1, arg2, arg3);
 }
 
-void test__std__putwc__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::putwc(arg1, p);
+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__putwc__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::putwc(arg1, x);
+void test__std__wmemcmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wmemcmp(NULL, arg2, arg3);
 }
 
-void test__putchar__noreturn() {
-  int x = 1;
-  if (cond) { x=100; putchar(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wmemcmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wmemcmp(x, arg2, arg3);
 }
 
-void test__putchar__leakignore() {
-  char *p = malloc(10); *p=0;
-  putchar(p);
-  // cppcheck-suppress memleak
+void test__std__wmemcmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wmemcmp(arg1, NULL, arg3);
 }
 
-void test__putchar__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  putchar(!x);
+void test__std__wmemcmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wmemcmp(arg1, x, arg3);
 }
 
-void test__putchar__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  putchar(x);
+void test__std__wmemcmp__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = std::wmemcmp(arg1, arg2, !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__wmemcmp__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wmemcmp(arg1, arg2, x);
 }
 
-void test__std__putchar__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::putchar(!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__putchar__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::putchar(x);
+void test__memcpy__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    memcpy(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__putwchar__noreturn() {
-  int x = 1;
-  if (cond) { x=100; putwchar(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__memcpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    memcpy(NULL, arg2, arg3);
 }
 
-void test__putwchar__leakignore() {
-  char *p = malloc(10); *p=0;
-  putwchar(p);
-  // cppcheck-suppress memleak
+void test__memcpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    memcpy(arg1, NULL, arg3);
 }
 
-void test__putwchar__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  putwchar(x);
+void test__memcpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    memcpy(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__memcpy__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    memcpy(arg1, arg2, !x);
 }
 
-void test__std__putwchar__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::putwchar(x);
+void test__memcpy__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    memcpy(arg1, arg2, x);
 }
 
-void test__puts__noreturn() {
-  int x = 1;
-  if (cond) { x=100; puts(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+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__puts__leakignore() {
-  char *p = malloc(10); *p=0;
-  puts(p);
-  // cppcheck-suppress memleak
+void test__std__memcpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::memcpy(NULL, arg2, arg3);
 }
 
-void test__puts__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  puts(!x);
+void test__std__memcpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::memcpy(arg1, NULL, arg3);
 }
 
-void test__puts__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  puts(p);
+void test__std__memcpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::memcpy(arg1, x, arg3);
 }
 
-void test__puts__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  puts(x);
+void test__std__memcpy__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::memcpy(arg1, arg2, !x);
 }
 
-void test__std__puts__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::puts(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__memcpy__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::memcpy(arg1, arg2, x);
 }
 
-void test__std__puts__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::puts(!x);
+void test__wmemcpy__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wmemcpy(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__puts__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::puts(p);
+void test__wmemcpy__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wmemcpy(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__puts__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::puts(x);
+void test__wmemcpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wmemcpy(NULL, arg2, arg3);
 }
 
-void test__realloc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; realloc(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wmemcpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wmemcpy(arg1, NULL, arg3);
 }
 
-void test__realloc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  realloc(x, arg2);
+void test__wmemcpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wmemcpy(arg1, x, arg3);
 }
 
-void test__realloc__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  realloc(arg1, x);
+void test__wmemcpy__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wmemcpy(arg1, arg2, !x);
 }
 
-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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wmemcpy(arg1, arg2, x);
 }
 
-void test__std__realloc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::realloc(x, arg2);
+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__realloc__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::realloc(arg1, x);
+void test__std__wmemcpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wmemcpy(NULL, arg2, arg3);
 }
 
-void test__remove__noreturn() {
-  int x = 1;
-  if (cond) { x=100; remove(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wmemcpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wmemcpy(arg1, NULL, arg3);
 }
 
-void test__remove__leakignore() {
-  char *p = malloc(10); *p=0;
-  remove(p);
-  // cppcheck-suppress memleak
+void test__std__wmemcpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wmemcpy(arg1, x, arg3);
 }
 
-void test__remove__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  remove(p);
+void test__std__wmemcpy__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::wmemcpy(arg1, arg2, !x);
 }
 
-void test__remove__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  remove(x);
+void test__std__wmemcpy__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wmemcpy(arg1, arg2, x);
 }
 
-void test__std__remove__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::remove(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__std__remove__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::remove(p);
+void test__memcpy_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    memcpy_s(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__std__remove__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::remove(x);
+void test__memcpy_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    memcpy_s(NULL, arg2, arg3, arg4);
 }
 
-void test__rename__noreturn() {
-  int x = 1;
-  if (cond) { x=100; rename(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__memcpy_s__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    memcpy_s(arg1, !x, arg3, arg4);
 }
 
-void test__rename__leakignore() {
-  char *p = malloc(10); *p=0;
-  rename(p, arg2);
-  // cppcheck-suppress memleak
+void test__memcpy_s__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    memcpy_s(arg1, x, arg3, arg4);
 }
 
-void test__rename__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  rename(p, arg2);
+void test__memcpy_s__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    memcpy_s(arg1, arg2, NULL, arg4);
 }
 
-void test__rename__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  rename(x, arg2);
+void test__memcpy_s__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    memcpy_s(arg1, arg2, x, arg4);
 }
 
-void test__rename__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  rename(arg1, p);
+void test__memcpy_s__arg4__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    memcpy_s(arg1, arg2, arg3, !x);
 }
 
-void test__rename__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  rename(arg1, x);
+void test__memcpy_s__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    memcpy_s(arg1, arg2, arg3, x);
 }
 
-void test__std__rename__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::rename(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__std__rename__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::rename(p, arg2);
+void test__wmemcpy_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wmemcpy_s(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__std__rename__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::rename(x, arg2);
+void test__wmemcpy_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wmemcpy_s(NULL, arg2, arg3, arg4);
 }
 
-void test__std__rename__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::rename(arg1, p);
+void test__wmemcpy_s__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wmemcpy_s(arg1, !x, arg3, arg4);
 }
 
-void test__std__rename__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::rename(arg1, x);
+void test__wmemcpy_s__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wmemcpy_s(arg1, x, arg3, arg4);
 }
 
-void test__rewind__noreturn() {
-  int x = 1;
-  if (cond) { x=100; rewind(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wmemcpy_s__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wmemcpy_s(arg1, arg2, NULL, arg4);
 }
 
-void test__rewind__leakignore() {
-  char *p = malloc(10); *p=0;
-  rewind(p);
-  // cppcheck-suppress memleak
+void test__wmemcpy_s__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wmemcpy_s(arg1, arg2, x, arg4);
 }
 
-void test__rewind__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  rewind(p);
+void test__wmemcpy_s__arg4__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wmemcpy_s(arg1, arg2, arg3, !x);
 }
 
-void test__rewind__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  rewind(x);
+void test__wmemcpy_s__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wmemcpy_s(arg1, arg2, arg3, x);
 }
 
-void test__std__rewind__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::rewind(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__rewind__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::rewind(p);
+void test__memmove__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    memmove(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__rewind__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::rewind(x);
+void test__memmove__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    memmove(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__memmove__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    memmove(arg1, NULL, arg3);
 }
 
-void test__round__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  round(arg1);
+void test__memmove__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    memmove(arg1, x, arg3);
 }
 
-void test__round__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((round(arg1) > 10) || (round(arg1) < 100)) {}
+void test__memmove__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    memmove(arg1, arg2, !x);
 }
 
-void test__round__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = round(p);
-  // cppcheck-suppress memleak
+void test__memmove__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    memmove(arg1, arg2, x);
 }
 
-void test__round__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = round(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__std__round__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::round(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__memmove__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::memmove(NULL, arg2, arg3);
 }
 
-void test__std__round__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::round(arg1);
+void test__std__memmove__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::memmove(arg1, NULL, arg3);
 }
 
-void test__std__round__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::round(arg1) > 10) || (std::round(arg1) < 100)) {}
+void test__std__memmove__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::memmove(arg1, x, arg3);
 }
 
-void test__std__round__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::round(x);
+void test__std__memmove__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::memmove(arg1, arg2, !x);
 }
 
-void test__roundf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = roundf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__memmove__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::memmove(arg1, arg2, x);
 }
 
-void test__roundf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  roundf(arg1);
+void test__wmemmove__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wmemmove(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__wmemmove__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wmemmove(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__roundf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = roundf(p);
-  // cppcheck-suppress memleak
+void test__wmemmove__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wmemmove(NULL, arg2, arg3);
 }
 
-void test__roundf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = roundf(x);
+void test__wmemmove__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wmemmove(arg1, NULL, 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__wmemmove__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wmemmove(arg1, x, arg3);
 }
 
-void test__std__roundf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::roundf(arg1);
+void test__wmemmove__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wmemmove(arg1, arg2, !x);
 }
 
-void test__std__roundf__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::roundf(arg1) > 10) || (std::roundf(arg1) < 100)) {}
+void test__wmemmove__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wmemmove(arg1, arg2, x);
 }
 
-void test__std__roundf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::roundf(x);
+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__roundl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = roundl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wmemmove__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wmemmove(NULL, arg2, arg3);
 }
 
-void test__roundl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  roundl(arg1);
+void test__std__wmemmove__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wmemmove(arg1, NULL, arg3);
 }
 
-void test__roundl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((roundl(arg1) > 10) || (roundl(arg1) < 100)) {}
+void test__std__wmemmove__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wmemmove(arg1, x, arg3);
 }
 
-void test__roundl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = roundl(p);
-  // cppcheck-suppress memleak
+void test__std__wmemmove__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::wmemmove(arg1, arg2, !x);
 }
 
-void test__roundl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = roundl(x);
+void test__std__wmemmove__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wmemmove(arg1, arg2, x);
 }
 
-void test__std__roundl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::roundl(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__std__roundl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::roundl(arg1);
+void test__memset_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    memset_s(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__std__roundl__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::roundl(arg1) > 10) || (std::roundl(arg1) < 100)) {}
+void test__memset_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    memset_s(NULL, arg2, arg3, arg4);
 }
 
-void test__std__roundl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::roundl(x);
+void test__memset_s__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    memset_s(arg1, x, arg3, arg4);
 }
 
-void test__scalbn__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = scalbn(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__memset_s__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    memset_s(arg1, arg2, x, arg4);
 }
 
-void test__scalbn__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  scalbn(arg1, arg2);
+void test__memset_s__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    memset_s(arg1, arg2, arg3, x);
 }
 
-void test__scalbn__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((scalbn(arg1, arg2) > 10) || (scalbn(arg1, arg2) < 100)) {}
+void test__memset__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        memset(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__scalbn__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = scalbn(p, arg2);
-  // cppcheck-suppress memleak
+void test__memset__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    memset(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__scalbn__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = scalbn(x, arg2);
+void test__memset__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    memset(NULL, arg2, arg3);
 }
 
-void test__scalbn__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = scalbn(arg1, x);
+void test__memset__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    memset(arg1, x, arg3);
 }
 
-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__memset__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    memset(arg1, arg2, !x);
 }
 
-void test__std__scalbn__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::scalbn(arg1, arg2);
+void test__memset__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    memset(arg1, arg2, 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__memset__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::memset(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__scalbn__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::scalbn(x, arg2);
+void test__std__memset__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::memset(NULL, arg2, arg3);
 }
 
-void test__std__scalbn__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::scalbn(arg1, x);
+void test__std__memset__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::memset(arg1, x, 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__memset__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::memset(arg1, arg2, !x);
 }
 
-void test__scalbnf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  scalbnf(arg1, arg2);
+void test__std__memset__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::memset(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__wmemset__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wmemset(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__scalbnf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = scalbnf(p, arg2);
-  // cppcheck-suppress memleak
+void test__wmemset__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wmemset(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__scalbnf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = scalbnf(x, arg2);
+void test__wmemset__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wmemset(NULL, arg2, arg3);
 }
 
-void test__scalbnf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = scalbnf(arg1, x);
+void test__wmemset__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wmemset(arg1, x, 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__wmemset__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wmemset(arg1, arg2, !x);
 }
 
-void test__std__scalbnf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::scalbnf(arg1, arg2);
+void test__wmemset__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wmemset(arg1, arg2, x);
 }
 
-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__std__wmemset__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::wmemset(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__scalbnf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::scalbnf(x, arg2);
+void test__std__wmemset__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wmemset(NULL, arg2, arg3);
 }
 
-void test__std__scalbnf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::scalbnf(arg1, x);
+void test__std__wmemset__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wmemset(arg1, x, arg3);
 }
 
-void test__scalbnl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = scalbnl(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wmemset__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::wmemset(arg1, arg2, !x);
 }
 
-void test__scalbnl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  scalbnl(arg1, arg2);
+void test__std__wmemset__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wmemset(arg1, arg2, x);
 }
 
-void test__scalbnl__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((scalbnl(arg1, arg2) > 10) || (scalbnl(arg1, arg2) < 100)) {}
+void test__mktime__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        mktime(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__scalbnl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = scalbnl(p, arg2);
-  // cppcheck-suppress memleak
+void test__mktime__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    mktime(p);
+    // cppcheck-suppress memleak
 }
 
-void test__scalbnl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = scalbnl(x, arg2);
+void test__mktime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    mktime(NULL);
 }
 
-void test__scalbnl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = scalbnl(arg1, x);
+void test__mktime__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    mktime(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__mktime__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::mktime(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__scalbnl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::scalbnl(arg1, arg2);
+void test__std__mktime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::mktime(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__std__mktime__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::mktime(x);
 }
 
-void test__std__scalbnl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::scalbnl(x, arg2);
+void test__mkxtime__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        mkxtime(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__scalbnl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::scalbnl(arg1, x);
+void test__mkxtime__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    mkxtime(p);
+    // 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__mkxtime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    mkxtime(NULL);
 }
 
-void test__scalbln__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  scalbln(arg1, arg2);
+void test__mkxtime__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    mkxtime(x);
 }
 
-void test__scalbln__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((scalbln(arg1, arg2) > 10) || (scalbln(arg1, arg2) < 100)) {}
+void test__modf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        modf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__scalbln__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = scalbln(p, arg2);
-  // cppcheck-suppress memleak
+void test__modf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    modf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__scalbln__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = scalbln(x, arg2);
+void test__modf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    modf(x, arg2);
 }
 
-void test__scalbln__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = scalbln(arg1, x);
+void test__modf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    modf(arg1, NULL);
 }
 
-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__modf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::modf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__scalbln__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::scalbln(arg1, arg2);
+void test__std__modf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::modf(x, arg2);
 }
 
-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__modf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::modf(arg1, NULL);
 }
 
-void test__std__scalbln__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::scalbln(x, arg2);
+void test__modff__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        modff(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__modff__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    modff(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__scalblnf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = scalblnf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__modff__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    modff(x, arg2);
 }
 
-void test__scalblnf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  scalblnf(arg1, arg2);
+void test__modff__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    modff(arg1, NULL);
 }
 
-void test__scalblnf__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((scalblnf(arg1, arg2) > 10) || (scalblnf(arg1, arg2) < 100)) {}
+void test__std__modff__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::modff(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__scalblnf__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = scalblnf(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__modff__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::modff(x, arg2);
 }
 
-void test__scalblnf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = scalblnf(x, arg2);
+void test__std__modff__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::modff(arg1, NULL);
 }
 
-void test__scalblnf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = scalblnf(arg1, x);
-}
+void test__modfl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        modfl(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
+}
 
-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__modfl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    modfl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__scalblnf__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::scalblnf(arg1, arg2);
+void test__modfl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    modfl(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__modfl__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    modfl(arg1, NULL);
 }
 
-void test__std__scalblnf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::scalblnf(x, 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__std__scalblnf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::scalblnf(arg1, x);
+void test__std__modfl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::modfl(x, arg2);
 }
 
-void test__scalblnl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = scalblnl(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__modfl__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::modfl(arg1, NULL);
 }
 
-void test__scalblnl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  scalblnl(arg1, arg2);
+void test__perror__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        perror(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__scalblnl__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((scalblnl(arg1, arg2) > 10) || (scalblnl(arg1, arg2) < 100)) {}
+void test__perror__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    perror(p);
+    // cppcheck-suppress memleak
 }
 
-void test__scalblnl__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = scalblnl(p, arg2);
-  // cppcheck-suppress memleak
+void test__perror__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    perror(x);
 }
 
-void test__scalblnl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = scalblnl(x, arg2);
+void test__std__perror__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::perror(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__scalblnl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = scalblnl(arg1, x);
+void test__std__perror__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::perror(x);
 }
 
-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__pow__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = pow(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__scalblnl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::scalblnl(arg1, arg2);
+void test__pow__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    pow(arg1, 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__pow__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((pow(arg1, arg2) > 10) || (pow(arg1, arg2) < 100)) {}
 }
 
-void test__std__scalblnl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::scalblnl(x, arg2);
+void test__pow__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = pow(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__scalblnl__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::scalblnl(arg1, x);
+void test__pow__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = pow(x, arg2);
 }
 
-void test__signbit__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = signbit(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__pow__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = pow(arg1, x);
 }
 
-void test__signbit__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  signbit(arg1);
+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__signbit__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((signbit(arg1) > 10) || (signbit(arg1) < 100)) {}
+void test__std__pow__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::pow(arg1, arg2);
 }
 
-void test__signbit__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = signbit(p);
-  // cppcheck-suppress memleak
+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__signbit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = signbit(x);
+void test__std__pow__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::pow(x, 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__std__pow__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::pow(arg1, x);
 }
 
-void test__std__signbit__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::signbit(arg1);
+void test__powf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = powf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__signbit__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::signbit(arg1) > 10) || (std::signbit(arg1) < 100)) {}
+void test__powf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    powf(arg1, arg2);
 }
 
-void test__std__signbit__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::signbit(x);
+void test__powf__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((powf(arg1, arg2) > 10) || (powf(arg1, arg2) < 100)) {}
 }
 
-void test__signal__noreturn() {
-  int x = 1;
-  if (cond) { x=100; signal(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__powf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = powf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__signal__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  signal(x, arg2);
+void test__powf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = powf(x, 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__powf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = powf(arg1, x);
 }
 
-void test__std__signal__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::signal(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__raise__noreturn() {
-  int x = 1;
-  if (cond) { x=100; raise(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__powf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::powf(arg1, arg2);
 }
 
-void test__raise__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  raise(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__raise__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::raise(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__powf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::powf(x, arg2);
 }
 
-void test__std__raise__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::raise(x);
+void test__std__powf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::powf(arg1, x);
 }
 
-void test__scanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; scanf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__powl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = powl(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__scanf__leakignore() {
-  char *p = malloc(10); *p=0;
-  scanf(p);
-  // cppcheck-suppress memleak
+void test__powl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    powl(arg1, arg2);
 }
 
-void test__scanf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  scanf(p);
+void test__powl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((powl(arg1, arg2) > 10) || (powl(arg1, arg2) < 100)) {}
 }
 
-void test__scanf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  scanf(x);
+void test__powl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = powl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__scanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::scanf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__powl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = powl(x, arg2);
 }
 
-void test__std__scanf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::scanf(p);
+void test__powl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = powl(arg1, x);
 }
 
-void test__std__scanf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::scanf(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__vsscanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; vsscanf(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__powl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::powl(arg1, arg2);
 }
 
-void test__vsscanf__leakignore() {
-  char *p = malloc(10); *p=0;
-  vsscanf(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__vsscanf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vsscanf(p, arg2, arg3);
+void test__std__powl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::powl(x, arg2);
 }
 
-void test__vsscanf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  vsscanf(x, arg2, arg3);
+void test__std__powl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::powl(arg1, x);
 }
 
-void test__vsscanf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vsscanf(arg1, p, arg3);
+void test__cpow__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cpow(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__vsscanf__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  vsscanf(arg1, x, arg3);
+void test__cpow__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cpow(arg1, 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__cpow__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cpow(arg1, arg2) > 10) || (cpow(arg1, arg2) < 100)) {}
 }
 
-void test__std__vsscanf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::vsscanf(p, arg2, arg3);
+void test__cpow__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cpow(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__vsscanf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::vsscanf(x, arg2, arg3);
+void test__cpow__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cpow(x, arg2);
 }
 
-void test__std__vsscanf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::vsscanf(arg1, p, arg3);
+void test__cpow__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cpow(arg1, x);
 }
 
-void test__std__vsscanf__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::vsscanf(arg1, x, arg3);
+void test__cpowf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cpowf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__vswscanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; vswscanf(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__cpowf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cpowf(arg1, arg2);
 }
 
-void test__vswscanf__leakignore() {
-  char *p = malloc(10); *p=0;
-  vswscanf(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__cpowf__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cpowf(arg1, arg2) > 10) || (cpowf(arg1, arg2) < 100)) {}
 }
 
-void test__vswscanf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vswscanf(p, arg2, arg3);
+void test__cpowf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cpowf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__vswscanf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  vswscanf(x, arg2, arg3);
+void test__cpowf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cpowf(x, arg2);
 }
 
-void test__vswscanf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vswscanf(arg1, p, arg3);
+void test__cpowf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cpowf(arg1, x);
 }
 
-void test__vswscanf__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  vswscanf(arg1, x, arg3);
+void test__cpowl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = cpowl(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__cpowl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cpowl(arg1, arg2);
 }
 
-void test__std__vswscanf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::vswscanf(p, arg2, arg3);
+void test__cpowl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((cpowl(arg1, arg2) > 10) || (cpowl(arg1, arg2) < 100)) {}
 }
 
-void test__std__vswscanf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::vswscanf(x, arg2, arg3);
+void test__cpowl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = cpowl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__vswscanf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::vswscanf(arg1, p, arg3);
+void test__cpowl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cpowl(x, arg2);
 }
 
-void test__std__vswscanf__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::vswscanf(arg1, x, arg3);
+void test__cpowl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = cpowl(arg1, x);
 }
 
-void test__vscanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; vscanf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__remainder__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = remainder(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__vscanf__leakignore() {
-  char *p = malloc(10); *p=0;
-  vscanf(p, arg2);
-  // cppcheck-suppress memleak
+void test__remainder__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    remainder(arg1, arg2);
 }
 
-void test__vscanf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vscanf(p, arg2);
+void test__remainder__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((remainder(arg1, arg2) > 10) || (remainder(arg1, arg2) < 100)) {}
 }
 
-void test__vscanf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  vscanf(x, arg2);
+void test__remainder__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = remainder(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__vscanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::vscanf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__remainder__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = remainder(x, arg2);
 }
 
-void test__std__vscanf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::vscanf(p, arg2);
+void test__remainder__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = remainder(arg1, x);
 }
 
-void test__std__vscanf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::vscanf(x, arg2);
+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__vwscanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; vwscanf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__remainder__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::remainder(arg1, arg2);
 }
 
-void test__vwscanf__leakignore() {
-  char *p = malloc(10); *p=0;
-  vwscanf(p, arg2);
-  // cppcheck-suppress memleak
+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__vwscanf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vwscanf(p, arg2);
+void test__std__remainder__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::remainder(x, arg2);
 }
 
-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__remainder__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::remainder(arg1, x);
 }
 
-void test__std__vwscanf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::vwscanf(p, arg2);
+void test__remainderf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = remainderf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__setbuf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; setbuf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__remainderf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    remainderf(arg1, arg2);
 }
 
-void test__setbuf__leakignore() {
-  char *p = malloc(10); *p=0;
-  setbuf(p, arg2);
-  // cppcheck-suppress memleak
+void test__remainderf__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((remainderf(arg1, arg2) > 10) || (remainderf(arg1, arg2) < 100)) {}
 }
 
-void test__setbuf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  setbuf(p, arg2);
+void test__remainderf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = remainderf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__setbuf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  setbuf(x, arg2);
+void test__remainderf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = remainderf(x, arg2);
 }
 
-void test__setbuf__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  setbuf(arg1, !x);
+void test__remainderf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = remainderf(arg1, x);
 }
 
-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__remainderf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::remainderf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__setbuf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::setbuf(p, arg2);
+void test__std__remainderf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::remainderf(arg1, arg2);
 }
 
-void test__std__setbuf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::setbuf(x, 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__std__setbuf__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::setbuf(arg1, !x);
+void test__std__remainderf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::remainderf(x, arg2);
 }
 
-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__remainderf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::remainderf(arg1, x);
 }
 
-void test__setvbuf__leakignore() {
-  char *p = malloc(10); *p=0;
-  setvbuf(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__remainderl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = remainderl(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__setvbuf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  setvbuf(p, arg2, arg3, arg4);
+void test__remainderl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    remainderl(arg1, arg2);
 }
 
-void test__setvbuf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  setvbuf(x, arg2, arg3, arg4);
+void test__remainderl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((remainderl(arg1, arg2) > 10) || (remainderl(arg1, arg2) < 100)) {}
 }
 
-void test__setvbuf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setvbuf(arg1, x, arg3, arg4);
+void test__remainderl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = remainderl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__setvbuf__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setvbuf(arg1, arg2, x, arg4);
+void test__remainderl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = remainderl(x, arg2);
 }
 
-void test__setvbuf__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setvbuf(arg1, arg2, arg3, x);
+void test__remainderl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = remainderl(arg1, 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__std__remainderl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::remainderl(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__setvbuf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::setvbuf(p, arg2, arg3, arg4);
+void test__std__remainderl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::remainderl(arg1, arg2);
 }
 
-void test__std__setvbuf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::setvbuf(x, arg2, arg3, arg4);
+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__std__setvbuf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::setvbuf(arg1, x, arg3, arg4);
+void test__std__remainderl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::remainderl(x, arg2);
 }
 
-void test__std__setvbuf__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::setvbuf(arg1, arg2, x, arg4);
+void test__std__remainderl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::remainderl(arg1, x);
 }
 
-void test__std__setvbuf__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::setvbuf(arg1, arg2, arg3, x);
+void test__remquo__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = remquo(arg1, arg2, arg3);
+    }
+    // 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__remquo__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    remquo(arg1, arg2, arg3);
 }
 
-void test__setjmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  setjmp(p);
-  // cppcheck-suppress memleak
+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__strcat__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strcat(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__strcat__leakignore() {
-  char *p = malloc(10); *p=0;
-  strcat(p, arg2);
-  // cppcheck-suppress memleak
+void test__remquo__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = remquo(x, arg2, arg3);
 }
 
-void test__strcat__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strcat(p, arg2);
+void test__remquo__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = remquo(arg1, x, arg3);
 }
 
-void test__strcat__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strcat(x, arg2);
+void test__remquo__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = remquo(arg1, arg2, NULL);
 }
 
-void test__strcat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strcat(arg1, p);
+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__strcat__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strcat(arg1, x);
+void test__std__remquo__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::remquo(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__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__std__strcat__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strcat(p, arg2);
+void test__std__remquo__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::remquo(x, arg2, arg3);
 }
 
-void test__std__strcat__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strcat(x, arg2);
+void test__std__remquo__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::remquo(arg1, x, arg3);
 }
 
-void test__std__strcat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strcat(arg1, p);
+void test__std__remquo__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::remquo(arg1, arg2, NULL);
 }
 
-void test__std__strcat__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strcat(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__wcscat__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wcscat(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__remquof__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    remquof(arg1, arg2, arg3);
 }
 
-void test__wcscat__leakignore() {
-  char *p = malloc(10); *p=0;
-  wcscat(p, arg2);
-  // cppcheck-suppress memleak
+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__wcscat__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcscat(p, arg2);
+void test__remquof__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = remquof(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__wcscat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcscat(arg1, p);
+void test__remquof__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = remquof(x, arg2, arg3);
 }
 
-void test__wcscat__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcscat(arg1, x);
+void test__remquof__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = remquof(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__remquof__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = remquof(arg1, arg2, NULL);
 }
 
-void test__std__wcscat__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcscat(p, arg2);
+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__std__wcscat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcscat(arg1, p);
+void test__std__remquof__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::remquof(arg1, arg2, arg3);
 }
 
-void test__std__wcscat__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wcscat(arg1, 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__wcrtomb__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wcrtomb(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__wcrtomb__leakignore() {
-  char *p = malloc(10); *p=0;
-  wcrtomb(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__remquof__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::remquof(arg1, x, arg3);
 }
 
-void test__wcrtomb__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wcrtomb(arg1, x, arg3);
+void test__std__remquof__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::remquof(arg1, arg2, NULL);
 }
 
-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__remquol__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = remquol(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__wcrtomb__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wcrtomb(arg1, x, arg3);
+void test__remquol__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    remquol(arg1, arg2, arg3);
 }
 
-void test__strchr__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = strchr(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__strchr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  strchr(arg1, arg2);
+void test__remquol__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = remquol(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__strchr__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = strchr(p, arg2);
-  // cppcheck-suppress memleak
+void test__remquol__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = remquol(x, arg2, arg3);
 }
 
-void test__strchr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strchr(p, arg2);
+void test__remquol__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = remquol(arg1, x, arg3);
 }
 
-void test__strchr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strchr(x, arg2);
+void test__remquol__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = remquol(arg1, arg2, NULL);
 }
 
-void test__strchr__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = strchr(arg1, 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__strchr__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::strchr(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__remquol__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::remquol(arg1, arg2, arg3);
 }
 
-void test__std__strchr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::strchr(arg1, 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__std__strchr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strchr(p, arg2);
+void test__std__remquol__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::remquol(x, arg2, arg3);
 }
 
-void test__std__strchr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strchr(x, arg2);
+void test__std__remquol__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::remquol(arg1, x, arg3);
 }
 
-void test__std__strchr__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::strchr(arg1, x);
+void test__std__remquol__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::remquol(arg1, arg2, NULL);
 }
 
-void test__wcschr__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wcschr(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__printf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        printf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcschr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcschr(arg1, arg2);
+void test__printf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    printf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wcschr__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcschr(p, arg2);
-  // cppcheck-suppress memleak
+void test__printf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    printf(x);
 }
 
-void test__wcschr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcschr(p, arg2);
+void test__std__printf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::printf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
-
-void test__wcschr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcschr(x, arg2);
+
+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__wcschr__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wcschr(arg1, x);
-}
+void test__vprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    vprintf(p, arg2);
+    // cppcheck-suppress memleak
+}
 
-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__vprintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    vprintf(x, arg2);
 }
 
-void test__std__wcschr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wcschr(arg1, arg2);
+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__std__wcschr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcschr(p, arg2);
+void test__vwprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    vwprintf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wcschr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcschr(x, arg2);
+void test__vwprintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    vwprintf(x, arg2);
 }
 
-void test__std__wcschr__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wcschr(arg1, 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__strcmp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = strcmp(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__vwprintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::vwprintf(x, arg2);
 }
 
-void test__strcmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  strcmp(arg1, 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__strcmp__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((strcmp(arg1, arg2) > 10) || (strcmp(arg1, arg2) < 100)) {}
+void test__bsearch__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    bsearch(arg1, arg2, arg3, arg4, arg5);
 }
 
-void test__strcmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = strcmp(p, arg2);
-  // cppcheck-suppress memleak
+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__strcmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strcmp(p, arg2);
+void test__bsearch__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = bsearch(p, arg2, arg3, arg4, arg5);
+    // cppcheck-suppress memleak
 }
 
-void test__strcmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strcmp(x, arg2);
+void test__bsearch__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = bsearch(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test__strcmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strcmp(arg1, p);
+void test__bsearch__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = bsearch(x, arg2, arg3, arg4, arg5);
 }
 
-void test__strcmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strcmp(arg1, x);
+void test__bsearch__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = bsearch(arg1, NULL, arg3, arg4, arg5);
 }
 
-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__bsearch__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = bsearch(arg1, x, arg3, arg4, arg5);
 }
 
-void test__std__strcmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::strcmp(arg1, arg2);
+void test__bsearch__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = bsearch(arg1, arg2, x, arg4, arg5);
 }
 
-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__bsearch__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = bsearch(arg1, arg2, arg3, x, arg5);
 }
 
-void test__std__strcmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strcmp(p, arg2);
+void test__bsearch__arg5__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = bsearch(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test__std__strcmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strcmp(x, arg2);
+void test__bsearch__arg5__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = bsearch(arg1, arg2, arg3, arg4, x);
 }
 
-void test__std__strcmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strcmp(arg1, p);
+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__strcmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strcmp(arg1, x);
+void test__std__bsearch__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::bsearch(arg1, arg2, arg3, arg4, arg5);
 }
 
-void test__wcscmp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wcscmp(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+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__wcscmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcscmp(arg1, arg2);
+void test__std__bsearch__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::bsearch(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test__wcscmp__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((wcscmp(arg1, arg2) > 10) || (wcscmp(arg1, arg2) < 100)) {}
+void test__std__bsearch__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::bsearch(x, arg2, arg3, arg4, arg5);
 }
 
-void test__wcscmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcscmp(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__bsearch__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::bsearch(arg1, NULL, arg3, arg4, arg5);
 }
 
-void test__wcscmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcscmp(p, arg2);
+void test__std__bsearch__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::bsearch(arg1, x, arg3, arg4, arg5);
 }
 
-void test__wcscmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcscmp(x, arg2);
+void test__std__bsearch__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::bsearch(arg1, arg2, x, arg4, arg5);
 }
 
-void test__wcscmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcscmp(arg1, p);
+void test__std__bsearch__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::bsearch(arg1, arg2, arg3, x, arg5);
 }
 
-void test__wcscmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcscmp(arg1, x);
+void test__std__bsearch__arg5__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::bsearch(arg1, arg2, arg3, arg4, NULL);
 }
 
-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__bsearch__arg5__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::bsearch(arg1, arg2, arg3, arg4, x);
 }
 
-void test__std__wcscmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wcscmp(arg1, 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__std__wcscmp__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::wcscmp(arg1, arg2) > 10) || (std::wcscmp(arg1, arg2) < 100)) {}
+void test__qsort__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    qsort(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wcscmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcscmp(p, arg2);
+void test__qsort__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    qsort(NULL, arg2, arg3, arg4);
 }
 
-void test__std__wcscmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcscmp(x, arg2);
+void test__qsort__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    qsort(x, arg2, arg3, arg4);
 }
 
-void test__std__wcscmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcscmp(arg1, p);
+void test__qsort__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    qsort(arg1, x, arg3, arg4);
 }
 
-void test__std__wcscmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcscmp(arg1, x);
+void test__qsort__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    qsort(arg1, arg2, x, arg4);
 }
 
-void test__strcpy__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strcpy(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__qsort__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    qsort(arg1, arg2, arg3, NULL);
 }
 
-void test__strcpy__leakignore() {
-  char *p = malloc(10); *p=0;
-  strcpy(p, arg2);
-  // cppcheck-suppress memleak
+void test__qsort__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    qsort(arg1, arg2, arg3, x);
 }
 
-void test__strcpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strcpy(p, arg2);
+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__strcpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strcpy(arg1, p);
+void test__std__qsort__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::qsort(NULL, arg2, arg3, arg4);
 }
 
-void test__strcpy__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strcpy(arg1, x);
+void test__std__qsort__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::qsort(x, arg2, arg3, arg4);
 }
 
-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__qsort__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::qsort(arg1, x, arg3, arg4);
 }
 
-void test__std__strcpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strcpy(p, arg2);
+void test__std__qsort__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::qsort(arg1, arg2, x, arg4);
 }
 
-void test__std__strcpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strcpy(arg1, p);
+void test__std__qsort__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::qsort(arg1, arg2, arg3, NULL);
 }
 
-void test__std__strcpy__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strcpy(arg1, x);
+void test__std__qsort__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::qsort(arg1, arg2, arg3, x);
 }
 
-void test__wcscpy__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wcscpy(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__putc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        putc(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcscpy__leakignore() {
-  char *p = malloc(10); *p=0;
-  wcscpy(p, arg2);
-  // cppcheck-suppress memleak
+void test__putc__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    putc(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__wcscpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcscpy(p, arg2);
+void test__putc__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    putc(!x, arg2);
 }
 
-void test__wcscpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcscpy(arg1, p);
+void test__putc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    putc(x, arg2);
 }
 
-void test__wcscpy__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcscpy(arg1, x);
+void test__putc__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    putc(arg1, NULL);
 }
 
-void test__std__wcscpy__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::wcscpy(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__putc__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    putc(arg1, x);
 }
 
-void test__std__wcscpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcscpy(p, 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__wcscpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcscpy(arg1, p);
+void test__std__putc__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::putc(!x, arg2);
 }
 
-void test__std__wcscpy__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wcscpy(arg1, x);
+void test__std__putc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::putc(x, arg2);
 }
 
-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__putc__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::putc(arg1, NULL);
 }
 
-void test__strftime__leakignore() {
-  char *p = malloc(10); *p=0;
-  strftime(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__std__putc__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::putc(arg1, x);
 }
 
-void test__strftime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strftime(p, arg2, arg3, arg4);
+void test__putwc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        putwc(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strftime__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strftime(arg1, x, arg3, arg4);
+void test__putwc__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    putwc(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__strftime__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strftime(arg1, arg2, p, arg4);
+void test__putwc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    putwc(x, arg2);
 }
 
-void test__strftime__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strftime(arg1, arg2, x, arg4);
+void test__putwc__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    putwc(arg1, NULL);
 }
 
-void test__strftime__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strftime(arg1, arg2, arg3, p);
+void test__putwc__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    putwc(arg1, x);
 }
 
-void test__strftime__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strftime(arg1, arg2, arg3, x);
+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__strftime__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::strftime(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__putwc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::putwc(x, arg2);
 }
 
-void test__std__strftime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strftime(p, arg2, arg3, arg4);
+void test__std__putwc__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::putwc(arg1, NULL);
 }
 
-void test__std__strftime__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::strftime(arg1, x, arg3, arg4);
+void test__std__putwc__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::putwc(arg1, x);
 }
 
-void test__std__strftime__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strftime(arg1, arg2, p, arg4);
+void test__putchar__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        putchar(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__strftime__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strftime(arg1, arg2, x, arg4);
-}
+void test__putchar__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    putchar(p);
+    // cppcheck-suppress memleak
+}
 
-void test__std__strftime__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strftime(arg1, arg2, arg3, p);
-}
+void test__putchar__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    putchar(!x);
+}
 
-void test__std__strftime__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strftime(arg1, arg2, arg3, x);
+void test__putchar__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    putchar(x);
 }
 
-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__putchar__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::putchar(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strfxtime__leakignore() {
-  char *p = malloc(10); *p=0;
-  strfxtime(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__std__putchar__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::putchar(!x);
 }
 
-void test__strfxtime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strfxtime(p, arg2, arg3, arg4);
+void test__std__putchar__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::putchar(x);
 }
 
-void test__strfxtime__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strfxtime(arg1, x, arg3, arg4);
+void test__putwchar__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        putwchar(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strfxtime__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strfxtime(arg1, arg2, p, arg4);
+void test__putwchar__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    putwchar(p);
+    // cppcheck-suppress memleak
 }
 
-void test__strfxtime__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strfxtime(arg1, arg2, x, arg4);
+void test__putwchar__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    putwchar(x);
 }
 
-void test__strfxtime__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strfxtime(arg1, arg2, arg3, p);
+void test__std__putwchar__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::putwchar(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strfxtime__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strfxtime(arg1, arg2, arg3, x);
+void test__std__putwchar__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::putwchar(x);
 }
-
-void test__strlen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = strlen(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+
+void test__puts__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        puts(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strlen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  strlen(arg1);
+void test__puts__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    puts(p);
+    // cppcheck-suppress memleak
 }
 
-void test__strlen__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((strlen(arg1) > 10) || (strlen(arg1) < 100)) {}
+void test__puts__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    puts(!x);
 }
-
-void test__strlen__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = strlen(p);
-  // cppcheck-suppress memleak
+
+void test__puts__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    puts(NULL);
 }
 
-void test__strlen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strlen(p);
+void test__puts__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    puts(x);
 }
 
-void test__strlen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strlen(x);
+void test__std__puts__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::puts(arg1);
+    }
+    // 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__std__puts__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::puts(!x);
 }
 
-void test__std__strlen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::strlen(arg1);
-}
+void test__std__puts__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::puts(NULL);
+}
 
-void test__std__strlen__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::strlen(arg1) > 10) || (std::strlen(arg1) < 100)) {}
+void test__std__puts__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::puts(x);
 }
 
-void test__std__strlen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strlen(p);
+void test__realloc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        realloc(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__realloc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    realloc(x, arg2);
 }
 
-void test__wcslen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wcslen(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__realloc__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    realloc(arg1, x);
 }
 
-void test__wcslen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcslen(arg1);
+void test__std__realloc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::realloc(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcslen__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((wcslen(arg1) > 10) || (wcslen(arg1) < 100)) {}
+void test__std__realloc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::realloc(x, arg2);
 }
 
-void test__wcslen__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcslen(p);
-  // cppcheck-suppress memleak
+void test__std__realloc__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::realloc(arg1, x);
 }
 
-void test__wcslen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcslen(p);
+void test__remove__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        remove(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcslen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcslen(x);
+void test__remove__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    remove(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wcslen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::wcslen(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__remove__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    remove(NULL);
 }
 
-void test__std__wcslen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wcslen(arg1);
+void test__remove__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    remove(x);
 }
 
-void test__std__wcslen__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::wcslen(arg1) > 10) || (std::wcslen(arg1) < 100)) {}
+void test__std__remove__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::remove(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__wcslen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcslen(p);
+void test__std__remove__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::remove(NULL);
 }
 
-void test__std__wcslen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcslen(x);
+void test__std__remove__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::remove(x);
 }
 
-void test__strncpy__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strncpy(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__rename__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        rename(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__rename__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    rename(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__strncpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strncpy(p, arg2, arg3);
+void test__rename__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    rename(NULL, arg2);
 }
 
-void test__strncpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strncpy(arg1, p, arg3);
+void test__rename__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    rename(x, arg2);
 }
 
-void test__strncpy__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strncpy(arg1, x, arg3);
+void test__rename__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    rename(arg1, NULL);
 }
 
-void test__strncpy__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  strncpy(arg1, arg2, !x);
+void test__rename__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    rename(arg1, x);
 }
 
-void test__strncpy__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strncpy(arg1, arg2, x);
+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__strncpy__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::strncpy(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__rename__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::rename(NULL, arg2);
 }
 
-void test__std__strncpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strncpy(p, arg2, arg3);
+void test__std__rename__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::rename(x, arg2);
 }
 
-void test__std__strncpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strncpy(arg1, p, arg3);
+void test__std__rename__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::rename(arg1, NULL);
 }
 
-void test__std__strncpy__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strncpy(arg1, x, arg3);
+void test__std__rename__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::rename(arg1, x);
 }
 
-void test__std__strncpy__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::strncpy(arg1, arg2, !x);
+void test__rewind__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        rewind(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__strncpy__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::strncpy(arg1, arg2, x);
+void test__rewind__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    rewind(p);
+    // cppcheck-suppress memleak
 }
 
-void test__strpbrk__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = strpbrk(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__rewind__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    rewind(NULL);
 }
 
-void test__strpbrk__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  strpbrk(arg1, arg2);
+void test__rewind__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    rewind(x);
 }
 
-void test__strpbrk__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = strpbrk(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__rewind__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::rewind(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strpbrk__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strpbrk(p, arg2);
+void test__std__rewind__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::rewind(NULL);
 }
 
-void test__strpbrk__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strpbrk(x, arg2);
+void test__std__rewind__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::rewind(x);
 }
 
-void test__strpbrk__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strpbrk(arg1, p);
+void test__round__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = round(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strpbrk__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strpbrk(arg1, x);
+void test__round__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    round(arg1);
 }
 
-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__round__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((round(arg1) > 10) || (round(arg1) < 100)) {}
 }
 
-void test__std__strpbrk__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::strpbrk(arg1, arg2);
+void test__round__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = round(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__strpbrk__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strpbrk(p, arg2);
+void test__round__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = round(x);
 }
 
-void test__std__strpbrk__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strpbrk(x, arg2);
+void test__std__round__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::round(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__strpbrk__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strpbrk(arg1, p);
+void test__std__round__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::round(arg1);
 }
 
-void test__std__strpbrk__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strpbrk(arg1, x);
+void test__std__round__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::round(arg1) > 10) || (std::round(arg1) < 100)) {}
 }
 
-void test__strncat__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strncat(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__strncat__leakignore() {
-  char *p = malloc(10); *p=0;
-  strncat(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__roundf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = roundf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strncat__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strncat(p, arg2, arg3);
+void test__roundf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    roundf(arg1);
 }
 
-void test__strncat__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strncat(x, arg2, arg3);
+void test__roundf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((roundf(arg1) > 10) || (roundf(arg1) < 100)) {}
 }
 
-void test__strncat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strncat(arg1, p, arg3);
+void test__roundf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = roundf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__strncat__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strncat(arg1, x, arg3);
+void test__roundf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = roundf(x);
 }
 
-void test__strncat__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  strncat(arg1, arg2, !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__strncat__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strncat(arg1, arg2, x);
+void test__std__roundf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::roundf(arg1);
 }
 
-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__roundf__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::roundf(arg1) > 10) || (std::roundf(arg1) < 100)) {}
 }
 
-void test__std__strncat__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strncat(p, arg2, arg3);
+void test__std__roundf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::roundf(x);
 }
 
-void test__std__strncat__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strncat(x, 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__strncat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strncat(arg1, p, arg3);
+void test__roundl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    roundl(arg1);
 }
 
-void test__std__strncat__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strncat(arg1, x, arg3);
+void test__roundl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((roundl(arg1) > 10) || (roundl(arg1) < 100)) {}
 }
 
-void test__std__strncat__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::strncat(arg1, arg2, !x);
+void test__roundl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = roundl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__strncat__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::strncat(arg1, arg2, x);
+void test__roundl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = roundl(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__roundl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::roundl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcsncat__leakignore() {
-  char *p = malloc(10); *p=0;
-  wcsncat(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__roundl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::roundl(arg1);
 }
 
-void test__wcsncat__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcsncat(p, arg2, arg3);
+void test__std__roundl__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::roundl(arg1) > 10) || (std::roundl(arg1) < 100)) {}
 }
 
-void test__wcsncat__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcsncat(x, arg2, arg3);
+void test__std__roundl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::roundl(x);
 }
 
-void test__wcsncat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcsncat(arg1, p, arg3);
+void test__scalbn__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = scalbn(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcsncat__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcsncat(arg1, x, arg3);
+void test__scalbn__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    scalbn(arg1, arg2);
 }
 
-void test__wcsncat__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  wcsncat(arg1, arg2, !x);
+void test__scalbn__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((scalbn(arg1, arg2) > 10) || (scalbn(arg1, arg2) < 100)) {}
 }
 
-void test__wcsncat__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wcsncat(arg1, arg2, x);
+void test__scalbn__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = scalbn(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__scalbn__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = scalbn(x, arg2);
 }
 
-void test__std__wcsncat__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcsncat(p, arg2, arg3);
+void test__scalbn__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = scalbn(arg1, x);
 }
 
-void test__std__wcsncat__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wcsncat(x, arg2, arg3);
+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__std__wcsncat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcsncat(arg1, p, arg3);
+void test__std__scalbn__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::scalbn(arg1, arg2);
 }
 
-void test__std__wcsncat__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wcsncat(arg1, x, arg3);
+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__wcsncat__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::wcsncat(arg1, arg2, !x);
+void test__std__scalbn__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::scalbn(x, arg2);
 }
 
-void test__std__wcsncat__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wcsncat(arg1, arg2, x);
+void test__std__scalbn__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::scalbn(arg1, x);
 }
 
-void test__strncmp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = strncmp(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__scalbnf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = scalbnf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strncmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  strncmp(arg1, arg2, arg3);
+void test__scalbnf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    scalbnf(arg1, 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__scalbnf__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((scalbnf(arg1, arg2) > 10) || (scalbnf(arg1, arg2) < 100)) {}
 }
 
-void test__strncmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = strncmp(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__scalbnf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = scalbnf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__strncmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strncmp(p, arg2, arg3);
+void test__scalbnf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = scalbnf(x, arg2);
 }
 
-void test__strncmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strncmp(x, arg2, arg3);
+void test__scalbnf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = scalbnf(arg1, x);
 }
 
-void test__strncmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strncmp(arg1, p, 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__strncmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strncmp(arg1, x, arg3);
+void test__std__scalbnf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::scalbnf(arg1, arg2);
 }
 
-void test__strncmp__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = strncmp(arg1, arg2, !x);
+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__strncmp__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = strncmp(arg1, arg2, x);
+void test__std__scalbnf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::scalbnf(x, arg2);
 }
 
-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__scalbnf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::scalbnf(arg1, x);
 }
 
-void test__std__strncmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::strncmp(arg1, arg2, arg3);
+void test__scalbnl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = scalbnl(arg1, arg2);
+    }
+    // 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__scalbnl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    scalbnl(arg1, arg2);
 }
 
-void test__std__strncmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strncmp(p, 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__strncmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strncmp(x, arg2, arg3);
+void test__scalbnl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = scalbnl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__strncmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strncmp(arg1, p, arg3);
+void test__scalbnl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = scalbnl(x, arg2);
 }
 
-void test__std__strncmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strncmp(arg1, x, arg3);
+void test__scalbnl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = scalbnl(arg1, x);
 }
 
-void test__std__strncmp__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = std::strncmp(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__strncmp__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::strncmp(arg1, arg2, x);
+void test__std__scalbnl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::scalbnl(arg1, 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__std__scalbnl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::scalbnl(arg1, arg2) > 10) || (std::scalbnl(arg1, arg2) < 100)) {}
 }
 
-void test__wcsncmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcsncmp(arg1, arg2, arg3);
+void test__std__scalbnl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::scalbnl(x, arg2);
 }
 
-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__scalbnl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::scalbnl(arg1, x);
 }
 
-void test__wcsncmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcsncmp(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__wcsncmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcsncmp(p, arg2, arg3);
+void test__scalbln__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    scalbln(arg1, arg2);
 }
 
-void test__wcsncmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcsncmp(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__wcsncmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcsncmp(arg1, p, arg3);
+void test__scalbln__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = scalbln(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__wcsncmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcsncmp(arg1, x, arg3);
+void test__scalbln__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = scalbln(x, arg2);
 }
 
-void test__wcsncmp__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = wcsncmp(arg1, arg2, !x);
+void test__scalbln__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = scalbln(arg1, x);
 }
 
-void test__wcsncmp__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wcsncmp(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__wcsncmp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::wcsncmp(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__scalbln__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::scalbln(arg1, arg2);
 }
 
-void test__std__wcsncmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wcsncmp(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__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__scalbln__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::scalbln(x, arg2);
 }
 
-void test__std__wcsncmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcsncmp(p, arg2, arg3);
+void test__std__scalbln__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::scalbln(arg1, x);
 }
 
-void test__std__wcsncmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcsncmp(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__wcsncmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcsncmp(arg1, p, arg3);
+void test__scalblnf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    scalblnf(arg1, arg2);
 }
 
-void test__std__wcsncmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcsncmp(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__wcsncmp__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = std::wcsncmp(arg1, arg2, !x);
+void test__scalblnf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = scalblnf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wcsncmp__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wcsncmp(arg1, arg2, x);
+void test__scalblnf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = scalblnf(x, arg2);
 }
 
-void test__strstr__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = strstr(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__scalblnf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = scalblnf(arg1, x);
 }
 
-void test__strstr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  strstr(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__strstr__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = strstr(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__scalblnf__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::scalblnf(arg1, arg2);
 }
 
-void test__strstr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strstr(p, 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__strstr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strstr(x, arg2);
+void test__std__scalblnf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::scalblnf(x, arg2);
 }
 
-void test__strstr__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strstr(arg1, p);
+void test__std__scalblnf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::scalblnf(arg1, x);
 }
 
-void test__strstr__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strstr(arg1, x);
+void test__scalblnl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = scalblnl(arg1, arg2);
+    }
+    // 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__scalblnl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    scalblnl(arg1, arg2);
 }
 
-void test__std__strstr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::strstr(arg1, arg2);
+void test__scalblnl__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((scalblnl(arg1, arg2) > 10) || (scalblnl(arg1, arg2) < 100)) {}
 }
 
-void test__std__strstr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strstr(p, arg2);
+void test__scalblnl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = scalblnl(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__strstr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strstr(x, arg2);
+void test__scalblnl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = scalblnl(x, arg2);
 }
 
-void test__std__strstr__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strstr(arg1, p);
+void test__scalblnl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = scalblnl(arg1, x);
 }
 
-void test__std__strstr__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strstr(arg1, x);
+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__wcsstr__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wcsstr(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__scalblnl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::scalblnl(arg1, arg2);
 }
 
-void test__wcsstr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcsstr(arg1, 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__wcsstr__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((wcsstr(arg1, arg2) > 10) || (wcsstr(arg1, arg2) < 100)) {}
+void test__std__scalblnl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::scalblnl(x, arg2);
 }
 
-void test__wcsstr__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcsstr(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__scalblnl__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::scalblnl(arg1, x);
 }
 
-void test__wcsstr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcsstr(p, arg2);
+void test__signbit__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = signbit(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcsstr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcsstr(x, arg2);
+void test__signbit__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    signbit(arg1);
 }
 
-void test__wcsstr__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcsstr(arg1, p);
+void test__signbit__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((signbit(arg1) > 10) || (signbit(arg1) < 100)) {}
 }
 
-void test__wcsstr__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcsstr(arg1, x);
+void test__signbit__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = signbit(p);
+    // cppcheck-suppress memleak
 }
 
-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__signbit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = signbit(x);
 }
 
-void test__std__wcsstr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wcsstr(arg1, 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__std__wcsstr__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((std::wcsstr(arg1, arg2) > 10) || (std::wcsstr(arg1, arg2) < 100)) {}
+
+void test__std__signbit__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::signbit(arg1);
 }
 
-void test__std__wcsstr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcsstr(p, arg2);
+void test__std__signbit__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::signbit(arg1) > 10) || (std::signbit(arg1) < 100)) {}
 }
 
-void test__std__wcsstr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcsstr(x, arg2);
+void test__std__signbit__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::signbit(x);
 }
 
-void test__std__wcsstr__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcsstr(arg1, p);
+void test__signal__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        signal(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__signal__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    signal(x, arg2);
 }
-
-void test__strspn__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = strspn(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+
+void test__std__signal__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::signal(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strspn__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  strspn(arg1, 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__strspn__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = strspn(p, arg2);
-  // cppcheck-suppress memleak
+void test__raise__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    raise(x);
 }
 
-void test__strspn__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strspn(p, arg2);
+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__strspn__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strspn(x, arg2);
-}
+void test__scanf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    scanf(NULL);
+}
 
-void test__strspn__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strspn(arg1, p);
+void test__scanf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    scanf(x);
 }
 
-void test__strspn__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strspn(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__std__strspn__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::strspn(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
-}
+void test__std__scanf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::scanf(NULL);
+}
 
-void test__std__strspn__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::strspn(arg1, arg2);
+void test__std__scanf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::scanf(x);
 }
 
-void test__std__strspn__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strspn(p, arg2);
+void test__vsscanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        vsscanf(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__strspn__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strspn(x, arg2);
+void test__vsscanf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    vsscanf(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__strspn__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strspn(arg1, p);
+void test__vsscanf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vsscanf(NULL, arg2, arg3);
 }
 
-void test__std__strspn__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strspn(arg1, x);
+void test__vsscanf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    vsscanf(x, arg2, arg3);
 }
 
-void test__strxfrm__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strxfrm(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__vsscanf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vsscanf(arg1, NULL, arg3);
 }
 
-void test__strxfrm__leakignore() {
-  char *p = malloc(10); *p=0;
-  strxfrm(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__vsscanf__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    vsscanf(arg1, x, arg3);
 }
 
-void test__strxfrm__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strxfrm(arg1, p, arg3);
+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__strxfrm__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strxfrm(arg1, x, arg3);
+void test__std__vsscanf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::vsscanf(NULL, arg2, arg3);
 }
 
-void test__strxfrm__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strxfrm(arg1, arg2, x);
+void test__std__vsscanf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::vsscanf(x, arg2, arg3);
 }
 
-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__vsscanf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::vsscanf(arg1, NULL, arg3);
 }
 
-void test__std__strxfrm__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strxfrm(arg1, p, arg3);
+void test__std__vsscanf__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::vsscanf(arg1, x, arg3);
 }
 
-void test__std__strxfrm__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strxfrm(arg1, x, arg3);
+void test__vswscanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        vswscanf(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__strxfrm__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::strxfrm(arg1, arg2, x);
+void test__vswscanf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    vswscanf(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__wcsxfrm__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wcsxfrm(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__vswscanf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vswscanf(NULL, arg2, arg3);
 }
 
-void test__wcsxfrm__leakignore() {
-  char *p = malloc(10); *p=0;
-  wcsxfrm(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__vswscanf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    vswscanf(x, arg2, arg3);
 }
 
-void test__wcsxfrm__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcsxfrm(arg1, p, arg3);
+void test__vswscanf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vswscanf(arg1, NULL, arg3);
 }
 
-void test__wcsxfrm__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcsxfrm(arg1, x, arg3);
+void test__vswscanf__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    vswscanf(arg1, x, arg3);
 }
 
-void test__wcsxfrm__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wcsxfrm(arg1, arg2, 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__wcsxfrm__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::wcsxfrm(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__vswscanf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::vswscanf(NULL, arg2, arg3);
 }
 
-void test__std__wcsxfrm__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcsxfrm(arg1, p, arg3);
+void test__std__vswscanf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::vswscanf(x, arg2, arg3);
 }
 
-void test__std__wcsxfrm__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wcsxfrm(arg1, x, arg3);
+void test__std__vswscanf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::vswscanf(arg1, NULL, arg3);
 }
 
-void test__std__wcsxfrm__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wcsxfrm(arg1, arg2, x);
+void test__std__vswscanf__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::vswscanf(arg1, x, arg3);
 }
 
-void test__wcsspn__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wcsspn(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__vscanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        vscanf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcsspn__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcsspn(arg1, arg2);
+void test__vscanf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    vscanf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__wcsspn__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((wcsspn(arg1, arg2) > 10) || (wcsspn(arg1, arg2) < 100)) {}
+void test__vscanf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vscanf(NULL, arg2);
 }
 
-void test__wcsspn__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcsspn(p, arg2);
-  // cppcheck-suppress memleak
+void test__vscanf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    vscanf(x, arg2);
 }
 
-void test__wcsspn__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcsspn(p, arg2);
+void test__std__vscanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::vscanf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcsspn__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcsspn(x, arg2);
+void test__std__vscanf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::vscanf(NULL, arg2);
 }
 
-void test__wcsspn__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcsspn(arg1, p);
+void test__std__vscanf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::vscanf(x, arg2);
 }
 
-void test__wcsspn__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcsspn(arg1, x);
+void test__vwscanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        vwscanf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__vwscanf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    vwscanf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wcsspn__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wcsspn(arg1, arg2);
+void test__vwscanf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vwscanf(NULL, 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__vwscanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::vwscanf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__wcsspn__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcsspn(p, arg2);
+void test__std__vwscanf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::vwscanf(NULL, arg2);
 }
 
-void test__std__wcsspn__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcsspn(x, arg2);
+void test__setbuf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        setbuf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__wcsspn__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcsspn(arg1, p);
+void test__setbuf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    setbuf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wcsspn__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcsspn(arg1, x);
+void test__setbuf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    setbuf(NULL, arg2);
 }
 
-void test__localeconv__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = localeconv(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__setbuf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    setbuf(x, arg2);
 }
 
-void test__localeconv__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  localeconv();
+void test__setbuf__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    setbuf(arg1, !x);
 }
 
-void test__localeconv__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = localeconv();
-  // cppcheck-suppress memleak
+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__localeconv__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::localeconv(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__setbuf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::setbuf(NULL, arg2);
 }
 
-void test__std__localeconv__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::localeconv();
+void test__std__setbuf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::setbuf(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__setbuf__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::setbuf(arg1, !x);
 }
 
-void test__std__locale__global__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::locale::global(arg1);
+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__locale__global__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::locale::global(x);
+void test__setvbuf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    setvbuf(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-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__setvbuf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    setvbuf(NULL, arg2, arg3, arg4);
 }
 
-void test__std__locale__classic__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::locale::classic();
+void test__setvbuf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    setvbuf(x, arg2, arg3, arg4);
 }
 
-void test__setlocale__noreturn() {
-  int x = 1;
-  if (cond) { x=100; setlocale(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__setvbuf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    setvbuf(arg1, x, arg3, arg4);
 }
 
-void test__setlocale__leakignore() {
-  char *p = malloc(10); *p=0;
-  setlocale(p, arg2);
-  // cppcheck-suppress memleak
+void test__setvbuf__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    setvbuf(arg1, arg2, x, arg4);
 }
 
-void test__setlocale__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setlocale(x, arg2);
+void test__setvbuf__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    setvbuf(arg1, arg2, arg3, x);
 }
 
-void test__setlocale__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setlocale(arg1, 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__std__setlocale__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::setlocale(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__setvbuf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::setvbuf(NULL, arg2, arg3, arg4);
 }
 
-void test__std__setlocale__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::setlocale(x, arg2);
+void test__std__setvbuf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::setvbuf(x, arg2, arg3, arg4);
 }
 
-void test__std__setlocale__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::setlocale(arg1, x);
+void test__std__setvbuf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::setvbuf(arg1, x, arg3, arg4);
 }
 
-void test__strerror__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = strerror(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__setvbuf__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::setvbuf(arg1, arg2, x, arg4);
 }
 
-void test__strerror__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  strerror(arg1);
+void test__std__setvbuf__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::setvbuf(arg1, arg2, arg3, x);
 }
 
-void test__strerror__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = strerror(p);
-  // cppcheck-suppress memleak
+void test__setjmp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        setjmp(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strerror__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = strerror(x);
+void test__setjmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    setjmp(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__strerror__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::strerror(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strcat__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strcat(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__strerror__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::strerror(arg1);
+void test__strcat__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strcat(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__strerror__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::strerror(x);
+void test__strcat__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strcat(NULL, arg2);
 }
 
-void test__strcspn__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = strcspn(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strcat__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strcat(x, arg2);
 }
 
-void test__strcspn__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  strcspn(arg1, arg2);
+void test__strcat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strcat(arg1, NULL);
 }
 
-void test__strcspn__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((strcspn(arg1, arg2) > 10) || (strcspn(arg1, arg2) < 100)) {}
+void test__strcat__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strcat(arg1, x);
 }
 
-void test__strcspn__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = strcspn(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__strcat__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::strcat(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strcspn__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strcspn(p, arg2);
+void test__std__strcat__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strcat(NULL, arg2);
 }
 
-void test__strcspn__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strcspn(x, arg2);
+void test__std__strcat__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strcat(x, arg2);
 }
 
-void test__strcspn__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strcspn(arg1, p);
+void test__std__strcat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strcat(arg1, NULL);
 }
 
-void test__strcspn__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strcspn(arg1, x);
+void test__std__strcat__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strcat(arg1, 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__wcscat__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wcscat(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__strcspn__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::strcspn(arg1, arg2);
+void test__wcscat__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcscat(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__wcscat__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcscat(NULL, arg2);
 }
 
-void test__std__strcspn__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strcspn(p, arg2);
+void test__wcscat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcscat(arg1, NULL);
 }
 
-void test__std__strcspn__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strcspn(x, arg2);
+void test__wcscat__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcscat(arg1, x);
 }
 
-void test__std__strcspn__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strcspn(arg1, p);
+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__strcspn__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strcspn(arg1, x);
+void test__std__wcscat__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcscat(NULL, arg2);
 }
 
-void test__wcscspn__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wcscspn(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wcscat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcscat(arg1, NULL);
 }
 
-void test__wcscspn__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcscspn(arg1, arg2);
+void test__std__wcscat__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wcscat(arg1, x);
 }
 
-void test__wcscspn__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((wcscspn(arg1, arg2) > 10) || (wcscspn(arg1, arg2) < 100)) {}
+void test__wcrtomb__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wcrtomb(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcscspn__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcscspn(p, arg2);
-  // cppcheck-suppress memleak
+void test__wcrtomb__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcrtomb(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__wcscspn__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcscspn(p, arg2);
+void test__wcrtomb__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wcrtomb(arg1, x, arg3);
 }
 
-void test__wcscspn__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcscspn(x, 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__wcscspn__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcscspn(arg1, p);
+void test__std__wcrtomb__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wcrtomb(arg1, x, arg3);
 }
 
-void test__wcscspn__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcscspn(arg1, x);
+void test__strchr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = strchr(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__strchr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    strchr(arg1, arg2);
 }
 
-void test__std__wcscspn__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wcscspn(arg1, arg2);
+void test__strchr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = strchr(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__strchr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strchr(NULL, arg2);
 }
 
-void test__std__wcscspn__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcscspn(p, arg2);
+void test__strchr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strchr(x, arg2);
 }
 
-void test__std__wcscspn__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcscspn(x, arg2);
+void test__strchr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = strchr(arg1, x);
 }
 
-void test__std__wcscspn__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcscspn(arg1, p);
+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__wcscspn__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcscspn(arg1, x);
+void test__std__strchr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::strchr(arg1, arg2);
 }
 
-void test__wcspbrk__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wcspbrk(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__strchr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strchr(NULL, arg2);
 }
 
-void test__wcspbrk__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcspbrk(arg1, arg2);
+void test__std__strchr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strchr(x, arg2);
 }
 
-void test__wcspbrk__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcspbrk(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__strchr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::strchr(arg1, x);
 }
 
-void test__wcspbrk__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcspbrk(p, arg2);
+void test__wcschr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wcschr(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__wcschr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcschr(arg1, arg2);
 }
 
-void test__wcspbrk__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wcspbrk(arg1, x);
+void test__wcschr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wcschr(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__wcschr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcschr(NULL, arg2);
 }
 
-void test__std__wcspbrk__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wcspbrk(arg1, arg2);
+void test__wcschr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcschr(x, arg2);
 }
 
-void test__std__wcspbrk__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcspbrk(p, arg2);
+void test__wcschr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = wcschr(arg1, x);
 }
 
-void test__std__wcspbrk__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcspbrk(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__std__wcspbrk__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wcspbrk(arg1, x);
+void test__std__wcschr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wcschr(arg1, arg2);
 }
 
-void test__wcsncpy__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wcsncpy(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wcschr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcschr(NULL, arg2);
 }
 
-void test__wcsncpy__leakignore() {
-  char *p = malloc(10); *p=0;
-  wcsncpy(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__wcschr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcschr(x, arg2);
 }
 
-void test__wcsncpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcsncpy(p, arg2, arg3);
+void test__std__wcschr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wcschr(arg1, x);
 }
 
-void test__wcsncpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcsncpy(arg1, p, arg3);
+void test__strcmp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = strcmp(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__strcmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    strcmp(arg1, arg2);
 }
 
-void test__wcsncpy__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  wcsncpy(arg1, arg2, !x);
+void test__strcmp__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((strcmp(arg1, arg2) > 10) || (strcmp(arg1, arg2) < 100)) {}
 }
 
-void test__wcsncpy__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wcsncpy(arg1, arg2, x);
+void test__strcmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = strcmp(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__strcmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strcmp(NULL, arg2);
 }
 
-void test__std__wcsncpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcsncpy(p, arg2, arg3);
+void test__strcmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strcmp(x, arg2);
 }
 
-void test__std__wcsncpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcsncpy(arg1, p, arg3);
+void test__strcmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strcmp(arg1, NULL);
 }
 
-void test__std__wcsncpy__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wcsncpy(arg1, x, arg3);
+void test__strcmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strcmp(arg1, x);
 }
 
-void test__std__wcsncpy__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  std::wcsncpy(arg1, arg2, !x);
+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__std__wcsncpy__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wcsncpy(arg1, arg2, x);
+void test__std__strcmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::strcmp(arg1, arg2);
 }
 
-void test__strcoll__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = strcoll(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__strcoll__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  strcoll(arg1, arg2);
+void test__std__strcmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strcmp(NULL, arg2);
 }
 
-void test__strcoll__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = strcoll(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__strcmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strcmp(x, arg2);
 }
 
-void test__strcoll__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strcoll(p, arg2);
+void test__std__strcmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strcmp(arg1, NULL);
 }
 
-void test__strcoll__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strcoll(x, arg2);
+void test__std__strcmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strcmp(arg1, x);
 }
 
-void test__strcoll__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strcoll(arg1, p);
+void test__wcscmp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wcscmp(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strcoll__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strcoll(arg1, x);
+void test__wcscmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcscmp(arg1, arg2);
 }
 
-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__wcscmp__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((wcscmp(arg1, arg2) > 10) || (wcscmp(arg1, arg2) < 100)) {}
 }
 
-void test__std__strcoll__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::strcoll(arg1, arg2);
+void test__wcscmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wcscmp(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__strcoll__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strcoll(p, arg2);
+void test__wcscmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcscmp(NULL, arg2);
 }
 
-void test__std__strcoll__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strcoll(x, arg2);
+void test__wcscmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcscmp(x, arg2);
 }
 
-void test__std__strcoll__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strcoll(arg1, p);
+void test__wcscmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcscmp(arg1, NULL);
 }
 
-void test__std__strcoll__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strcoll(arg1, x);
+void test__wcscmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcscmp(arg1, x);
 }
 
-void test__wcscoll__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wcscoll(arg1, arg2); }
-  // 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__wcscoll__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcscoll(arg1, arg2);
+void test__std__wcscmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wcscmp(arg1, arg2);
 }
 
-void test__wcscoll__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcscoll(p, arg2);
-  // cppcheck-suppress memleak
+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__wcscoll__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcscoll(p, arg2);
+void test__std__wcscmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcscmp(NULL, arg2);
 }
 
-void test__wcscoll__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcscoll(x, arg2);
+void test__std__wcscmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcscmp(x, arg2);
 }
 
-void test__wcscoll__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcscoll(arg1, p);
+void test__std__wcscmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcscmp(arg1, NULL);
 }
 
-void test__wcscoll__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcscoll(arg1, x);
+void test__std__wcscmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcscmp(arg1, 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__strcpy__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strcpy(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__wcscoll__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wcscoll(arg1, arg2);
+void test__strcpy__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strcpy(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wcscoll__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcscoll(p, arg2);
+void test__strcpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strcpy(NULL, arg2);
 }
 
-void test__std__wcscoll__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcscoll(x, arg2);
+void test__strcpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strcpy(arg1, NULL);
 }
 
-void test__std__wcscoll__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcscoll(arg1, p);
+void test__strcpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strcpy(arg1, x);
 }
 
-void test__std__wcscoll__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcscoll(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__strrchr__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = strrchr(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__strcpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strcpy(NULL, arg2);
 }
 
-void test__strrchr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  strrchr(arg1, arg2);
+void test__std__strcpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strcpy(arg1, NULL);
 }
 
-void test__strrchr__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = strrchr(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__strcpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strcpy(arg1, x);
 }
 
-void test__strrchr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strrchr(p, arg2);
+void test__wcscpy__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wcscpy(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strrchr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strrchr(x, arg2);
+void test__wcscpy__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcscpy(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__strrchr__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = strrchr(arg1, x);
+void test__wcscpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcscpy(NULL, arg2);
 }
 
-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__wcscpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcscpy(arg1, NULL);
 }
 
-void test__std__strrchr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::strrchr(arg1, arg2);
+void test__wcscpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcscpy(arg1, x);
 }
 
-void test__std__strrchr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::strrchr(p, arg2);
+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__strrchr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::strrchr(x, arg2);
+void test__std__wcscpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcscpy(NULL, arg2);
 }
 
-void test__std__strrchr__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::strrchr(arg1, x);
+void test__std__wcscpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcscpy(arg1, NULL);
 }
 
-void test__wcsrchr__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wcsrchr(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wcscpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wcscpy(arg1, x);
 }
 
-void test__wcsrchr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcsrchr(arg1, arg2);
+void test__strftime__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strftime(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcsrchr__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcsrchr(p, arg2);
-  // cppcheck-suppress memleak
+void test__strftime__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strftime(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__wcsrchr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcsrchr(p, arg2);
+void test__strftime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strftime(NULL, arg2, arg3, arg4);
 }
 
-void test__wcsrchr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcsrchr(x, arg2);
+void test__strftime__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    strftime(arg1, x, arg3, arg4);
 }
 
-void test__wcsrchr__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wcsrchr(arg1, x);
+void test__strftime__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strftime(arg1, arg2, NULL, arg4);
 }
 
-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__strftime__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strftime(arg1, arg2, x, arg4);
 }
 
-void test__std__wcsrchr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wcsrchr(arg1, arg2);
+void test__strftime__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strftime(arg1, arg2, arg3, NULL);
 }
 
-void test__std__wcsrchr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcsrchr(p, arg2);
+void test__strftime__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strftime(arg1, arg2, arg3, x);
 }
 
-void test__std__wcsrchr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcsrchr(x, 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__std__wcsrchr__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wcsrchr(arg1, x);
+void test__std__strftime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strftime(NULL, arg2, arg3, arg4);
 }
 
-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__strftime__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::strftime(arg1, x, arg3, arg4);
 }
 
-void test__wcsrtombs__leakignore() {
-  char *p = malloc(10); *p=0;
-  wcsrtombs(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__std__strftime__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strftime(arg1, arg2, NULL, arg4);
 }
 
-void test__wcsrtombs__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcsrtombs(arg1, p, arg3, arg4);
+void test__std__strftime__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strftime(arg1, arg2, x, arg4);
 }
 
-void test__wcsrtombs__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcsrtombs(arg1, x, arg3, arg4);
+void test__std__strftime__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strftime(arg1, arg2, arg3, NULL);
 }
 
-void test__wcsrtombs__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wcsrtombs(arg1, arg2, x, arg4);
+void test__std__strftime__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strftime(arg1, arg2, arg3, x);
 }
 
-void test__wcsrtombs__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcsrtombs(arg1, arg2, arg3, p);
+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__wcsrtombs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::wcsrtombs(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strfxtime__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strfxtime(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wcsrtombs__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcsrtombs(arg1, p, arg3, arg4);
+void test__strfxtime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strfxtime(NULL, arg2, arg3, arg4);
 }
 
-void test__std__wcsrtombs__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wcsrtombs(arg1, x, arg3, arg4);
+void test__strfxtime__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    strfxtime(arg1, x, arg3, arg4);
 }
 
-void test__std__wcsrtombs__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wcsrtombs(arg1, arg2, x, arg4);
+void test__strfxtime__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strfxtime(arg1, arg2, NULL, arg4);
 }
 
-void test__std__wcsrtombs__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcsrtombs(arg1, arg2, arg3, p);
+void test__strfxtime__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strfxtime(arg1, arg2, x, arg4);
 }
 
-void test__strtok__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strtok(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strfxtime__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strfxtime(arg1, arg2, arg3, NULL);
 }
 
-void test__strtok__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((strtok(arg1, arg2) > 10) || (strtok(arg1, arg2) < 100)) {}
+void test__strfxtime__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strfxtime(arg1, arg2, arg3, x);
 }
 
-void test__strtok__leakignore() {
-  char *p = malloc(10); *p=0;
-  strtok(p, arg2);
-  // cppcheck-suppress memleak
+void test__strlen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = strlen(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strtok__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strtok(x, arg2);
+void test__strlen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    strlen(arg1);
 }
 
-void test__strtok__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strtok(arg1, p);
+void test__strlen__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((strlen(arg1) > 10) || (strlen(arg1) < 100)) {}
 }
 
-void test__strtok__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strtok(arg1, x);
+void test__strlen__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = strlen(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__strtok__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::strtok(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strlen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strlen(NULL);
 }
 
-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__strlen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strlen(x);
 }
 
-void test__std__strtok__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::strtok(x, 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__std__strtok__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strtok(arg1, p);
+void test__std__strlen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::strlen(arg1);
 }
 
-void test__std__strtok__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strtok(arg1, x);
+void test__std__strlen__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::strlen(arg1) > 10) || (std::strlen(arg1) < 100)) {}
 }
 
-void test__strtof__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strtof(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__strlen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strlen(NULL);
 }
 
-void test__strtof__leakignore() {
-  char *p = malloc(10); *p=0;
-  strtof(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__strlen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strlen(x);
 }
 
-void test__strtof__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strtof(p, arg2);
+void test__wcslen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wcslen(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strtof__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strtof(x, arg2);
+void test__wcslen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcslen(arg1);
 }
 
-void test__std__strtof__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::strtof(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcslen__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((wcslen(arg1) > 10) || (wcslen(arg1) < 100)) {}
 }
 
-void test__std__strtof__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strtof(p, arg2);
+void test__wcslen__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wcslen(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__strtof__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strtof(x, arg2);
+void test__wcslen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcslen(NULL);
 }
 
-void test__strtod__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strtod(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcslen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcslen(x);
 }
 
-void test__strtod__leakignore() {
-  char *p = malloc(10); *p=0;
-  strtod(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__wcslen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::wcslen(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strtod__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strtod(p, arg2);
+void test__std__wcslen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wcslen(arg1);
 }
 
-void test__strtod__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strtod(x, arg2);
+void test__std__wcslen__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((std::wcslen(arg1) > 10) || (std::wcslen(arg1) < 100)) {}
 }
 
-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__wcslen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcslen(NULL);
 }
 
-void test__std__strtod__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strtod(p, arg2);
+void test__std__wcslen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcslen(x);
 }
 
-void test__std__strtod__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strtod(x, arg2);
+void test__strncpy__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strncpy(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strtold__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strtold(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__strtold__leakignore() {
-  char *p = malloc(10); *p=0;
-  strtold(p, arg2);
-  // cppcheck-suppress memleak
+void test__strncpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strncpy(NULL, arg2, arg3);
 }
 
-void test__strtold__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strtold(p, arg2);
+void test__strncpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strncpy(arg1, NULL, arg3);
 }
 
-void test__strtold__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strtold(x, arg2);
+void test__strncpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strncpy(arg1, x, arg3);
 }
 
-void test__std__strtold__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::strtold(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strncpy__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    strncpy(arg1, arg2, !x);
 }
 
-void test__std__strtold__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strtold(p, arg2);
+void test__strncpy__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    strncpy(arg1, arg2, x);
 }
 
-void test__std__strtold__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strtold(x, arg2);
+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__strtol__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strtol(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__strncpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strncpy(NULL, arg2, arg3);
 }
 
-void test__strtol__leakignore() {
-  char *p = malloc(10); *p=0;
-  strtol(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__strncpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strncpy(arg1, NULL, arg3);
 }
 
-void test__strtol__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strtol(p, arg2, arg3);
+void test__std__strncpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strncpy(arg1, x, arg3);
 }
 
-void test__strtol__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strtol(x, arg2, arg3);
+void test__std__strncpy__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::strncpy(arg1, arg2, !x);
 }
 
-void test__strtol__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strtol(arg1, arg2, x);
+void test__std__strncpy__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::strncpy(arg1, arg2, x);
 }
 
-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__strpbrk__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = strpbrk(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__strtol__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strtol(p, arg2, arg3);
+void test__strpbrk__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    strpbrk(arg1, arg2);
 }
 
-void test__std__strtol__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strtol(x, arg2, arg3);
+void test__strpbrk__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = strpbrk(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__strtol__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::strtol(arg1, arg2, x);
+void test__strpbrk__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strpbrk(NULL, arg2);
 }
 
-void test__strtoul__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strtoul(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strpbrk__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strpbrk(x, arg2);
 }
 
-void test__strtoul__leakignore() {
-  char *p = malloc(10); *p=0;
-  strtoul(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__strpbrk__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strpbrk(arg1, NULL);
 }
 
-void test__strtoul__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strtoul(p, arg2, arg3);
+void test__strpbrk__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strpbrk(arg1, x);
 }
 
-void test__strtoul__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strtoul(x, arg2, arg3);
+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__strtoul__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strtoul(arg1, arg2, x);
+void test__std__strpbrk__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::strpbrk(arg1, arg2);
 }
 
-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__std__strpbrk__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strpbrk(NULL, arg2);
 }
 
-void test__std__strtoul__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strtoul(p, arg2, arg3);
+void test__std__strpbrk__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strpbrk(x, arg2);
 }
 
-void test__std__strtoul__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strtoul(x, arg2, arg3);
+void test__std__strpbrk__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strpbrk(arg1, NULL);
 }
 
-void test__std__strtoul__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::strtoul(arg1, arg2, x);
+void test__std__strpbrk__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strpbrk(arg1, x);
 }
 
-void test__strtoll__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strtoll(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strncat__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strncat(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strtoll__leakignore() {
-  char *p = malloc(10); *p=0;
-  strtoll(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__strncat__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strncat(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__strtoll__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strtoll(p, arg2, arg3);
+void test__strncat__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strncat(NULL, arg2, arg3);
 }
 
-void test__strtoll__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strtoll(x, arg2, arg3);
+void test__strncat__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strncat(x, arg2, arg3);
 }
 
-void test__strtoll__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strtoll(arg1, arg2, x);
+void test__strncat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strncat(arg1, NULL, arg3);
 }
 
-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__strncat__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strncat(arg1, x, arg3);
 }
 
-void test__std__strtoll__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strtoll(p, arg2, arg3);
+void test__strncat__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    strncat(arg1, arg2, !x);
 }
 
-void test__std__strtoll__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strtoll(x, arg2, arg3);
+void test__strncat__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    strncat(arg1, arg2, x);
 }
 
-void test__std__strtoll__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::strtoll(arg1, arg2, x);
+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__strtoull__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strtoull(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__strncat__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strncat(NULL, arg2, arg3);
 }
 
-void test__strtoull__leakignore() {
-  char *p = malloc(10); *p=0;
-  strtoull(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__strncat__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strncat(x, arg2, arg3);
 }
 
-void test__strtoull__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strtoull(p, arg2, arg3);
+void test__std__strncat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strncat(arg1, NULL, arg3);
 }
 
-void test__strtoull__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strtoull(x, arg2, arg3);
+void test__std__strncat__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strncat(arg1, x, arg3);
 }
 
-void test__strtoull__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strtoull(arg1, arg2, x);
+void test__std__strncat__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::strncat(arg1, arg2, !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__std__strncat__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::strncat(arg1, arg2, x);
 }
 
-void test__std__strtoull__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strtoull(p, arg2, arg3);
+void test__wcsncat__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wcsncat(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__strtoull__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strtoull(x, arg2, arg3);
+void test__wcsncat__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcsncat(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__strtoull__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::strtoull(arg1, arg2, x);
+void test__wcsncat__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcsncat(NULL, arg2, arg3);
 }
 
-void test__strtoimax__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strtoimax(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcsncat__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcsncat(x, arg2, arg3);
 }
 
-void test__strtoimax__leakignore() {
-  char *p = malloc(10); *p=0;
-  strtoimax(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__wcsncat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcsncat(arg1, NULL, arg3);
 }
 
-void test__strtoimax__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strtoimax(p, arg2, arg3);
+void test__wcsncat__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcsncat(arg1, x, arg3);
 }
 
-void test__strtoimax__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strtoimax(x, arg2, arg3);
+void test__wcsncat__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wcsncat(arg1, arg2, !x);
 }
 
-void test__strtoimax__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strtoimax(arg1, arg2, x);
+void test__wcsncat__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wcsncat(arg1, arg2, 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__std__wcsncat__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::wcsncat(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__strtoimax__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strtoimax(p, arg2, arg3);
+void test__std__wcsncat__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcsncat(NULL, arg2, arg3);
 }
 
-void test__std__strtoimax__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::strtoimax(x, arg2, arg3);
+void test__std__wcsncat__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wcsncat(x, arg2, arg3);
 }
 
-void test__std__strtoimax__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::strtoimax(arg1, arg2, x);
+void test__std__wcsncat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcsncat(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__wcsncat__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wcsncat(arg1, x, arg3);
 }
 
-void test__strtoumax__leakignore() {
-  char *p = malloc(10); *p=0;
-  strtoumax(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__wcsncat__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::wcsncat(arg1, arg2, !x);
 }
 
-void test__strtoumax__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strtoumax(p, arg2, arg3);
+void test__std__wcsncat__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wcsncat(arg1, arg2, x);
 }
 
-void test__strtoumax__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strtoumax(x, 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__strtoumax__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strtoumax(arg1, arg2, x);
+void test__strncmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    strncmp(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__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__strtoumax__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::strtoumax(p, arg2, arg3);
+void test__strncmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = strncmp(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__strncmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strncmp(NULL, arg2, arg3);
 }
 
-void test__std__strtoumax__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::strtoumax(arg1, arg2, x);
+void test__strncmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strncmp(x, arg2, arg3);
 }
 
-void test__time__noreturn() {
-  int x = 1;
-  if (cond) { x=100; time(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strncmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strncmp(arg1, NULL, arg3);
 }
 
-void test__time__leakignore() {
-  char *p = malloc(10); *p=0;
-  time(p);
-  // cppcheck-suppress memleak
+void test__strncmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strncmp(arg1, x, arg3);
 }
 
-void test__time__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  time(x);
+void test__strncmp__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = strncmp(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__strncmp__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = strncmp(arg1, arg2, x);
 }
 
-void test__std__time__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::time(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__tmpnam__noreturn() {
-  int x = 1;
-  if (cond) { x=100; tmpnam(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__strncmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::strncmp(arg1, arg2, arg3);
 }
 
-void test__tmpnam__leakignore() {
-  char *p = malloc(10); *p=0;
-  tmpnam(p);
-  // cppcheck-suppress memleak
+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__tmpnam__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  tmpnam(x);
+void test__std__strncmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strncmp(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__strncmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strncmp(x, arg2, arg3);
 }
 
-void test__std__tmpnam__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::tmpnam(x);
+void test__std__strncmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strncmp(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__strncmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strncmp(arg1, x, arg3);
 }
 
-void test__tmpnam_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  tmpnam_s(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__strncmp__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = std::strncmp(arg1, arg2, !x);
 }
 
-void test__tmpnam_s__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  tmpnam_s(x, arg2);
+void test__std__strncmp__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::strncmp(arg1, arg2, x);
 }
 
-void test__tmpnam_s__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  tmpnam_s(arg1, x);
+void test__wcsncmp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wcsncmp(arg1, arg2, arg3);
+    }
+    // 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__wcsncmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcsncmp(arg1, arg2, arg3);
 }
 
-void test__tmpfile__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  tmpfile();
+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__tolower__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = tolower(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcsncmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wcsncmp(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__tolower__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  tolower(arg1);
+void test__wcsncmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcsncmp(NULL, arg2, arg3);
 }
 
-void test__tolower__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = tolower(p);
-  // cppcheck-suppress memleak
+void test__wcsncmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcsncmp(x, arg2, arg3);
 }
 
-void test__tolower__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = tolower(x);
+void test__wcsncmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcsncmp(arg1, NULL, arg3);
 }
 
-void test__std__tolower__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::tolower(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcsncmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcsncmp(arg1, x, arg3);
 }
 
-void test__std__tolower__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::tolower(arg1);
+void test__wcsncmp__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = wcsncmp(arg1, arg2, !x);
 }
 
-void test__std__tolower__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::tolower(x);
+void test__wcsncmp__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = wcsncmp(arg1, arg2, x);
 }
 
-void test__toupper__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = toupper(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__toupper__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  toupper(arg1);
+void test__std__wcsncmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wcsncmp(arg1, arg2, arg3);
 }
 
-void test__toupper__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = toupper(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__toupper__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = toupper(x);
+void test__std__wcsncmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcsncmp(NULL, arg2, arg3);
 }
 
-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__wcsncmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcsncmp(x, arg2, arg3);
 }
 
-void test__std__toupper__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::toupper(arg1);
+void test__std__wcsncmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcsncmp(arg1, NULL, arg3);
 }
 
-void test__std__toupper__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::toupper(x);
+void test__std__wcsncmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcsncmp(arg1, x, arg3);
 }
 
-void test__typeid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = typeid(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wcsncmp__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = std::wcsncmp(arg1, arg2, !x);
 }
 
-void test__typeid__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  typeid(arg1);
+void test__std__wcsncmp__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wcsncmp(arg1, arg2, x);
 }
 
-void test__va_arg__noreturn() {
-  int x = 1;
-  if (cond) { x=100; va_arg(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strstr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = strstr(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__strstr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    strstr(arg1, arg2);
 }
 
-void test__va_copy__noreturn() {
-  int x = 1;
-  if (cond) { x=100; va_copy(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strstr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = strstr(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__va_copy__leakignore() {
-  char *p = malloc(10); *p=0;
-  va_copy(p, arg2);
-  // cppcheck-suppress memleak
+void test__strstr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strstr(NULL, arg2);
 }
 
-void test__va_end__noreturn() {
-  int x = 1;
-  if (cond) { x=100; va_end(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strstr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strstr(x, arg2);
 }
 
-void test__va_end__leakignore() {
-  char *p = malloc(10); *p=0;
-  va_end(p);
-  // cppcheck-suppress memleak
+void test__strstr__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strstr(arg1, NULL);
 }
 
-void test__va_start__noreturn() {
-  int x = 1;
-  if (cond) { x=100; va_start(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strstr__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strstr(arg1, x);
 }
 
-void test__va_start__leakignore() {
-  char *p = malloc(10); *p=0;
-  va_start(p, arg2);
-  // cppcheck-suppress memleak
+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__wcstof__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wcstof(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__strstr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::strstr(arg1, arg2);
 }
 
-void test__wcstof__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcstof(arg1, arg2);
+void test__std__strstr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strstr(NULL, arg2);
 }
 
-void test__wcstof__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcstof(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__strstr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strstr(x, arg2);
 }
 
-void test__wcstof__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcstof(p, arg2);
+void test__std__strstr__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strstr(arg1, NULL);
 }
 
-void test__wcstof__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcstof(x, arg2);
+void test__std__strstr__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strstr(arg1, x);
 }
 
-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__wcsstr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wcsstr(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__wcstof__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wcstof(arg1, arg2);
+void test__wcsstr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcsstr(arg1, arg2);
 }
 
-void test__std__wcstof__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcstof(p, arg2);
+void test__wcsstr__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((wcsstr(arg1, arg2) > 10) || (wcsstr(arg1, arg2) < 100)) {}
 }
 
-void test__std__wcstof__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcstof(x, arg2);
+void test__wcsstr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wcsstr(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__wcstod__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wcstod(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcsstr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcsstr(NULL, arg2);
 }
 
-void test__wcstod__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcstod(arg1, arg2);
+void test__wcsstr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcsstr(x, arg2);
 }
 
-void test__wcstod__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcstod(p, arg2);
-  // cppcheck-suppress memleak
+void test__wcsstr__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcsstr(arg1, NULL);
 }
 
-void test__wcstod__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcstod(p, arg2);
+void test__wcsstr__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcsstr(arg1, x);
 }
 
-void test__wcstod__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcstod(x, arg2);
+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__std__wcstod__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::wcstod(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wcsstr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wcsstr(arg1, arg2);
 }
 
-void test__std__wcstod__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wcstod(arg1, arg2);
+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__std__wcstod__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcstod(p, arg2);
+void test__std__wcsstr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcsstr(NULL, arg2);
 }
 
-void test__std__wcstod__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcstod(x, arg2);
+void test__std__wcsstr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcsstr(x, arg2);
 }
 
-void test__wcstold__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wcstold(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wcsstr__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcsstr(arg1, NULL);
 }
 
-void test__wcstold__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcstold(arg1, arg2);
+void test__std__wcsstr__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcsstr(arg1, x);
 }
 
-void test__wcstold__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcstold(p, arg2);
-  // cppcheck-suppress memleak
+void test__strspn__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = strspn(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcstold__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcstold(p, arg2);
+void test__strspn__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    strspn(arg1, arg2);
 }
 
-void test__wcstold__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcstold(x, arg2);
+void test__strspn__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = strspn(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__strspn__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strspn(NULL, arg2);
 }
 
-void test__std__wcstold__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wcstold(arg1, arg2);
+void test__strspn__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strspn(x, arg2);
 }
 
-void test__std__wcstold__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcstold(p, arg2);
+void test__strspn__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strspn(arg1, NULL);
 }
 
-void test__std__wcstold__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcstold(x, arg2);
+void test__strspn__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strspn(arg1, 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__strspn__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::strspn(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__stof__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  stof(arg1, arg2);
+void test__std__strspn__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::strspn(arg1, arg2);
 }
 
-void test__stof__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = stof(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__strspn__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strspn(NULL, arg2);
 }
 
-void test__stof__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stof(x, arg2);
+void test__std__strspn__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strspn(x, arg2);
 }
 
-void test__stof__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stof(arg1, x);
+void test__std__strspn__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strspn(arg1, NULL);
 }
 
-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__std__strspn__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strspn(arg1, x);
 }
 
-void test__std__stof__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::stof(arg1, arg2);
+void test__strxfrm__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strxfrm(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__stof__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stof(x, arg2);
+void test__strxfrm__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strxfrm(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__stof__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stof(arg1, x);
+void test__strxfrm__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strxfrm(arg1, NULL, arg3);
 }
 
-void test__stod__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = stod(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strxfrm__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strxfrm(arg1, x, arg3);
 }
 
-void test__stod__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  stod(arg1, arg2);
+void test__strxfrm__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    strxfrm(arg1, arg2, x);
 }
 
-void test__stod__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = stod(p, arg2);
-  // cppcheck-suppress memleak
+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__stod__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stod(x, arg2);
+void test__std__strxfrm__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strxfrm(arg1, NULL, arg3);
 }
 
-void test__stod__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stod(arg1, x);
+void test__std__strxfrm__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strxfrm(arg1, x, arg3);
 }
 
-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__strxfrm__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::strxfrm(arg1, arg2, x);
 }
 
-void test__std__stod__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::stod(arg1, 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__stod__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stod(x, arg2);
+void test__wcsxfrm__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcsxfrm(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__stod__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stod(arg1, x);
+void test__wcsxfrm__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcsxfrm(arg1, NULL, arg3);
 }
 
-void test__stold__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = stold(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__stold__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  stold(arg1, arg2);
+void test__wcsxfrm__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wcsxfrm(arg1, arg2, x);
 }
 
-void test__stold__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = stold(p, arg2);
-  // cppcheck-suppress memleak
+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__stold__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stold(x, arg2);
+void test__std__wcsxfrm__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcsxfrm(arg1, NULL, arg3);
 }
 
-void test__stold__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stold(arg1, x);
+void test__std__wcsxfrm__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wcsxfrm(arg1, x, arg3);
 }
 
-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__wcsxfrm__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wcsxfrm(arg1, arg2, x);
 }
 
-void test__std__stold__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::stold(arg1, 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__stold__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stold(x, arg2);
+void test__wcsspn__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcsspn(arg1, arg2);
 }
 
-void test__std__stold__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stold(arg1, x);
+void test__wcsspn__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((wcsspn(arg1, arg2) > 10) || (wcsspn(arg1, arg2) < 100)) {}
 }
 
-void test__stoi__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = stoi(arg1, arg2, arg3); }
-  // 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__stoi__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  stoi(arg1, arg2, arg3);
+void test__wcsspn__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcsspn(NULL, arg2);
 }
 
-void test__stoi__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = stoi(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__wcsspn__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcsspn(x, arg2);
 }
 
-void test__stoi__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stoi(x, arg2, arg3);
+void test__wcsspn__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcsspn(arg1, NULL);
 }
 
-void test__stoi__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stoi(arg1, x, arg3);
+void test__wcsspn__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcsspn(arg1, x);
 }
 
-void test__stoi__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stoi(arg1, arg2, 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__stoi__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::stoi(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wcsspn__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wcsspn(arg1, arg2);
 }
 
-void test__std__stoi__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::stoi(arg1, arg2, arg3);
+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__stoi__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stoi(x, arg2, arg3);
+void test__std__wcsspn__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcsspn(NULL, arg2);
 }
 
-void test__std__stoi__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stoi(arg1, x, arg3);
+void test__std__wcsspn__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcsspn(x, arg2);
 }
 
-void test__std__stoi__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stoi(arg1, arg2, x);
+void test__std__wcsspn__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcsspn(arg1, NULL);
 }
 
-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__wcsspn__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcsspn(arg1, x);
 }
 
-void test__stol__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  stol(arg1, arg2, arg3);
+void test__localeconv__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = localeconv();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__stol__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = stol(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__localeconv__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    localeconv();
 }
 
-void test__stol__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stol(x, arg2, arg3);
+void test__localeconv__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = localeconv();
+    // cppcheck-suppress memleak
 }
 
-void test__stol__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stol(arg1, x, arg3);
+void test__std__localeconv__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::localeconv();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__stol__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stol(arg1, arg2, x);
+void test__std__localeconv__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::localeconv();
 }
 
-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__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__stol__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::stol(arg1, arg2, arg3);
+void test__std__locale__global__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::locale::global(arg1);
 }
 
-void test__std__stol__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stol(x, arg2, arg3);
+void test__std__locale__global__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::locale::global(x);
 }
 
-void test__std__stol__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stol(arg1, x, 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__std__stol__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stol(arg1, arg2, x);
+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__stoll__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = stoll(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__setlocale__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    setlocale(arg1, x);
 }
 
-void test__stoll__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  stoll(arg1, arg2, 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__stoll__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = stoll(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__setlocale__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::setlocale(arg1, x);
 }
 
-void test__stoll__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stoll(x, arg2, arg3);
+void test__strerror__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = strerror(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__stoll__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stoll(arg1, x, arg3);
+void test__strerror__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    strerror(arg1);
 }
 
-void test__stoll__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stoll(arg1, arg2, x);
+void test__strerror__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = strerror(p);
+    // cppcheck-suppress memleak
 }
 
-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__strerror__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = strerror(x);
 }
 
-void test__std__stoll__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::stoll(arg1, arg2, arg3);
+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__stoll__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stoll(x, arg2, arg3);
+void test__std__strerror__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::strerror(arg1);
 }
 
-void test__std__stoll__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stoll(arg1, x, arg3);
+void test__std__strerror__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::strerror(x);
 }
 
-void test__std__stoll__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stoll(arg1, arg2, x);
+void test__strcspn__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = strcspn(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__strcspn__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    strcspn(arg1, arg2);
 }
 
-void test__stoul__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  stoul(arg1, arg2, arg3);
+void test__strcspn__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((strcspn(arg1, arg2) > 10) || (strcspn(arg1, arg2) < 100)) {}
 }
 
-void test__stoul__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = stoul(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__strcspn__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = strcspn(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__stoul__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stoul(x, arg2, arg3);
+void test__strcspn__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strcspn(NULL, arg2);
 }
 
-void test__stoul__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stoul(arg1, x, arg3);
+void test__strcspn__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strcspn(x, arg2);
 }
 
-void test__stoul__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stoul(arg1, arg2, x);
+void test__strcspn__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strcspn(arg1, NULL);
 }
 
-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__strcspn__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strcspn(arg1, x);
 }
 
-void test__std__stoul__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::stoul(arg1, arg2, arg3);
+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__std__stoul__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stoul(x, arg2, arg3);
+void test__std__strcspn__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::strcspn(arg1, arg2);
 }
 
-void test__std__stoul__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stoul(arg1, x, 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__std__stoul__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stoul(arg1, arg2, x);
+void test__std__strcspn__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strcspn(NULL, arg2);
 }
 
-void test__stoull__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = stoull(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__strcspn__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strcspn(x, arg2);
 }
 
-void test__stoull__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  stoull(arg1, arg2, arg3);
+void test__std__strcspn__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strcspn(arg1, NULL);
 }
 
-void test__stoull__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = stoull(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__strcspn__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strcspn(arg1, x);
 }
 
-void test__stoull__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stoull(x, arg2, arg3);
+void test__wcscspn__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wcscspn(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__stoull__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stoull(arg1, x, arg3);
+void test__wcscspn__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcscspn(arg1, arg2);
 }
 
-void test__stoull__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = stoull(arg1, arg2, x);
+void test__wcscspn__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((wcscspn(arg1, arg2) > 10) || (wcscspn(arg1, arg2) < 100)) {}
 }
 
-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__wcscspn__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wcscspn(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__stoull__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::stoull(arg1, arg2, arg3);
+void test__wcscspn__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcscspn(NULL, arg2);
 }
 
-void test__std__stoull__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stoull(x, arg2, arg3);
+void test__wcscspn__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcscspn(x, arg2);
 }
 
-void test__std__stoull__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stoull(arg1, x, arg3);
+void test__wcscspn__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcscspn(arg1, NULL);
 }
 
-void test__std__stoull__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::stoull(arg1, arg2, x);
+void test__wcscspn__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcscspn(arg1, 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__std__wcscspn__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::wcscspn(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__to_string__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::to_string(arg1);
+void test__std__wcscspn__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wcscspn(arg1, arg2);
 }
 
-void test__std__to_string__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::to_string(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__string__resize__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::string::resize(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wcscspn__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcscspn(NULL, arg2);
 }
 
-void test__std__string__resize__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::string::resize(x, arg2);
+void test__std__wcscspn__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcscspn(x, arg2);
 }
 
-void test__std__string__resize__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::string::resize(arg1, x);
+void test__std__wcscspn__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcscspn(arg1, NULL);
 }
 
-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__wcscspn__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcscspn(arg1, x);
 }
 
-void test__std__wstring__resize__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wstring::resize(x, arg2);
+void test__wcspbrk__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wcspbrk(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__wstring__resize__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wstring::resize(arg1, x);
+void test__wcspbrk__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcspbrk(arg1, arg2);
 }
 
-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__wcspbrk__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wcspbrk(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__to_wstring__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::to_wstring(arg1);
+void test__wcspbrk__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcspbrk(NULL, arg2);
 }
 
-void test__std__to_wstring__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::to_wstring(x);
+void test__wcspbrk__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcspbrk(x, arg2);
 }
 
-void test__mbrtowc__noreturn() {
-  int x = 1;
-  if (cond) { x=100; mbrtowc(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcspbrk__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = wcspbrk(arg1, x);
 }
 
-void test__mbrtowc__leakignore() {
-  char *p = malloc(10); *p=0;
-  mbrtowc(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+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__mbrtowc__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mbrtowc(arg1, x, arg3, arg4);
+void test__std__wcspbrk__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wcspbrk(arg1, arg2);
 }
 
-void test__mbrtowc__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mbrtowc(arg1, arg2, x, arg4);
+void test__std__wcspbrk__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcspbrk(NULL, arg2);
 }
 
-void test__mbrtowc__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mbrtowc(arg1, arg2, arg3, x);
+void test__std__wcspbrk__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcspbrk(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__std__wcspbrk__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wcspbrk(arg1, x);
 }
 
-void test__std__mbrtowc__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::mbrtowc(arg1, x, arg3, arg4);
+void test__wcsncpy__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wcsncpy(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__mbrtowc__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::mbrtowc(arg1, arg2, x, arg4);
+void test__wcsncpy__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcsncpy(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__mbrtowc__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::mbrtowc(arg1, arg2, arg3, x);
+void test__wcsncpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcsncpy(NULL, arg2, arg3);
 }
 
-void test__wcstok__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wcstok(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcsncpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcsncpy(arg1, NULL, arg3);
 }
 
-void test__wcstok__leakignore() {
-  char *p = malloc(10); *p=0;
-  wcstok(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__wcsncpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcsncpy(arg1, x, arg3);
 }
 
-void test__wcstok__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wcstok(x, arg2, arg3);
+void test__wcsncpy__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wcsncpy(arg1, arg2, !x);
 }
 
-void test__wcstok__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcstok(arg1, p, arg3);
+void test__wcsncpy__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wcsncpy(arg1, arg2, x);
 }
 
-void test__wcstok__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcstok(arg1, x, arg3);
+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__wcstok__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcstok(arg1, arg2, p);
+void test__std__wcsncpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcsncpy(NULL, arg2, arg3);
 }
 
-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__wcsncpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcsncpy(arg1, NULL, arg3);
 }
 
-void test__std__wcstok__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wcstok(x, arg2, arg3);
+void test__std__wcsncpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wcsncpy(arg1, x, arg3);
 }
 
-void test__std__wcstok__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcstok(arg1, p, arg3);
+void test__std__wcsncpy__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    std::wcsncpy(arg1, arg2, !x);
 }
 
-void test__std__wcstok__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wcstok(arg1, x, arg3);
+void test__std__wcsncpy__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wcsncpy(arg1, arg2, x);
 }
 
-void test__std__wcstok__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcstok(arg1, arg2, p);
+void test__strcoll__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = strcoll(arg1, arg2);
+    }
+    // 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__strcoll__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    strcoll(arg1, arg2);
 }
 
-void test__wcstoimax__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcstoimax(arg1, arg2, arg3);
+void test__strcoll__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = strcoll(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__wcstoimax__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcstoimax(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__strcoll__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strcoll(NULL, arg2);
 }
 
-void test__wcstoimax__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcstoimax(p, arg2, arg3);
+void test__strcoll__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strcoll(x, arg2);
 }
 
-void test__wcstoimax__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcstoimax(x, arg2, arg3);
+void test__strcoll__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strcoll(arg1, NULL);
 }
 
-void test__wcstoimax__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wcstoimax(arg1, arg2, x);
+void test__strcoll__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strcoll(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__std__strcoll__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::strcoll(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__wcstoimax__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wcstoimax(arg1, arg2, arg3);
+void test__std__strcoll__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::strcoll(arg1, arg2);
 }
 
-void test__std__wcstoimax__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcstoimax(p, arg2, arg3);
+void test__std__strcoll__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strcoll(NULL, arg2);
 }
 
-void test__std__wcstoimax__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcstoimax(x, arg2, arg3);
+void test__std__strcoll__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strcoll(x, arg2);
 }
 
-void test__std__wcstoimax__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wcstoimax(arg1, arg2, x);
+void test__std__strcoll__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strcoll(arg1, NULL);
 }
 
-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__strcoll__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strcoll(arg1, x);
 }
 
-void test__wcstoumax__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcstoumax(arg1, arg2, arg3);
+void test__wcscoll__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wcscoll(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__wcscoll__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcscoll(arg1, arg2);
 }
 
-void test__wcstoumax__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcstoumax(p, arg2, arg3);
+void test__wcscoll__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wcscoll(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__wcstoumax__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcstoumax(x, arg2, arg3);
+void test__wcscoll__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcscoll(NULL, arg2);
 }
 
-void test__wcstoumax__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wcstoumax(arg1, arg2, x);
+void test__wcscoll__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcscoll(x, arg2);
 }
 
-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__wcscoll__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcscoll(arg1, NULL);
 }
 
-void test__std__wcstoumax__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wcstoumax(arg1, arg2, arg3);
+void test__wcscoll__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcscoll(arg1, x);
 }
 
-void test__std__wcstoumax__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wcstoumax(p, arg2, arg3);
+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__std__wcstoumax__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wcstoumax(x, arg2, arg3);
+void test__std__wcscoll__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wcscoll(arg1, arg2);
 }
 
-void test__std__wcstoumax__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wcstoumax(arg1, arg2, x);
+void test__std__wcscoll__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcscoll(NULL, arg2);
 }
 
-void test__wcstol__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wcstol(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wcscoll__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcscoll(x, arg2);
 }
 
-void test__wcstol__leakignore() {
-  char *p = malloc(10); *p=0;
-  wcstol(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__wcscoll__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcscoll(arg1, NULL);
 }
 
-void test__wcstol__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcstol(p, arg2, arg3);
+void test__std__wcscoll__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcscoll(arg1, x);
 }
 
-void test__wcstol__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcstol(x, arg2, arg3);
+void test__strrchr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = strrchr(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcstol__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wcstol(arg1, arg2, x);
+void test__strrchr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    strrchr(arg1, 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__strrchr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = strrchr(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wcstol__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcstol(p, arg2, arg3);
+void test__strrchr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strrchr(NULL, arg2);
 }
 
-void test__std__wcstol__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wcstol(x, arg2, arg3);
+void test__strrchr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strrchr(x, arg2);
 }
 
-void test__std__wcstol__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wcstol(arg1, arg2, x);
+void test__strrchr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = strrchr(arg1, 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__strrchr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::strrchr(arg1, arg2);
+    }
+    // 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__strrchr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::strrchr(arg1, arg2);
 }
 
-void test__wcstoll__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcstoll(p, arg2, arg3);
+void test__std__strrchr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::strrchr(NULL, arg2);
 }
 
-void test__wcstoll__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcstoll(x, arg2, arg3);
+void test__std__strrchr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::strrchr(x, arg2);
 }
 
-void test__wcstoll__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wcstoll(arg1, arg2, x);
+void test__std__strrchr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::strrchr(arg1, 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__wcsrchr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wcsrchr(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__wcstoll__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcstoll(p, arg2, arg3);
+void test__wcsrchr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcsrchr(arg1, arg2);
 }
 
-void test__std__wcstoll__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wcstoll(x, arg2, arg3);
+void test__wcsrchr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wcsrchr(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wcstoll__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wcstoll(arg1, arg2, x);
+void test__wcsrchr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcsrchr(NULL, arg2);
 }
 
-void test__wcstoul__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wcstoul(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcsrchr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcsrchr(x, arg2);
 }
 
-void test__wcstoul__leakignore() {
-  char *p = malloc(10); *p=0;
-  wcstoul(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__wcsrchr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = wcsrchr(arg1, x);
 }
 
-void test__wcstoul__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcstoul(p, arg2, arg3);
+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__wcstoul__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcstoul(x, arg2, arg3);
+void test__std__wcsrchr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wcsrchr(arg1, arg2);
 }
 
-void test__wcstoul__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wcstoul(arg1, arg2, x);
+void test__std__wcsrchr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcsrchr(NULL, arg2);
 }
 
-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__wcsrchr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcsrchr(x, arg2);
 }
 
-void test__std__wcstoul__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcstoul(p, arg2, arg3);
+void test__std__wcsrchr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wcsrchr(arg1, x);
 }
 
-void test__std__wcstoul__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wcstoul(x, 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__wcstoul__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wcstoul(arg1, arg2, x);
+void test__wcsrtombs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcsrtombs(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__wcstoull__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wcstoull(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcsrtombs__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcsrtombs(arg1, NULL, arg3, arg4);
 }
 
-void test__wcstoull__leakignore() {
-  char *p = malloc(10); *p=0;
-  wcstoull(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__wcsrtombs__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcsrtombs(arg1, x, arg3, arg4);
 }
 
-void test__wcstoull__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcstoull(p, arg2, arg3);
+void test__wcsrtombs__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wcsrtombs(arg1, arg2, x, arg4);
 }
 
-void test__wcstoull__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcstoull(x, arg2, arg3);
+void test__wcsrtombs__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcsrtombs(arg1, arg2, arg3, NULL);
 }
 
-void test__wcstoull__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wcstoull(arg1, arg2, 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__std__wcstoull__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::wcstoull(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wcsrtombs__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcsrtombs(arg1, NULL, arg3, arg4);
 }
 
-void test__std__wcstoull__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wcstoull(p, arg2, arg3);
+void test__std__wcsrtombs__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wcsrtombs(arg1, x, arg3, arg4);
 }
 
-void test__std__wcstoull__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wcstoull(x, arg2, arg3);
+void test__std__wcsrtombs__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wcsrtombs(arg1, arg2, x, arg4);
 }
 
-void test__std__wcstoull__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wcstoull(arg1, arg2, x);
+void test__std__wcsrtombs__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcsrtombs(arg1, arg2, arg3, NULL);
 }
 
-void test__wprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wprintf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strtok__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strtok(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  wprintf(p);
-  // cppcheck-suppress memleak
+void test__strtok__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((strtok(arg1, arg2) > 10) || (strtok(arg1, arg2) < 100)) {}
 }
 
-void test__wprintf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wprintf(p);
+void test__strtok__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strtok(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__wprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::wprintf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strtok__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    strtok(x, arg2);
 }
 
-void test__std__wprintf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wprintf(p);
+void test__strtok__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strtok(arg1, NULL);
 }
 
-void test__sprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; sprintf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strtok__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strtok(arg1, x);
 }
 
-void test__sprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  sprintf(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__strtok__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::strtok(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__sprintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sprintf(x, arg2);
+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__sprintf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  sprintf(arg1, p);
+void test__std__strtok__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::strtok(x, arg2);
 }
 
-void test__sprintf__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  sprintf(arg1, x);
+void test__std__strtok__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strtok(arg1, NULL);
 }
 
-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__strtok__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strtok(arg1, x);
 }
 
-void test__std__sprintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::sprintf(x, arg2);
+void test__strtof__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strtof(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__sprintf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::sprintf(arg1, p);
+void test__strtof__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strtof(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__sprintf__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::sprintf(arg1, x);
+void test__strtof__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strtof(NULL, arg2);
 }
 
-void test__swprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; swprintf(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strtof__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strtof(x, arg2);
 }
 
-void test__swprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  swprintf(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__strtof__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::strtof(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__swprintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  swprintf(x, arg2, arg3);
+void test__std__strtof__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strtof(NULL, arg2);
 }
 
-void test__swprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  swprintf(arg1, x, arg3);
+void test__std__strtof__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strtof(x, arg2);
 }
 
-void test__swprintf__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  swprintf(arg1, arg2, p);
+void test__strtod__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strtod(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__swprintf__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  swprintf(arg1, arg2, x);
+void test__strtod__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strtod(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__strtod__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strtod(NULL, arg2);
 }
 
-void test__std__swprintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::swprintf(x, arg2, arg3);
+void test__strtod__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strtod(x, arg2);
 }
 
-void test__std__swprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::swprintf(arg1, x, arg3);
+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__swprintf__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::swprintf(arg1, arg2, p);
+void test__std__strtod__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strtod(NULL, arg2);
 }
 
-void test__std__swprintf__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::swprintf(arg1, arg2, x);
+void test__std__strtod__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strtod(x, arg2);
 }
 
-void test__vsprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; vsprintf(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strtold__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strtold(arg1, arg2);
+    }
+    // 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__strtold__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strtold(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__vsprintf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vsprintf(p, arg2, arg3);
+void test__strtold__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strtold(NULL, arg2);
 }
 
-void test__vsprintf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vsprintf(arg1, p, arg3);
+void test__strtold__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strtold(x, arg2);
 }
 
-void test__vsprintf__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  vsprintf(arg1, x, arg3);
+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__vsprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::vsprintf(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__strtold__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strtold(NULL, arg2);
 }
 
-void test__std__vsprintf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::vsprintf(p, arg2, arg3);
+void test__std__strtold__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strtold(x, arg2);
 }
 
-void test__std__vsprintf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::vsprintf(arg1, p, arg3);
+void test__strtol__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strtol(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__vsprintf__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::vsprintf(arg1, x, arg3);
+void test__strtol__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strtol(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__vswprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; vswprintf(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strtol__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strtol(NULL, arg2, arg3);
 }
 
-void test__vswprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  vswprintf(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__strtol__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strtol(x, arg2, arg3);
 }
 
-void test__vswprintf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vswprintf(p, arg2, arg3, arg4);
+void test__strtol__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    strtol(arg1, arg2, x);
 }
 
-void test__vswprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  vswprintf(arg1, x, arg3, arg4);
+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__vswprintf__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vswprintf(arg1, arg2, p, arg4);
+void test__std__strtol__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strtol(NULL, arg2, arg3);
 }
 
-void test__vswprintf__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  vswprintf(arg1, arg2, x, arg4);
+void test__std__strtol__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strtol(x, arg2, arg3);
 }
 
-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__strtol__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::strtol(arg1, arg2, x);
 }
 
-void test__std__vswprintf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::vswprintf(p, arg2, arg3, arg4);
+void test__strtoul__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strtoul(arg1, arg2, arg3);
+    }
+    // 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__strtoul__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strtoul(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__vswprintf__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::vswprintf(arg1, arg2, p, arg4);
+void test__strtoul__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strtoul(NULL, arg2, arg3);
 }
 
-void test__std__vswprintf__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::vswprintf(arg1, arg2, x, arg4);
+void test__strtoul__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strtoul(x, arg2, arg3);
 }
 
-void test__fwprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fwprintf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strtoul__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    strtoul(arg1, arg2, x);
 }
 
-void test__fwprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  fwprintf(p, arg2);
-  // cppcheck-suppress memleak
+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__fwprintf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fwprintf(p, arg2);
+void test__std__strtoul__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strtoul(NULL, arg2, arg3);
 }
 
-void test__fwprintf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fwprintf(arg1, p);
+void test__std__strtoul__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strtoul(x, arg2, arg3);
 }
 
-void test__fwprintf__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fwprintf(arg1, x);
+void test__std__strtoul__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::strtoul(arg1, arg2, 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__strtoll__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strtoll(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fwprintf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fwprintf(p, arg2);
+void test__strtoll__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strtoll(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__fwprintf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::fwprintf(arg1, p);
+void test__strtoll__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strtoll(NULL, arg2, arg3);
 }
 
-void test__std__fwprintf__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::fwprintf(arg1, x);
+void test__strtoll__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strtoll(x, arg2, arg3);
 }
 
-void test__snprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; snprintf(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strtoll__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    strtoll(arg1, arg2, x);
 }
 
-void test__snprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  snprintf(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__snprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  snprintf(arg1, x, arg3);
+void test__std__strtoll__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strtoll(NULL, arg2, arg3);
 }
 
-void test__snprintf__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  snprintf(arg1, arg2, p);
+void test__std__strtoll__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strtoll(x, arg2, arg3);
 }
 
-void test__snprintf__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  snprintf(arg1, arg2, x);
+void test__std__strtoll__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::strtoll(arg1, arg2, 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__strtoull__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strtoull(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__snprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::snprintf(arg1, x, arg3);
+void test__strtoull__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strtoull(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__snprintf__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::snprintf(arg1, arg2, p);
+void test__strtoull__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strtoull(NULL, arg2, arg3);
 }
 
-void test__std__snprintf__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::snprintf(arg1, arg2, x);
+void test__strtoull__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strtoull(x, arg2, arg3);
 }
 
-void test__vsnprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; vsnprintf(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strtoull__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    strtoull(arg1, arg2, x);
 }
 
-void test__vsnprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  vsnprintf(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+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__vsnprintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  vsnprintf(x, arg2, arg3, arg4);
+void test__std__strtoull__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strtoull(NULL, arg2, arg3);
 }
 
-void test__vsnprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  vsnprintf(arg1, x, arg3, arg4);
+void test__std__strtoull__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strtoull(x, arg2, arg3);
 }
 
-void test__vsnprintf__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vsnprintf(arg1, arg2, p, arg4);
+void test__std__strtoull__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::strtoull(arg1, arg2, x);
 }
 
-void test__vsnprintf__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  vsnprintf(arg1, arg2, x, arg4);
+void test__strtoimax__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strtoimax(arg1, arg2, arg3);
+    }
+    // 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__strtoimax__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strtoimax(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__vsnprintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::vsnprintf(x, arg2, arg3, arg4);
+void test__strtoimax__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strtoimax(NULL, arg2, arg3);
 }
 
-void test__std__vsnprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::vsnprintf(arg1, x, arg3, arg4);
+void test__strtoimax__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strtoimax(x, arg2, arg3);
 }
 
-void test__std__vsnprintf__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::vsnprintf(arg1, arg2, p, arg4);
+void test__strtoimax__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    strtoimax(arg1, arg2, x);
 }
 
-void test__std__vsnprintf__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::vsnprintf(arg1, arg2, x, arg4);
+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__wscanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wscanf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__strtoimax__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::strtoimax(NULL, arg2, arg3);
 }
 
-void test__wscanf__leakignore() {
-  char *p = malloc(10); *p=0;
-  wscanf(p);
-  // cppcheck-suppress memleak
+void test__std__strtoimax__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::strtoimax(x, arg2, arg3);
 }
 
-void test__wscanf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wscanf(p);
+void test__std__strtoimax__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::strtoimax(arg1, arg2, x);
 }
 
-void test__wscanf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wscanf(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__wscanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::wscanf(arg1); }
-  // 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__wscanf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::wscanf(p);
-}
+void test__strtoumax__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strtoumax(NULL, arg2, arg3);
+}
 
-void test__std__wscanf__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::wscanf(x);
+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__sscanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; sscanf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__sscanf__leakignore() {
-  char *p = malloc(10); *p=0;
-  sscanf(p, arg2);
-  // cppcheck-suppress memleak
+
+void test__tolower__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = tolower(p);
+    // cppcheck-suppress memleak
 }
-
-void test__sscanf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  sscanf(x, arg2);
+
+void test__tolower__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = tolower(x);
 }
-
-void test__sscanf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  sscanf(arg1, p);
+
+void test__std__tolower__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::tolower(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
-
-void test__sscanf__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  sscanf(arg1, x);
+
+void test__std__tolower__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::tolower(arg1);
 }
 
-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__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__std__sscanf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::sscanf(x, arg2);
+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__sscanf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::sscanf(arg1, p);
+
+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__sscanf__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  std::sscanf(arg1, x);
+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__fwscanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fwscanf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcstof__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcstof(x, arg2);
 }
 
-void test__fwscanf__leakignore() {
-  char *p = malloc(10); *p=0;
-  fwscanf(p, arg2);
-  // cppcheck-suppress memleak
+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__fwscanf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fwscanf(x, arg2);
+void test__std__wcstof__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wcstof(arg1, arg2);
 }
 
-void test__fwscanf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  fwscanf(arg1, x);
+void test__std__wcstof__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcstof(NULL, 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__std__wcstof__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcstof(x, arg2);
 }
 
-void test__std__fwscanf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fwscanf(x, arg2);
+void test__wcstod__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wcstod(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__fwscanf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fwscanf(arg1, x);
+void test__wcstod__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcstod(arg1, arg2);
 }
 
-void test__swscanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; swscanf(arg1, arg2); }
-  // 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__swscanf__leakignore() {
-  char *p = malloc(10); *p=0;
-  swscanf(p, arg2);
-  // cppcheck-suppress memleak
+void test__wcstod__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcstod(NULL, arg2);
 }
 
-void test__swscanf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  swscanf(x, arg2);
+void test__wcstod__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcstod(x, arg2);
 }
 
-void test__swscanf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  swscanf(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__std__swscanf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::swscanf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wcstod__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wcstod(arg1, arg2);
 }
 
-void test__std__swscanf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::swscanf(x, arg2);
+void test__std__wcstod__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcstod(NULL, arg2);
 }
 
-void test__std__swscanf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::swscanf(arg1, x);
+void test__std__wcstod__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcstod(x, arg2);
 }
 
-void test__system__noreturn() {
-  int x = 1;
-  if (cond) { x=100; system(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcstold__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wcstold(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__system__leakignore() {
-  char *p = malloc(10); *p=0;
-  system(p);
-  // cppcheck-suppress memleak
+void test__wcstold__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcstold(arg1, arg2);
 }
 
-void test__system__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  system(x);
+void test__wcstold__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wcstold(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__system__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::system(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcstold__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcstold(NULL, arg2);
 }
 
-void test__std__system__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::system(x);
+void test__wcstold__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcstold(x, arg2);
 }
 
-void test__setw__noreturn() {
-  int x = 1;
-  if (cond) { x=100; setw(arg1); }
-  // 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__setw__leakignore() {
-  char *p = malloc(10); *p=0;
-  setw(p);
-  // cppcheck-suppress memleak
+void test__std__wcstold__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wcstold(arg1, arg2);
 }
 
-void test__setw__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setw(x);
+void test__std__wcstold__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcstold(NULL, arg2);
 }
 
-void test__std__setw__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::setw(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wcstold__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcstold(x, arg2);
 }
 
-void test__std__setw__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::setw(x);
+void test__stof__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = stof(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__min__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = min(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__stof__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    stof(arg1, arg2);
 }
 
-void test__min__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  min(arg1, arg2);
+void test__stof__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = stof(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__min__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = min(p, arg2);
-  // cppcheck-suppress memleak
+void test__stof__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stof(x, arg2);
 }
 
-void test__min__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = min(x, arg2);
+void test__stof__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stof(arg1, x);
 }
 
-void test__min__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = min(arg1, 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__std__min__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::min(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__stof__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::stof(arg1, arg2);
 }
 
-void test__std__min__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::min(arg1, arg2);
+void test__std__stof__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stof(x, arg2);
 }
 
-void test__std__min__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::min(x, arg2);
+void test__std__stof__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stof(arg1, x);
 }
 
-void test__std__min__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::min(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__max__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = max(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__stod__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    stod(arg1, arg2);
 }
 
-void test__max__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  max(arg1, arg2);
+void test__stod__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = stod(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__max__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = max(p, arg2);
-  // cppcheck-suppress memleak
+void test__stod__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stod(x, arg2);
 }
 
-void test__max__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = max(x, arg2);
+void test__stod__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stod(arg1, x);
 }
 
-void test__max__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = max(arg1, 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__max__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::max(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__stod__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::stod(arg1, arg2);
 }
 
-void test__std__max__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::max(arg1, arg2);
+void test__std__stod__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stod(x, arg2);
 }
 
-void test__std__max__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::max(x, arg2);
+void test__std__stod__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stod(arg1, x);
 }
 
-void test__std__max__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::max(arg1, x);
+void test__stold__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = stold(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__setiosflags__noreturn() {
-  int x = 1;
-  if (cond) { x=100; setiosflags(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__stold__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    stold(arg1, arg2);
 }
 
-void test__setiosflags__leakignore() {
-  char *p = malloc(10); *p=0;
-  setiosflags(p);
-  // cppcheck-suppress memleak
+void test__stold__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = stold(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__setiosflags__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setiosflags(x);
+void test__stold__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stold(x, arg2);
 }
 
-void test__std__setiosflags__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::setiosflags(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__stold__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stold(arg1, x);
 }
 
-void test__std__setiosflags__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::setiosflags(x);
+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__resetiosflags__noreturn() {
-  int x = 1;
-  if (cond) { x=100; resetiosflags(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__stold__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::stold(arg1, arg2);
 }
 
-void test__resetiosflags__leakignore() {
-  char *p = malloc(10); *p=0;
-  resetiosflags(p);
-  // cppcheck-suppress memleak
+void test__std__stold__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stold(x, arg2);
 }
 
-void test__resetiosflags__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  resetiosflags(x);
+void test__std__stold__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stold(arg1, x);
 }
 
-void test__std__resetiosflags__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::resetiosflags(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+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__resetiosflags__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::resetiosflags(x);
+void test__stoi__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    stoi(arg1, arg2, arg3);
 }
 
-void test__setfill__noreturn() {
-  int x = 1;
-  if (cond) { x=100; setfill(arg1); }
-  // 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__setfill__leakignore() {
-  char *p = malloc(10); *p=0;
-  setfill(p);
-  // cppcheck-suppress memleak
+void test__stoi__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stoi(x, arg2, arg3);
 }
 
-void test__setfill__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setfill(x);
+void test__stoi__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stoi(arg1, x, arg3);
 }
 
-void test__std__setfill__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::setfill(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__stoi__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stoi(arg1, arg2, x);
 }
 
-void test__std__setfill__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::setfill(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__setprecision__noreturn() {
-  int x = 1;
-  if (cond) { x=100; setprecision(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__stoi__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::stoi(arg1, arg2, arg3);
 }
 
-void test__setprecision__leakignore() {
-  char *p = malloc(10); *p=0;
-  setprecision(p);
-  // cppcheck-suppress memleak
+void test__std__stoi__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stoi(x, arg2, arg3);
 }
 
-void test__setprecision__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setprecision(x);
+void test__std__stoi__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stoi(arg1, x, arg3);
 }
 
-void test__std__setprecision__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::setprecision(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__stoi__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stoi(arg1, arg2, x);
 }
 
-void test__std__setprecision__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::setprecision(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__setbase__noreturn() {
-  int x = 1;
-  if (cond) { x=100; setbase(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__stol__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    stol(arg1, arg2, arg3);
 }
 
-void test__setbase__leakignore() {
-  char *p = malloc(10); *p=0;
-  setbase(p);
-  // cppcheck-suppress memleak
+void test__stol__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = stol(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__setbase__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  setbase(x);
+void test__stol__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stol(x, arg2, arg3);
 }
 
-void test__std__setbase__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::setbase(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__stol__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stol(arg1, x, arg3);
 }
 
-void test__std__setbase__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::setbase(x);
+void test__stol__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stol(arg1, arg2, 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__stol__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::stol(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__zonetime__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  zonetime(arg1, arg2);
+void test__std__stol__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::stol(arg1, arg2, arg3);
 }
 
-void test__zonetime__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = zonetime(p, arg2);
-  // cppcheck-suppress memleak
+void test__std__stol__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stol(x, arg2, arg3);
 }
 
-void test__zonetime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = zonetime(p, arg2);
+void test__std__stol__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stol(arg1, x, arg3);
 }
 
-void test__zonetime__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = zonetime(x, arg2);
+void test__std__stol__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stol(arg1, arg2, x);
 }
 
-void test__zonetime__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = zonetime(arg1, 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__c16rtomb__noreturn() {
-  int x = 1;
-  if (cond) { x=100; c16rtomb(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__stoll__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    stoll(arg1, arg2, arg3);
 }
 
-void test__c16rtomb__leakignore() {
-  char *p = malloc(10); *p=0;
-  c16rtomb(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__stoll__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = stoll(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__c16rtomb__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  c16rtomb(arg1, x, arg3);
+void test__stoll__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stoll(x, arg2, arg3);
 }
 
-void test__c16rtomb__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  c16rtomb(arg1, arg2, p);
+void test__stoll__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stoll(arg1, x, arg3);
 }
 
-void test__c16rtomb__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  c16rtomb(arg1, arg2, x);
+void test__stoll__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stoll(arg1, arg2, 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__stoll__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::stoll(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__c32rtomb__leakignore() {
-  char *p = malloc(10); *p=0;
-  c32rtomb(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__stoll__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::stoll(arg1, arg2, arg3);
 }
 
-void test__c32rtomb__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  c32rtomb(arg1, x, arg3);
+void test__std__stoll__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stoll(x, arg2, arg3);
 }
 
-void test__c32rtomb__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  c32rtomb(arg1, arg2, p);
+void test__std__stoll__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stoll(arg1, x, arg3);
 }
 
-void test__c32rtomb__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  c32rtomb(arg1, arg2, x);
+void test__std__stoll__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stoll(arg1, arg2, x);
 }
 
-void test__mbrtoc16__noreturn() {
-  int x = 1;
-  if (cond) { x=100; mbrtoc16(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__mbrtoc16__leakignore() {
-  char *p = malloc(10); *p=0;
-  mbrtoc16(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__stoul__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    stoul(arg1, arg2, arg3);
 }
 
-void test__mbrtoc16__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mbrtoc16(arg1, x, arg3, arg4);
+void test__stoul__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = stoul(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__mbrtoc16__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mbrtoc16(arg1, arg2, x, arg4);
+void test__stoul__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stoul(x, arg2, arg3);
 }
 
-void test__mbrtoc16__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mbrtoc16(arg1, arg2, arg3, p);
+void test__stoul__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stoul(arg1, x, arg3);
 }
 
-void test__mbrtoc16__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  mbrtoc16(arg1, arg2, arg3, x);
+void test__stoul__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stoul(arg1, arg2, 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__stoul__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::stoul(arg1, arg2, arg3);
+    }
+    // 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__stoul__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::stoul(arg1, arg2, arg3);
 }
 
-void test__mbrtoc32__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mbrtoc32(arg1, x, arg3, arg4);
+void test__std__stoul__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stoul(x, arg2, arg3);
 }
 
-void test__mbrtoc32__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  mbrtoc32(arg1, arg2, x, arg4);
+void test__std__stoul__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stoul(arg1, x, arg3);
 }
 
-void test__mbrtoc32__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  mbrtoc32(arg1, arg2, arg3, p);
+void test__std__stoul__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stoul(arg1, arg2, x);
 }
 
-void test__mbrtoc32__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  mbrtoc32(arg1, arg2, arg3, 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__std__swap__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::swap(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__stoull__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    stoull(arg1, arg2, arg3);
 }
 
-void test__std__swap__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::swap(x, arg2);
+void test__stoull__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = stoull(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__swap__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::swap(arg1, x);
+void test__stoull__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stoull(x, arg2, arg3);
 }
 
-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__stoull__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stoull(arg1, x, arg3);
 }
 
-void test__std__ostringstream__str__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ostringstream::str();
+void test__stoull__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = stoull(arg1, arg2, x);
 }
 
-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__stoull__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::stoull(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__ios__good__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ios::good();
+void test__std__stoull__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::stoull(arg1, arg2, arg3);
 }
 
-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__stoull__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stoull(x, arg2, arg3);
 }
 
-void test__std__ios_base__good__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ios_base::good();
+void test__std__stoull__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stoull(arg1, x, arg3);
 }
 
-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__stoull__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::stoull(arg1, arg2, x);
 }
 
-void test__std__ostream__good__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ostream::good();
+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__std__ofstream__good__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::ofstream::good(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__to_string__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::to_string(arg1);
 }
 
-void test__std__ofstream__good__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ofstream::good();
+void test__std__to_string__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::to_string(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__std__string__resize__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::string::resize(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__ostringstream__good__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ostringstream::good();
+void test__std__string__resize__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::string::resize(x, arg2);
 }
 
-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__string__resize__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::string::resize(arg1, x);
 }
 
-void test__std__ios__eof__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ios::eof();
+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__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__wstring__resize__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wstring::resize(x, arg2);
 }
 
-void test__std__ios_base__eof__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ios_base::eof();
+void test__std__wstring__resize__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wstring::resize(arg1, 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__to_wstring__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::to_wstring(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__ostream__eof__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ostream::eof();
+void test__std__to_wstring__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::to_wstring(arg1);
 }
 
-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__to_wstring__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::to_wstring(x);
 }
 
-void test__std__ofstream__eof__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ofstream::eof();
+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__eof__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::ostringstream::eof(); }
-  // 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__std__ostringstream__eof__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ostringstream::eof();
+void test__mbrtowc__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mbrtowc(arg1, x, arg3, arg4);
 }
-
-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__mbrtowc__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mbrtowc(arg1, arg2, x, arg4);
 }
 
-void test__std__ios__fail__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ios::fail();
+void test__mbrtowc__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mbrtowc(arg1, arg2, arg3, x);
 }
 
-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__mbrtowc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::mbrtowc(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__ios_base__fail__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ios_base::fail();
+void test__std__mbrtowc__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::mbrtowc(arg1, x, arg3, arg4);
 }
 
-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__mbrtowc__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::mbrtowc(arg1, arg2, x, arg4);
 }
 
-void test__std__ostream__fail__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ostream::fail();
+void test__std__mbrtowc__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::mbrtowc(arg1, arg2, arg3, x);
 }
 
-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__wcstok__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wcstok(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__ofstream__fail__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ofstream::fail();
+void test__wcstok__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcstok(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__wcstok__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wcstok(x, arg2, arg3);
 }
 
-void test__std__ostringstream__fail__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ostringstream::fail();
+void test__wcstok__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcstok(arg1, NULL, arg3);
 }
 
-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__wcstok__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcstok(arg1, x, arg3);
 }
 
-void test__std__ios__bad__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ios::bad();
+void test__wcstok__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcstok(arg1, arg2, NULL);
 }
 
-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__wcstok__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::wcstok(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__ios_base__bad__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ios_base::bad();
+void test__std__wcstok__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wcstok(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__std__wcstok__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcstok(arg1, NULL, arg3);
 }
 
-void test__std__ostream__bad__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ostream::bad();
+void test__std__wcstok__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wcstok(arg1, x, arg3);
 }
 
-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__wcstok__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcstok(arg1, arg2, NULL);
 }
 
-void test__std__ofstream__bad__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ofstream::bad();
+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__bad__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::ostringstream::bad(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcstoimax__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcstoimax(arg1, arg2, arg3);
 }
 
-void test__std__ostringstream__bad__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::ostringstream::bad();
+void test__wcstoimax__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wcstoimax(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__array__clear__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::array::clear(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcstoimax__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcstoimax(NULL, arg2, arg3);
 }
 
-void test__std__deque__clear__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::deque::clear(); }
-  // 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__list__clear__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::list::clear(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcstoimax__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = wcstoimax(arg1, arg2, 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__wcstoimax__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::wcstoimax(arg1, arg2, arg3);
+    }
+    // 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__wcstoimax__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wcstoimax(arg1, arg2, arg3);
 }
 
-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__wcstoimax__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcstoimax(NULL, arg2, arg3);
 }
 
-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__wcstoimax__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcstoimax(x, 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__wcstoimax__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wcstoimax(arg1, arg2, 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__wcstoumax__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wcstoumax(arg1, arg2, arg3);
+    }
+    // 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__wcstoumax__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcstoumax(arg1, arg2, arg3);
 }
 
-void test__std__string__clear__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::string::clear(); }
-  // 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__wstring__clear__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::wstring::clear(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wcstoumax__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcstoumax(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__wcstoumax__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcstoumax(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__wcstoumax__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = wcstoumax(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__wcstoumax__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::wcstoumax(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__array__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::array::empty();
+void test__std__wcstoumax__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wcstoumax(arg1, 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__wcstoumax__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wcstoumax(NULL, arg2, arg3);
 }
 
-void test__std__deque__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::deque::empty();
+void test__std__wcstoumax__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wcstoumax(x, arg2, arg3);
 }
 
-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__wcstoumax__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wcstoumax(arg1, arg2, x);
 }
 
-void test__std__list__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::list::empty();
+void test__wcstol__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wcstol(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__wcstol__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcstol(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__forward_list__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::forward_list::empty();
+void test__wcstol__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcstol(NULL, 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__wcstol__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcstol(x, arg2, arg3);
 }
 
-void test__std__map__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::map::empty();
+void test__wcstol__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wcstol(arg1, arg2, 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__wcstol__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::wcstol(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__unordered_map__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::unordered_map::empty();
+void test__std__wcstol__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcstol(NULL, 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__wcstol__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wcstol(x, arg2, arg3);
 }
 
-void test__std__queue__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::queue::empty();
+void test__std__wcstol__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wcstol(arg1, arg2, 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__wcstoll__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wcstoll(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__set__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::set::empty();
+void test__wcstoll__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcstoll(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__wcstoll__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcstoll(NULL, arg2, arg3);
 }
 
-void test__std__unordered_set__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::unordered_set::empty();
+void test__wcstoll__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcstoll(x, arg2, arg3);
 }
 
-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__wcstoll__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wcstoll(arg1, arg2, x);
 }
 
-void test__std__stack__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::stack::empty();
+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__string__empty__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::string::empty(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wcstoll__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcstoll(NULL, arg2, arg3);
 }
 
-void test__std__string__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::string::empty();
+void test__std__wcstoll__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wcstoll(x, arg2, arg3);
 }
 
-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__wcstoll__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wcstoll(arg1, arg2, x);
 }
 
-void test__std__wstring__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wstring::empty();
+void test__wcstoul__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wcstoul(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__wcstoul__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcstoul(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__basic_string__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::basic_string::empty();
+void test__wcstoul__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcstoul(NULL, arg2, arg3);
 }
 
-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__wcstoul__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcstoul(x, arg2, arg3);
 }
 
-void test__std__vector__empty__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::vector::empty();
+void test__wcstoul__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wcstoul(arg1, arg2, 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__std__wcstoul__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::wcstoul(arg1, arg2, arg3);
+    }
+    // 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__wcstoul__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcstoul(NULL, arg2, arg3);
 }
 
-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__wcstoul__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wcstoul(x, arg2, arg3);
 }
 
-void test__std__deque__push_front__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::deque::push_front(x);
+void test__std__wcstoul__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wcstoul(arg1, arg2, 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__wcstoull__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wcstoull(arg1, arg2, arg3);
+    }
+    // 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__wcstoull__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcstoull(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__wcstoull__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcstoull(NULL, arg2, arg3);
 }
 
-void test__std__list__push_front__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::list::push_front(x);
+void test__wcstoull__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcstoull(x, arg2, arg3);
 }
 
-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__wcstoull__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wcstoull(arg1, arg2, x);
 }
 
-void test__std__forward_list__push_front__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::forward_list::push_front(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__queue__push__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::queue::push(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__wcstoull__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wcstoull(NULL, arg2, arg3);
 }
 
-void test__std__queue__push__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::queue::push(x);
+void test__std__wcstoull__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wcstoull(x, arg2, 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__std__wcstoull__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::wcstoull(arg1, arg2, x);
 }
 
-void test__std__stack__push__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::stack::push(x);
+void test__wprintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wprintf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__wprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wprintf(p);
+    // cppcheck-suppress memleak
 }
 
-void test__std__vector__push_back__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::vector::push_back(x);
+void test__wprintf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wprintf(NULL);
 }
 
-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__wprintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::wprintf(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__wprintf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wprintf(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__sprintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        sprintf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__list__insert__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::list::insert(x);
+void test__sprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    sprintf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__sprintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sprintf(x, arg2);
 }
 
-void test__std__multimap__insert__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::multimap::insert(x);
+void test__sprintf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    sprintf(arg1, NULL);
 }
 
-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__sprintf__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    sprintf(arg1, x);
 }
 
-void test__std__set__insert__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::set::insert(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__string__insert__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::string::insert(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__sprintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::sprintf(x, arg2);
 }
 
-void test__std__string__insert__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::string::insert(x);
+void test__std__sprintf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::sprintf(arg1, NULL);
 }
 
-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__sprintf__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::sprintf(arg1, x);
 }
 
-void test__std__vector__insert__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::vector::insert(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__deque__emplace_back__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::deque::emplace_back(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__swprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    swprintf(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__swprintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    swprintf(x, arg2, arg3);
 }
 
-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__swprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    swprintf(arg1, x, arg3);
 }
 
-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__swprintf__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    swprintf(arg1, arg2, NULL);
 }
 
-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__swprintf__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    swprintf(arg1, arg2, 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__swprintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::swprintf(arg1, arg2, arg3);
+    }
+    // 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__swprintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::swprintf(x, arg2, arg3);
 }
 
-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__swprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::swprintf(arg1, x, arg3);
 }
 
-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__swprintf__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::swprintf(arg1, arg2, NULL);
 }
 
-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__swprintf__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::swprintf(arg1, arg2, x);
 }
 
-void test__std__list__find__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::list::find(arg1);
+void test__vsprintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        vsprintf(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__list__find__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::list::find(x);
+void test__vsprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    vsprintf(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__vsprintf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vsprintf(NULL, arg2, arg3);
 }
 
-void test__std__map__find__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::map::find(arg1);
+void test__vsprintf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vsprintf(arg1, NULL, arg3);
 }
 
-void test__std__map__find__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::map::find(x);
+void test__vsprintf__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    vsprintf(arg1, x, arg3);
 }
 
-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__vsprintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::vsprintf(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__set__find__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::set::find(arg1);
+void test__std__vsprintf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::vsprintf(NULL, arg2, arg3);
 }
 
-void test__std__set__find__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::set::find(x);
+void test__std__vsprintf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::vsprintf(arg1, NULL, arg3);
 }
 
-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__vsprintf__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::vsprintf(arg1, x, arg3);
 }
 
-void test__std__vector__find__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::vector::find(arg1);
+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__vector__find__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::vector::find(x);
+void test__vswprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    vswprintf(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-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__vswprintf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vswprintf(NULL, arg2, arg3, arg4);
 }
 
-void test__std__deque__size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::deque::size();
+void test__vswprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    vswprintf(arg1, x, arg3, arg4);
 }
 
-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__vswprintf__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vswprintf(arg1, arg2, NULL, arg4);
 }
 
-void test__std__deque__max_size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::deque::max_size();
+void test__vswprintf__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    vswprintf(arg1, arg2, x, arg4);
 }
 
-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__vswprintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::vswprintf(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__list__size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::list::size();
+void test__std__vswprintf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::vswprintf(NULL, arg2, arg3, arg4);
 }
 
-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__vswprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::vswprintf(arg1, x, arg3, arg4);
 }
 
-void test__std__list__max_size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::list::max_size();
+void test__std__vswprintf__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::vswprintf(arg1, arg2, NULL, arg4);
 }
 
-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__vswprintf__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::vswprintf(arg1, arg2, x, arg4);
 }
 
-void test__std__map__size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::map::size();
+void test__fwprintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        fwprintf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__fwprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    fwprintf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__map__max_size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::map::max_size();
+void test__fwprintf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fwprintf(NULL, arg2);
 }
 
-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__fwprintf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fwprintf(arg1, NULL);
 }
 
-void test__std__unordered_map__size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::unordered_map::size();
+void test__fwprintf__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fwprintf(arg1, x);
 }
 
-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__fwprintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::fwprintf(arg1, arg2);
+    }
+    // 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__fwprintf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fwprintf(NULL, arg2);
 }
 
-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__fwprintf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::fwprintf(arg1, NULL);
 }
 
-void test__std__queue__size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::queue::size();
+void test__std__fwprintf__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::fwprintf(arg1, x);
 }
 
-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__snprintf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        snprintf(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__set__size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::set::size();
+void test__snprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    snprintf(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__snprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    snprintf(arg1, x, arg3);
 }
 
-void test__std__set__max_size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::set::max_size();
+void test__snprintf__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    snprintf(arg1, arg2, 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__snprintf__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    snprintf(arg1, arg2, x);
 }
 
-void test__std__unordered_set__size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::unordered_set::size();
+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__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__snprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::snprintf(arg1, x, arg3);
 }
 
-void test__std__unordered_set__max_size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::unordered_set::max_size();
+void test__std__snprintf__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::snprintf(arg1, arg2, NULL);
 }
 
-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__snprintf__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::snprintf(arg1, arg2, x);
 }
 
-void test__std__stack__size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::stack::size();
+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__string__size__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::string::size(); }
-  // 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__std__string__size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::string::size();
+void test__vsnprintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    vsnprintf(x, arg2, arg3, arg4);
 }
 
-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__vsnprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    vsnprintf(arg1, x, arg3, arg4);
 }
 
-void test__std__wstring__size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wstring::size();
+void test__vsnprintf__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vsnprintf(arg1, arg2, NULL, arg4);
 }
 
-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__vsnprintf__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    vsnprintf(arg1, arg2, x, arg4);
 }
 
-void test__std__vector__size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::vector::size();
+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__vector__capacity__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::vector::capacity(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__vsnprintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::vsnprintf(x, arg2, arg3, arg4);
 }
 
-void test__std__vector__capacity__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::vector::capacity();
+void test__std__vsnprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::vsnprintf(arg1, x, arg3, arg4);
 }
 
-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__vsnprintf__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::vsnprintf(arg1, arg2, NULL, arg4);
 }
 
-void test__std__vector__max_size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::vector::max_size();
+void test__std__vsnprintf__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::vsnprintf(arg1, arg2, x, arg4);
 }
 
-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__wscanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wscanf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__array__size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::array::size();
+void test__wscanf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wscanf(p);
+    // cppcheck-suppress memleak
 }
 
-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__wscanf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wscanf(NULL);
 }
 
-void test__std__array__max_size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::array::max_size();
+void test__wscanf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wscanf(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__std__wscanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::wscanf(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__list__back__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::list::back();
+void test__std__wscanf__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::wscanf(NULL);
 }
 
-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__wscanf__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    std::wscanf(x);
 }
 
-void test__std__list__front__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::list::front();
+void test__sscanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        sscanf(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__sscanf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    sscanf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__forward_list__front__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::forward_list::front();
+void test__sscanf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sscanf(x, arg2);
 }
 
-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__sscanf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    sscanf(arg1, NULL);
 }
 
-void test__std__queue__back__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::queue::back();
-}
+void test__sscanf__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    sscanf(arg1, x);
+}
 
-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__sscanf__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::sscanf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__queue__front__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::queue::front();
+void test__std__sscanf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::sscanf(x, arg2);
 }
 
-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__sscanf__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::sscanf(arg1, NULL);
 }
 
-void test__std__vector__back__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::vector::back();
+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__front__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::vector::front(); }
-  // 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__vector__front__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::vector::front();
+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__array__front__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::array::front(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+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__front__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::array::front();
+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__back__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::array::back(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+
+void test__std__min__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::min(x, arg2);
 }
 
-void test__std__array__back__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::array::back();
+void test__std__min__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::min(arg1, x);
 }
 
-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__max__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = max(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__vector__at__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::vector::at(arg1);
+void test__max__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    max(arg1, arg2);
 }
 
-void test__std__vector__at__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::vector::at(x);
-}
+void test__max__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = max(p, arg2);
+    // 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__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__pop_front__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::list::pop_front(); }
-  // 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__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__pop_front__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::forward_list::pop_front(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__zonetime__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    zonetime(arg1, arg2);
 }
 
-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__zonetime__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = zonetime(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__std__stack__pop__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::stack::pop(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__zonetime__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = zonetime(NULL, arg2);
 }
-
-void test__std__queue__pop__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::queue::pop(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+
+void test__zonetime__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = zonetime(x, arg2);
 }
-
-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__zonetime__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = zonetime(arg1, x);
 }
 
-void test__std__stack__top__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::stack::top();
+void test__c16rtomb__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        c16rtomb(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__c16rtomb__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    c16rtomb(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__string__at__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::string::at(arg1);
+void test__c16rtomb__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    c16rtomb(arg1, x, arg3);
 }
 
-void test__std__string__at__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::string::at(x);
+void test__c16rtomb__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    c16rtomb(arg1, arg2, NULL);
 }
 
-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__c16rtomb__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    c16rtomb(arg1, arg2, x);
 }
 
-void test__std__string__push_back__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::string::push_back(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__string__back__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::string::back(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__c32rtomb__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    c32rtomb(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__string__back__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::string::back();
+void test__c32rtomb__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    c32rtomb(arg1, x, arg3);
 }
 
-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__c32rtomb__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    c32rtomb(arg1, arg2, NULL);
 }
 
-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__c32rtomb__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    c32rtomb(arg1, arg2, x);
 }
 
-void test__std__string__c_str__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::string::c_str();
+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__string__data__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = std::string::data(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__mbrtoc16__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    mbrtoc16(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__std__string__data__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::string::data();
+void test__mbrtoc16__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mbrtoc16(arg1, x, arg3, arg4);
 }
 
-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__mbrtoc16__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mbrtoc16(arg1, arg2, x, arg4);
 }
 
-void test__std__string__front__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::string::front();
+void test__mbrtoc16__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    mbrtoc16(arg1, arg2, arg3, NULL);
 }
 
-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__mbrtoc16__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    mbrtoc16(arg1, arg2, arg3, 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__mbrtoc32__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        mbrtoc32(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__basic_string__find_last_not_of__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::basic_string::find_last_not_of(p, arg2, arg3);
+void test__mbrtoc32__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    mbrtoc32(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-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__mbrtoc32__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mbrtoc32(arg1, x, arg3, arg4);
 }
 
-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__mbrtoc32__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    mbrtoc32(arg1, arg2, x, arg4);
 }
 
-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__mbrtoc32__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    mbrtoc32(arg1, arg2, arg3, NULL);
 }
 
-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__mbrtoc32__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    mbrtoc32(arg1, arg2, arg3, x);
 }
 
-void test__std__string__find_last_not_of__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::string::find_last_not_of(arg1, arg2, arg3);
+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__find_last_not_of__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::string::find_last_not_of(p, arg2, arg3);
+void test__std__swap__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::swap(x, arg2);
 }
 
-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__swap__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::swap(arg1, 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__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__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__data__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::string::data();
 }
 
-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__front__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::string::front();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__front__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::string::front();
 }
 
-void test__std__wstring__find_last_not_of__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wstring::find_last_not_of(p, arg2, 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__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__basic_string__find_last_not_of__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::basic_string::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__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__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_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__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_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_first_not_of__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::basic_string::find_first_not_of(arg1, 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__basic_string__find_first_not_of__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::basic_string::find_first_not_of(p, 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_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__string__find_last_not_of__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::string::find_last_not_of(arg1, 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__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_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_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_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_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_first_not_of__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::string::find_first_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_first_not_of__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::string::find_first_not_of(p, 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_first_not_of__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::string::find_first_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__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__wstring__find_last_not_of__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wstring::find_last_not_of(NULL, arg2, 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__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_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_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_first_not_of__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wstring::find_first_not_of(arg1, 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_first_not_of__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wstring::find_first_not_of(p, 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__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__basic_string__find_first_not_of__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::basic_string::find_first_not_of(arg1, 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__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__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__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__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__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__string__find__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::string::find(arg1, arg2, 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__string__find__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::string::find(p, arg2, arg3);
+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__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::string::find(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::string::find(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::string::find(arg1, arg2, x);
+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__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_first_not_of__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::string::find_first_not_of(arg1, x, arg3);
 }
 
-void test__std__string__rfind__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::string::rfind(arg1, arg2, 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__rfind__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::string::rfind(p, arg2, arg3);
+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__string__rfind__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::string::rfind(x, 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__string__rfind__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::string::rfind(arg1, x, 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__string__rfind__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::string::rfind(arg1, arg2, x);
+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__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_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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wstring::find(arg1, 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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wstring::find(p, 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__wstring__find__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wstring::find(x, arg2, arg3);
+void test__std__string__find__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::string::find(arg1, arg2, arg3);
 }
 
-void test__std__wstring__find__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wstring::find(arg1, x, arg3);
+void test__std__string__find__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::string::find(NULL, arg2, arg3);
 }
 
-void test__std__wstring__find__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wstring::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__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__string__find__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::string::find(arg1, x, arg3);
 }
 
-void test__std__wstring__rfind__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wstring::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__wstring__rfind__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wstring::rfind(p, 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__wstring__rfind__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wstring::rfind(x, arg2, arg3);
+void test__std__string__rfind__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::string::rfind(arg1, arg2, arg3);
 }
 
-void test__std__wstring__rfind__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wstring::rfind(arg1, x, arg3);
+void test__std__string__rfind__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::string::rfind(NULL, arg2, arg3);
 }
 
-void test__std__wstring__rfind__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wstring::rfind(arg1, arg2, x);
+void test__std__string__rfind__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::string::rfind(x, arg2, arg3);
 }
 
-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__string__rfind__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::string::rfind(arg1, x, arg3);
 }
 
-void test__std__basic_string__find__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::basic_string::find(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__basic_string__find__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::basic_string::find(p, 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__basic_string__find__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::basic_string::find(x, arg2, arg3);
+void test__std__wstring__find__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wstring::find(arg1, 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__find__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wstring::find(NULL, arg2, 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__find__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wstring::find(x, 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__wstring__find__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wstring::find(arg1, x, arg3);
 }
 
-void test__std__basic_string__rfind__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::basic_string::rfind(arg1, arg2, arg3);
+void test__std__wstring__find__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wstring::find(arg1, arg2, x);
 }
 
-void test__std__basic_string__rfind__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::basic_string::rfind(p, 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__basic_string__rfind__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::basic_string::rfind(x, arg2, arg3);
+void test__std__wstring__rfind__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wstring::rfind(arg1, 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__wstring__rfind__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wstring::rfind(NULL, 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__rfind__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::wstring::rfind(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__rfind__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wstring::rfind(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__rfind__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wstring::rfind(arg1, arg2, x);
 }
 
-void test__std__string__find_first_of__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::string::find_first_of(p, arg2, arg3);
+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__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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::basic_string::find(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__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::basic_string::find(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__find__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::basic_string::find(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__find__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::basic_string::find(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__find__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::basic_string::find(arg1, arg2, x);
 }
 
-void test__std__wstring__find_first_of__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wstring::find_first_of(p, 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__wstring__find_first_of__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::wstring::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__wstring__find_first_of__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wstring::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__wstring__find_first_of__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wstring::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__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__basic_string__rfind__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::basic_string::rfind(arg1, x, 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__basic_string__rfind__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::basic_string::rfind(arg1, arg2, x);
 }
 
-void test__std__basic_string__find_first_of__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::basic_string::find_first_of(p, 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__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__string__find_first_of__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::string::find_first_of(arg1, arg2, 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__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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::basic_string::find_first_of(arg1, arg2, 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__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__string__find_first_of__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::string::find_first_of(arg1, x, arg3);
 }
 
-void test__std__string__find_last_of__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::string::find_last_of(arg1, 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__string__find_last_of__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::string::find_last_of(p, 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__string__find_last_of__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = std::string::find_last_of(x, arg2, arg3);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::string::find_last_of(arg1, x, arg3);
+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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::string::find_last_of(arg1, arg2, x);
+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__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__find_first_of__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wstring::find_first_of(arg1, x, arg3);
 }
 
-void test__std__wstring__find_last_of__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wstring::find_last_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__wstring__find_last_of__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::wstring::find_last_of(p, 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__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__find_first_of__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::basic_string::find_first_of(arg1, 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__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::basic_string::find_first_of(NULL, arg2, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::basic_string::find_first_of(x, arg2, arg3);
 }
 
-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__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__basic_string__find_last_of__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::basic_string::find_last_of(arg1, arg2, arg3);
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = std::basic_string::find_last_of(p, 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__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__find_last_of__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::string::find_last_of(arg1, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::string::find_last_of(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = std::string::find_last_of(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::string::find_last_of(arg1, x, arg3);
 }
 
-void test__std__string__length__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::string::length();
+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__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__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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wstring::length();
+void test__std__wstring__find_last_of__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wstring::find_last_of(arg1, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = std::wstring::find_last_of(NULL, arg2, arg3);
 }
 
-void test__std__basic_string__size__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::basic_string::size();
+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__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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wstring::find_last_of(arg1, x, arg3);
 }
 
-void test__std__basic_string__length__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::basic_string::length();
+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__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__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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::string::substr(arg1, arg2);
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::string::substr(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::string::substr(arg1, x);
+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__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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::basic_string::find_last_of(arg1, x, arg3);
 }
 
-void test__std__wstring__substr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::wstring::substr(arg1, arg2);
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wstring::substr(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::wstring::substr(arg1, x);
+void test__std__string__length__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::string::length();
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::wstring::length();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__basic_string__substr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::basic_string::substr(arg1, arg2);
+void test__std__wstring__length__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wstring::length();
 }
 
-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__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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::basic_string::substr(arg1, x);
+void test__std__basic_string__size__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::basic_string::size();
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = std::basic_string::length();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__ios__clear__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::ios::clear(x);
+void test__std__basic_string__length__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::basic_string::length();
 }
 
-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__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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::fstream::clear(x);
+void test__std__string__substr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::string::substr(arg1, 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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::string::substr(x, arg2);
 }
 
-void test__std__istream__read__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::istream::read(p, arg2);
+void test__std__string__substr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::string::substr(arg1, x);
 }
 
-void test__std__istream__read__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::istream::read(arg1, x);
+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__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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::wstring::substr(arg1, arg2);
 }
 
-void test__std__ifstream__read__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::ifstream::read(p, arg2);
+void test__std__wstring__substr__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = std::wstring::substr(x, arg2);
 }
 
-void test__std__ifstream__read__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::ifstream::read(arg1, x);
+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__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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::basic_string::substr(arg1, arg2);
 }
 
-void test__std__istream__readsome__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::istream::readsome(p, arg2);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::istream::readsome(arg1, 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__ifstream__readsome__noreturn() {
-  int x = 1;
-  if (cond) { x=100; std::ifstream::readsome(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__std__ios__clear__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::ios::clear(x);
 }
 
-void test__std__ifstream__readsome__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::ifstream::readsome(p, arg2);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::ifstream::readsome(arg1, x);
+void test__std__fstream__clear__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::fstream::clear(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        std::istream::read(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__std__istream__getline__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::istream::getline(p, arg2, arg3);
+void test__std__istream__read__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::istream::read(NULL, arg2);
 }
 
-void test__std__istream__getline__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::istream::getline(arg1, x, arg3);
+void test__std__istream__read__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::istream::read(arg1, x);
 }
 
-void test__std__istream__getline__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::istream::getline(arg1, arg2, x);
+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__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__read__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::ifstream::read(arg1, x);
 }
 
-void test__std__ifstream__getline__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::ifstream::getline(p, arg2, arg3);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::ifstream::getline(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::ifstream::getline(arg1, arg2, 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__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__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::ifstream::readsome(NULL, arg2);
 }
 
-void test__std__istream__get__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::istream::get(p, arg2, arg3);
+void test__std__ifstream__readsome__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::ifstream::readsome(arg1, x);
 }
 
-void test__std__istream__get__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::istream::get(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::istream::get(arg1, arg2, x);
+void test__std__istream__getline__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::istream::getline(NULL, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::istream::getline(arg1, x, arg3);
 }
 
-void test__std__ifstream__get__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  std::ifstream::get(p, arg2, arg3);
+void test__std__istream__getline__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::istream::getline(arg1, arg2, x);
 }
 
-void test__std__ifstream__get__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::ifstream::get(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::ifstream::get(arg1, arg2, x);
+void test__std__ifstream__getline__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::ifstream::getline(NULL, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::ifstream::getline(arg1, x, arg3);
 }
 
-void test__itoa__leakignore() {
-  char *p = malloc(10); *p=0;
-  itoa(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__std__ifstream__getline__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::ifstream::getline(arg1, arg2, x);
 }
 
-void test__itoa__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  itoa(x, arg2, arg3);
+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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  itoa(arg1, p, arg3);
+void test__std__istream__get__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::istream::get(NULL, arg2, arg3);
 }
 
-void test__itoa__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  itoa(arg1, arg2, x);
+void test__std__istream__get__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::istream::get(arg1, x, arg3);
 }
 
-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__istream__get__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::istream::get(arg1, arg2, x);
 }
 
-void test__std__string__erase__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::string::erase(x, arg2);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::string::erase(arg1, x);
+void test__std__ifstream__get__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    std::ifstream::get(NULL, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::ifstream::get(arg1, x, arg3);
 }
 
-void test__std__wstring__erase__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wstring::erase(x, arg2);
+void test__std__ifstream__get__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::ifstream::get(arg1, arg2, x);
 }
 
-void test__std__wstring__erase__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wstring::erase(arg1, x);
+void test__itoa__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        itoa(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__itoa__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    itoa(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__std__basic_string__erase__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::basic_string::erase(x, arg2);
+void test__itoa__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    itoa(x, arg2, arg3);
 }
 
-void test__std__basic_string__erase__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::basic_string::erase(arg1, x);
+void test__itoa__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    itoa(arg1, NULL, arg3);
 }
 
-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__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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::string::reserve(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__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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::basic_string::erase(x, arg2);
 }
 
-void test__std__wstring__reserve__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::wstring::reserve(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__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__string__reserve__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::string::reserve(x);
 }
-
-void test__std__basic_string__reserve__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  std::basic_string::reserve(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__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__basic_string__reserve__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    std::basic_string::reserve(x);
+}
 
-void test__std__adjacent_find__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  std::adjacent_find(arg1, arg2, arg3);
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = std::adjacent_find(x, arg2, arg3);
+void test__std__adjacent_find__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::adjacent_find(arg1, 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__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__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 d7cb81b81..a30d34a16 100644
--- a/test/cfg/generated-cfg-tests-windows.cpp
+++ b/test/cfg/generated-cfg-tests-windows.cpp
@@ -8,14512 +8,18125 @@
 // => '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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = RtlCompareMemory(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = RtlCompareMemory(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  RtlCopyBytes(p, arg2, arg3);
+void test__RtlCopyBytes__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    RtlCopyBytes(NULL, arg2, arg3);
 }
 
-void test__RtlCopyBytes__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  RtlCopyBytes(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  RtlFillBytes(p, 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__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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  RtlSecureZeroMemory(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  RtlZeroBytes(p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  printf_s(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wprintf_s(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fprintf_s(arg1, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fwprintf_s(arg1, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _snprintf_s(arg1, arg2, arg3, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _snwprintf_s(arg1, arg2, arg3, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  DbgPrint(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  DbgPrintEx(arg1, arg2, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vDbgPrintEx(arg1, arg2, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vDbgPrintExWithPrefix(arg1, arg2, arg3, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  scanf_s(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wscanf_s(p);
-}
-
-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__RtlSecureZeroMemory__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    RtlSecureZeroMemory(arg1, !x);
+}
 
-void test__sscanf_s__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  sscanf_s(arg1, p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  sscanf_s(arg1, 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__fscanf_s__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fscanf_s(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fscanf_s(arg1, p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fscanf_s(arg1, 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__fwscanf_s__noreturn() {
-  int x = 1;
-  if (cond) { x=100; fwscanf_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__fwscanf_s__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  fwscanf_s(arg1, p);
+void test__fprintf_s__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fprintf_s(arg1, x);
 }
 
-void test__fwscanf_s__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  fwscanf_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__swscanf_s__noreturn() {
-  int x = 1;
-  if (cond) { x=100; swscanf_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__swscanf_s__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  swscanf_s(arg1, p);
+void test__fwprintf_s__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fwprintf_s(arg1, NULL);
 }
 
-void test__swscanf_s__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  swscanf_s(arg1, x);
+void test__fwprintf_s__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fwprintf_s(arg1, x);
 }
 
-void test__CloseHandle__noreturn() {
-  int x = 1;
-  if (cond) { x=100; CloseHandle(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CloseHandle(x);
+void test___snprintf_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _snprintf_s(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _snprintf_s(arg1, arg2, arg3, NULL);
 }
 
-void test__OpenFile__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  OpenFile(p, arg2, arg3);
+void test___snprintf_s__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _snprintf_s(arg1, arg2, arg3, x);
 }
 
-void test__OpenFile__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  OpenFile(x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenFile(arg1, arg2, x);
+void test___snwprintf_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _snwprintf_s(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _snwprintf_s(arg1, arg2, arg3, NULL);
 }
 
-void test__BuildCommDCB__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  BuildCommDCB(x, arg2);
+void test___snwprintf_s__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _snwprintf_s(arg1, arg2, arg3, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        DbgPrint(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__BuildCommDCBAndTimeouts__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  BuildCommDCBAndTimeouts(x, arg2, arg3);
+void test__DbgPrint__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    DbgPrint(p);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    DbgPrint(NULL);
 }
 
-void test__WriteFile__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  WriteFile(x, arg2, arg3, arg4, arg5);
+void test__DbgPrint__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    DbgPrint(x);
 }
 
-void test__WriteFile__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  WriteFile(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  WriteFile(arg1, arg2, x, arg4, arg5);
+void test__DbgPrintEx__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    DbgPrintEx(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    DbgPrintEx(arg1, arg2, NULL);
 }
 
-void test__ReadFile__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ReadFile(x, arg2, arg3, arg4, arg5);
+void test__DbgPrintEx__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    DbgPrintEx(arg1, arg2, x);
 }
 
-void test__ReadFile__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ReadFile(arg1, p, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ReadFile(arg1, arg2, x, arg4, arg5);
+void test__vDbgPrintEx__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    vDbgPrintEx(p, arg2, arg3);
+    // 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__vDbgPrintEx__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vDbgPrintEx(arg1, arg2, NULL);
 }
 
-void test__CreateFile__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateFile(x, arg2, arg3, arg4, arg5, arg6, arg7);
+void test__vDbgPrintEx__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    vDbgPrintEx(arg1, arg2, x);
 }
 
-void test__CreateFile__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateFile(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateFile(arg1, arg2, x, 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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateFile(arg1, arg2, arg3, x, arg5, arg6, arg7);
+void test__vDbgPrintExWithPrefix__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vDbgPrintExWithPrefix(arg1, arg2, arg3, NULL);
 }
 
-void test__CreateFile__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateFile(arg1, arg2, arg3, arg4, x, arg6, arg7);
+void test__vDbgPrintExWithPrefix__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    vDbgPrintExWithPrefix(arg1, arg2, arg3, x);
 }
 
-void test__CreateFile__arg6__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateFile(arg1, arg2, arg3, arg4, arg5, x, 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__arg7__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateFile(arg1, arg2, arg3, arg4, arg5, arg6, x);
+void test__scanf_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    scanf_s(NULL);
 }
 
-void test__SetCommTimeouts__noreturn() {
-  int x = 1;
-  if (cond) { x=100; SetCommTimeouts(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__scanf_s__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    scanf_s(x);
 }
 
-void test__SetCommTimeouts__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetCommTimeouts(x, arg2);
+void test__wscanf_s__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wscanf_s(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__SetCommTimeouts__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetCommTimeouts(arg1, x);
+void test__wscanf_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wscanf_s(NULL);
 }
 
-void test__SetCommState__noreturn() {
-  int x = 1;
-  if (cond) { x=100; SetCommState(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wscanf_s__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wscanf_s(x);
 }
 
-void test__SetCommState__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetCommState(x, arg2);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetCommState(arg1, x);
+void test__sscanf_s__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    sscanf_s(arg1, NULL);
 }
 
-void test___mbstok__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _mbstok(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((_mbstok(arg1, arg2) > 10) || (_mbstok(arg1, arg2) < 100)) {}
+void test__fscanf_s__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fscanf_s(arg1, NULL);
 }
 
-void test___mbstok__leakignore() {
-  char *p = malloc(10); *p=0;
-  _mbstok(p, arg2);
-  // cppcheck-suppress memleak
+void test__fscanf_s__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    fscanf_s(arg1, x);
 }
 
-void test___mbstok__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _mbstok(x, arg2);
+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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbstok(arg1, p);
+void test__fwscanf_s__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    fwscanf_s(arg1, NULL);
 }
 
-void test___mbstok__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _mbstok(arg1, x);
+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___tcstok__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _tcstok(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((_tcstok(arg1, arg2) > 10) || (_tcstok(arg1, arg2) < 100)) {}
+void test__CloseHandle__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CloseHandle(x);
 }
 
-void test___tcstok__leakignore() {
-  char *p = malloc(10); *p=0;
-  _tcstok(p, arg2);
-  // cppcheck-suppress memleak
-}
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _tcstok(x, arg2);
+void test__OpenFile__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    OpenFile(x, arg2, arg3);
 }
 
-void test___tcstok__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcstok(arg1, p);
+void test__OpenFile__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenFile(arg1, arg2, x);
 }
 
-void test___tcstok__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tcstok(arg1, x);
+void test__BuildCommDCB__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        BuildCommDCB(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__BuildCommDCB__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    BuildCommDCB(x, arg2);
 }
 
-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__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__leakignore() {
-  char *p = malloc(10); *p=0;
-  _mbstok_l(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _mbstok_l(x, arg2, arg3);
+void test__WriteFile__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    WriteFile(x, arg2, arg3, arg4, arg5);
 }
 
-void test___mbstok_l__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbstok_l(arg1, p, arg3);
+void test__WriteFile__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    WriteFile(arg1, x, arg3, arg4, arg5);
 }
 
-void test___mbstok_l__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _mbstok_l(arg1, x, arg3);
+void test__WriteFile__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    WriteFile(arg1, arg2, x, arg4, arg5);
 }
 
-void test___mbstok_l__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _mbstok_l(arg1, arg2, x);
+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___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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ReadFile(x, arg2, 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__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    ReadFile(arg1, NULL, arg3, 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__ReadFile__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ReadFile(arg1, arg2, x, arg4, arg5);
 }
 
-void test___strtok_s_l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _strtok_s_l(x, arg2, arg3, arg4);
+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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _strtok_s_l(arg1, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _strtok_s_l(arg1, x, 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__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _strtok_s_l(arg1, arg2, p, arg4);
+void test__CreateFile__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateFile(arg1, arg2, x, arg4, 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__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateFile(arg1, arg2, arg3, x, arg5, 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__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateFile(arg1, arg2, arg3, arg4, x, arg6, 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__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateFile(arg1, arg2, arg3, arg4, arg5, x, arg7);
 }
 
-void test___wcstok_s_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  _wcstok_s_l(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__CreateFile__arg7__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateFile(arg1, arg2, arg3, arg4, arg5, arg6, x);
 }
 
-void test___wcstok_s_l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _wcstok_s_l(x, arg2, arg3, arg4);
+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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wcstok_s_l(arg1, p, arg3, arg4);
+void test__SetCommTimeouts__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetCommTimeouts(x, arg2);
 }
 
-void test___wcstok_s_l__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wcstok_s_l(arg1, x, arg3, arg4);
+void test__SetCommTimeouts__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetCommTimeouts(arg1, x);
 }
 
-void test___wcstok_s_l__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wcstok_s_l(arg1, arg2, p, 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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _wcstok_s_l(arg1, arg2, arg3, x);
+void test__SetCommState__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetCommState(x, arg2);
 }
 
-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__SetCommState__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetCommState(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _mbstok(arg1, arg2);
+    }
+    // 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___mbstok__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((_mbstok(arg1, arg2) > 10) || (_mbstok(arg1, arg2) < 100)) {}
 }
 
-void test___mbstok_s_l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _mbstok_s_l(x, arg2, arg3, arg4);
+void test___mbstok__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _mbstok(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___mbstok_s_l__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbstok_s_l(arg1, p, arg3, arg4);
+void test___mbstok__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _mbstok(x, arg2);
 }
 
-void test___mbstok_s_l__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _mbstok_s_l(arg1, x, arg3, arg4);
+void test___mbstok__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbstok(arg1, NULL);
 }
 
-void test___mbstok_s_l__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbstok_s_l(arg1, arg2, p, arg4);
+void test___mbstok__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _mbstok(arg1, x);
 }
 
-void test___mbstok_s_l__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _mbstok_s_l(arg1, arg2, arg3, x);
+void test___tcstok__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _tcstok(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((_tcstok(arg1, arg2) > 10) || (_tcstok(arg1, arg2) < 100)) {}
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _tcstok(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___tcstok__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _tcstok(x, arg2);
 }
 
-void test___tcstok_s_l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _tcstok_s_l(x, arg2, arg3, arg4);
+void test___tcstok__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcstok(arg1, NULL);
 }
 
-void test___tcstok_s_l__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcstok_s_l(arg1, p, arg3, arg4);
+void test___tcstok__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tcstok(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _mbstok_l(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tcstok_s_l__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcstok_s_l(arg1, arg2, p, 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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _tcstok_s_l(arg1, arg2, arg3, x);
+void test___mbstok_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _mbstok_l(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _mbstok_l(x, arg2, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbstok_l(arg1, NULL, arg3);
 }
 
-void test__strtok_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  strtok_s(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test___mbstok_l__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _mbstok_l(arg1, x, arg3);
 }
 
-void test__strtok_s__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strtok_s(x, arg2, arg3);
+void test___mbstok_l__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _mbstok_l(arg1, arg2, x);
 }
 
-void test__strtok_s__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strtok_s(arg1, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strtok_s(arg1, x, 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__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strtok_s(arg1, arg2, p);
+void test___strtok_s_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _strtok_s_l(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _strtok_s_l(x, arg2, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _strtok_s_l(arg1, NULL, 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__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _strtok_s_l(arg1, x, arg3, arg4);
 }
 
-void test__wcstok_s__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wcstok_s(x, arg2, arg3);
+void test___strtok_s_l__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _strtok_s_l(arg1, arg2, NULL, arg4);
 }
 
-void test__wcstok_s__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcstok_s(arg1, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcstok_s(arg1, x, 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__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcstok_s(arg1, arg2, p);
+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___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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _wcstok_s_l(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _wcstok_s_l(x, arg2, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wcstok_s_l(arg1, NULL, arg3, arg4);
 }
 
-void test___mbstok_s__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _mbstok_s(x, arg2, arg3);
+void test___wcstok_s_l__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wcstok_s_l(arg1, x, arg3, arg4);
 }
 
-void test___mbstok_s__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbstok_s(arg1, p, arg3);
+void test___wcstok_s_l__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wcstok_s_l(arg1, arg2, NULL, arg4);
 }
 
-void test___mbstok_s__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _mbstok_s(arg1, x, arg3);
+void test___wcstok_s_l__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _wcstok_s_l(arg1, arg2, arg3, x);
 }
 
-void test___mbstok_s__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbstok_s(arg1, arg2, p);
+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___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__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__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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _mbstok_s_l(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test___tcstok_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  _tcstok_s(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test___mbstok_s_l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _mbstok_s_l(x, arg2, arg3, arg4);
 }
 
-void test___tcstok_s__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _tcstok_s(x, arg2, arg3);
+void test___mbstok_s_l__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbstok_s_l(arg1, NULL, arg3, arg4);
 }
 
-void test___tcstok_s__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcstok_s(arg1, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tcstok_s(arg1, x, arg3);
+void test___mbstok_s_l__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbstok_s_l(arg1, arg2, NULL, arg4);
 }
 
-void test___tcstok_s__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcstok_s(arg1, arg2, p);
+void test___mbstok_s_l__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _mbstok_s_l(arg1, arg2, arg3, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _tcstok_s_l(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___getcwd__leakignore() {
-  char *p = malloc(10); *p=0;
-  _getcwd(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___getcwd__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _getcwd(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___getcwd__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _getcwd(arg1, x);
+void test___tcstok_s_l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _tcstok_s_l(x, arg2, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcstok_s_l(arg1, NULL, arg3, arg4);
 }
 
-void test___wgetcwd__leakignore() {
-  char *p = malloc(10); *p=0;
-  _wgetcwd(p, arg2);
-  // cppcheck-suppress memleak
+void test___tcstok_s_l__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tcstok_s_l(arg1, x, arg3, arg4);
 }
 
-void test___wgetcwd__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _wgetcwd(x, arg2);
+void test___tcstok_s_l__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcstok_s_l(arg1, arg2, NULL, arg4);
 }
 
-void test___wgetcwd__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _wgetcwd(arg1, x);
+void test___tcstok_s_l__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _tcstok_s_l(arg1, arg2, arg3, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        strtok_s(arg1, arg2, arg3);
+    }
+    // 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__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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SHGetFolderPath(x, arg2, arg3, arg4, arg5);
+void test__strtok_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strtok_s(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__SHGetFolderPath__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SHGetFolderPath(arg1, x, arg3, arg4, arg5);
+void test__strtok_s__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    strtok_s(x, arg2, arg3);
 }
 
-void test__SHGetFolderPath__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SHGetFolderPath(arg1, arg2, x, arg4, arg5);
+void test__strtok_s__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strtok_s(arg1, NULL, arg3);
 }
 
-void test__SHGetFolderPath__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SHGetFolderPath(arg1, arg2, arg3, x, arg5);
+void test__strtok_s__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strtok_s(arg1, x, arg3);
 }
 
-void test__SHGetFolderPath__arg5__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SHGetFolderPath(arg1, arg2, arg3, arg4, p);
+void test__strtok_s__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strtok_s(arg1, arg2, NULL);
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wcstok_s(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__SHGetFolderPathA__leakignore() {
-  char *p = malloc(10); *p=0;
-  SHGetFolderPathA(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SHGetFolderPathA(x, arg2, arg3, arg4, arg5);
+void test__wcstok_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcstok_s(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__SHGetFolderPathA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SHGetFolderPathA(arg1, x, arg3, arg4, arg5);
+void test__wcstok_s__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wcstok_s(x, arg2, arg3);
 }
 
-void test__SHGetFolderPathA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SHGetFolderPathA(arg1, arg2, x, arg4, arg5);
+void test__wcstok_s__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcstok_s(arg1, NULL, arg3);
 }
 
-void test__SHGetFolderPathA__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SHGetFolderPathA(arg1, arg2, arg3, x, arg5);
+void test__wcstok_s__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcstok_s(arg1, x, arg3);
 }
 
-void test__SHGetFolderPathA__arg5__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SHGetFolderPathA(arg1, arg2, arg3, arg4, p);
+void test__wcstok_s__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcstok_s(arg1, arg2, NULL);
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _mbstok_s(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__SHGetFolderPathW__leakignore() {
-  char *p = malloc(10); *p=0;
-  SHGetFolderPathW(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SHGetFolderPathW(x, arg2, arg3, arg4, arg5);
+void test___mbstok_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _mbstok_s(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__SHGetFolderPathW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SHGetFolderPathW(arg1, x, arg3, arg4, arg5);
+void test___mbstok_s__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _mbstok_s(x, arg2, arg3);
 }
 
-void test__SHGetFolderPathW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SHGetFolderPathW(arg1, arg2, x, arg4, arg5);
+void test___mbstok_s__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbstok_s(arg1, NULL, arg3);
 }
 
-void test__SHGetFolderPathW__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SHGetFolderPathW(arg1, arg2, arg3, x, arg5);
+void test___mbstok_s__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _mbstok_s(arg1, x, arg3);
 }
 
-void test__SHGetFolderPathW__arg5__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SHGetFolderPathW(arg1, arg2, arg3, arg4, p);
+void test___mbstok_s__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbstok_s(arg1, arg2, NULL);
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _tcstok_s(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__RegQueryValueEx__leakignore() {
-  char *p = malloc(10); *p=0;
-  RegQueryValueEx(p, arg2, arg3, arg4, arg5, arg6);
-  // 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__RegQueryValueEx__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegQueryValueEx(x, arg2, arg3, arg4, arg5, arg6);
+void test___tcstok_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _tcstok_s(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__RegQueryValueEx__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegQueryValueEx(arg1, arg2, x, arg4, arg5, arg6);
+void test___tcstok_s__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _tcstok_s(x, arg2, arg3);
 }
 
-void test__RegQueryValueEx__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegQueryValueEx(arg1, arg2, arg3, x, arg5, arg6);
+void test___tcstok_s__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcstok_s(arg1, NULL, 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__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tcstok_s(arg1, x, arg3);
 }
 
-void test__RegQueryValueExA__leakignore() {
-  char *p = malloc(10); *p=0;
-  RegQueryValueExA(p, arg2, arg3, arg4, arg5, arg6);
-  // cppcheck-suppress memleak
+void test___tcstok_s__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcstok_s(arg1, arg2, NULL);
 }
 
-void test__RegQueryValueExA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegQueryValueExA(x, arg2, arg3, arg4, arg5, arg6);
+void test___getcwd__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _getcwd(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__RegQueryValueExA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegQueryValueExA(arg1, arg2, x, arg4, arg5, arg6);
+void test___getcwd__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _getcwd(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__RegQueryValueExA__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegQueryValueExA(arg1, arg2, arg3, x, arg5, arg6);
+void test___getcwd__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _getcwd(x, arg2);
 }
 
-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___getcwd__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _getcwd(arg1, x);
 }
 
-void test__RegQueryValueExW__leakignore() {
-  char *p = malloc(10); *p=0;
-  RegQueryValueExW(p, arg2, arg3, arg4, arg5, arg6);
-  // cppcheck-suppress memleak
+void test___wgetcwd__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _wgetcwd(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__RegQueryValueExW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegQueryValueExW(x, arg2, arg3, arg4, arg5, arg6);
+void test___wgetcwd__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _wgetcwd(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__RegQueryValueExW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegQueryValueExW(arg1, arg2, x, arg4, arg5, arg6);
+void test___wgetcwd__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _wgetcwd(x, arg2);
 }
 
-void test__RegQueryValueExW__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegQueryValueExW(arg1, arg2, arg3, x, arg5, arg6);
+void test___wgetcwd__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _wgetcwd(arg1, x);
 }
 
-void test__RegCloseKey__noreturn() {
-  int x = 1;
-  if (cond) { x=100; RegCloseKey(arg1); }
-  // 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__RegCloseKey__leakignore() {
-  char *p = malloc(10); *p=0;
-  RegCloseKey(p);
-  // cppcheck-suppress memleak
+void test__SHGetFolderPath__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    SHGetFolderPath(p, arg2, arg3, arg4, arg5);
+    // cppcheck-suppress memleak
 }
 
-void test__RegCloseKey__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegCloseKey(x);
+void test__SHGetFolderPath__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SHGetFolderPath(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SHGetFolderPath(arg1, x, arg3, arg4, arg5);
 }
 
-void test___stricmp_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  _stricmp_l(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__SHGetFolderPath__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SHGetFolderPath(arg1, arg2, x, arg4, arg5);
 }
 
-void test___stricmp_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stricmp_l(p, arg2, arg3);
+void test__SHGetFolderPath__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SHGetFolderPath(arg1, arg2, arg3, x, arg5);
 }
 
-void test___stricmp_l__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _stricmp_l(x, arg2, arg3);
+void test__SHGetFolderPath__arg5__notnull()
+{
+    // cppcheck-suppress nullPointer
+    SHGetFolderPath(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test___stricmp_l__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stricmp_l(arg1, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _stricmp_l(arg1, x, arg3);
+void test__SHGetFolderPathA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    SHGetFolderPathA(p, arg2, arg3, arg4, arg5);
+    // cppcheck-suppress memleak
 }
 
-void test___stricmp_l__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _stricmp_l(arg1, arg2, x);
+void test__SHGetFolderPathA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SHGetFolderPathA(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SHGetFolderPathA(arg1, x, arg3, arg4, arg5);
 }
 
-void test___wcsicmp_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  _wcsicmp_l(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__SHGetFolderPathA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SHGetFolderPathA(arg1, arg2, x, arg4, arg5);
 }
 
-void test___wcsicmp_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wcsicmp_l(p, arg2, arg3);
+void test__SHGetFolderPathA__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SHGetFolderPathA(arg1, arg2, arg3, x, arg5);
 }
 
-void test___wcsicmp_l__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wcsicmp_l(x, arg2, arg3);
+void test__SHGetFolderPathA__arg5__notnull()
+{
+    // cppcheck-suppress nullPointer
+    SHGetFolderPathA(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test___wcsicmp_l__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wcsicmp_l(arg1, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wcsicmp_l(arg1, x, arg3);
+void test__SHGetFolderPathW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    SHGetFolderPathW(p, arg2, arg3, arg4, arg5);
+    // cppcheck-suppress memleak
 }
 
-void test___wcsicmp_l__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _wcsicmp_l(arg1, arg2, x);
+void test__SHGetFolderPathW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SHGetFolderPathW(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SHGetFolderPathW(arg1, x, arg3, arg4, arg5);
 }
 
-void test___mbsicmp_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  _mbsicmp_l(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__SHGetFolderPathW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SHGetFolderPathW(arg1, arg2, x, arg4, arg5);
 }
 
-void test___mbsicmp_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbsicmp_l(p, arg2, arg3);
+void test__SHGetFolderPathW__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SHGetFolderPathW(arg1, arg2, arg3, x, arg5);
 }
 
-void test___mbsicmp_l__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _mbsicmp_l(x, arg2, arg3);
+void test__SHGetFolderPathW__arg5__notnull()
+{
+    // cppcheck-suppress nullPointer
+    SHGetFolderPathW(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test___mbsicmp_l__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbsicmp_l(arg1, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _mbsicmp_l(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _mbsicmp_l(arg1, arg2, x);
+void test__RegQueryValueEx__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegQueryValueEx(x, arg2, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegQueryValueEx(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__stricmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  stricmp(p, arg2);
-  // cppcheck-suppress memleak
+void test__RegQueryValueEx__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegQueryValueEx(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__stricmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  stricmp(p, arg2);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  stricmp(x, arg2);
+void test__RegQueryValueExA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    RegQueryValueExA(p, arg2, arg3, arg4, arg5, arg6);
+    // cppcheck-suppress memleak
 }
 
-void test__stricmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  stricmp(arg1, p);
+void test__RegQueryValueExA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegQueryValueExA(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__stricmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  stricmp(arg1, x);
+void test__RegQueryValueExA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegQueryValueExA(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__RegQueryValueExA__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegQueryValueExA(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test___stricmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  _stricmp(p, arg2);
-  // cppcheck-suppress memleak
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stricmp(p, arg2);
+void test__RegQueryValueExW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    RegQueryValueExW(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__RegQueryValueExW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegQueryValueExW(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test___stricmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stricmp(arg1, p);
+void test__RegQueryValueExW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegQueryValueExW(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test___stricmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _stricmp(arg1, x);
+void test__RegQueryValueExW__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegQueryValueExW(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__wcsicmp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wcsicmp(arg1, arg2); }
-  // 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__wcsicmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  wcsicmp(p, arg2);
-  // cppcheck-suppress memleak
+void test__RegCloseKey__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    RegCloseKey(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wcsicmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcsicmp(p, arg2);
+void test__RegCloseKey__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegCloseKey(x);
 }
 
-void test__wcsicmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcsicmp(x, 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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcsicmp(arg1, p);
+void test___stricmp_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _stricmp_l(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__wcsicmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcsicmp(arg1, x);
+void test___stricmp_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stricmp_l(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _stricmp_l(x, arg2, arg3);
 }
 
-void test___wcsicmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  _wcsicmp(p, arg2);
-  // cppcheck-suppress memleak
+void test___stricmp_l__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stricmp_l(arg1, NULL, arg3);
 }
 
-void test___wcsicmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wcsicmp(p, arg2);
+void test___stricmp_l__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _stricmp_l(arg1, x, arg3);
 }
 
-void test___wcsicmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wcsicmp(x, arg2);
+void test___stricmp_l__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _stricmp_l(arg1, arg2, x);
 }
 
-void test___wcsicmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wcsicmp(arg1, p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wcsicmp(arg1, x);
+void test___wcsicmp_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _wcsicmp_l(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wcsicmp_l(NULL, arg2, arg3);
 }
 
-void test___mbsicmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  _mbsicmp(p, arg2);
-  // cppcheck-suppress memleak
+void test___wcsicmp_l__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wcsicmp_l(x, arg2, arg3);
 }
 
-void test___mbsicmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbsicmp(p, arg2);
+void test___wcsicmp_l__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wcsicmp_l(arg1, NULL, arg3);
 }
 
-void test___mbsicmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _mbsicmp(x, arg2);
+void test___wcsicmp_l__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wcsicmp_l(arg1, x, arg3);
 }
 
-void test___mbsicmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbsicmp(arg1, p);
+void test___wcsicmp_l__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _wcsicmp_l(arg1, arg2, x);
 }
 
-void test___mbsicmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _mbsicmp(arg1, x);
+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___tcsicmp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _tcsicmp(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___mbsicmp_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _mbsicmp_l(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___tcsicmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  _tcsicmp(p, arg2);
-  // cppcheck-suppress memleak
+void test___mbsicmp_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbsicmp_l(NULL, arg2, arg3);
 }
 
-void test___tcsicmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcsicmp(p, arg2);
+void test___mbsicmp_l__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _mbsicmp_l(x, arg2, arg3);
 }
 
-void test___tcsicmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tcsicmp(x, arg2);
+void test___mbsicmp_l__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbsicmp_l(arg1, NULL, arg3);
 }
 
-void test___tcsicmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcsicmp(arg1, p);
+void test___mbsicmp_l__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _mbsicmp_l(arg1, x, arg3);
 }
 
-void test___tcsicmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tcsicmp(arg1, x);
+void test___mbsicmp_l__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _mbsicmp_l(arg1, arg2, x);
 }
 
-void test__GetFileAttributes__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GetFileAttributes(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__stricmp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        stricmp(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__GetFileAttributes__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetFileAttributes(p);
-  // cppcheck-suppress memleak
+void test__stricmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    stricmp(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__GetFileAttributes__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetFileAttributes(x);
+void test__stricmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    stricmp(NULL, arg2);
 }
 
-void test__GetFileAttributesA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GetFileAttributesA(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__stricmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    stricmp(x, arg2);
 }
 
-void test__GetFileAttributesA__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetFileAttributesA(p);
-  // cppcheck-suppress memleak
+void test__stricmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    stricmp(arg1, NULL);
 }
 
-void test__GetFileAttributesA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetFileAttributesA(x);
+void test__stricmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    stricmp(arg1, x);
 }
 
-void test__GetFileAttributesW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GetFileAttributesW(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___stricmp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _stricmp(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__GetFileAttributesW__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetFileAttributesW(p);
-  // cppcheck-suppress memleak
+void test___stricmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _stricmp(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__GetFileAttributesW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetFileAttributesW(x);
+void test___stricmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stricmp(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _stricmp(x, arg2);
 }
 
-void test__RegOpenKeyEx__leakignore() {
-  char *p = malloc(10); *p=0;
-  RegOpenKeyEx(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
+void test___stricmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stricmp(arg1, NULL);
 }
 
-void test__RegOpenKeyEx__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegOpenKeyEx(x, arg2, arg3, arg4, arg5);
+void test___stricmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _stricmp(arg1, x);
 }
 
-void test__RegOpenKeyEx__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegOpenKeyEx(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__RegOpenKeyEx__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegOpenKeyEx(arg1, arg2, arg3, x, arg5);
+void test__wcsicmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcsicmp(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcsicmp(NULL, arg2);
 }
 
-void test__RegOpenKeyExA__leakignore() {
-  char *p = malloc(10); *p=0;
-  RegOpenKeyExA(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
+void test__wcsicmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcsicmp(x, arg2);
 }
 
-void test__RegOpenKeyExA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegOpenKeyExA(x, arg2, arg3, arg4, arg5);
+void test__wcsicmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcsicmp(arg1, NULL);
 }
 
-void test__RegOpenKeyExA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegOpenKeyExA(arg1, arg2, x, arg4, arg5);
+void test__wcsicmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcsicmp(arg1, x);
 }
 
-void test__RegOpenKeyExA__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegOpenKeyExA(arg1, arg2, arg3, x, arg5);
+void test___wcsicmp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _wcsicmp(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _wcsicmp(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__RegOpenKeyExW__leakignore() {
-  char *p = malloc(10); *p=0;
-  RegOpenKeyExW(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
+void test___wcsicmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wcsicmp(NULL, arg2);
 }
 
-void test__RegOpenKeyExW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegOpenKeyExW(x, arg2, arg3, arg4, arg5);
+void test___wcsicmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wcsicmp(x, arg2);
 }
 
-void test__RegOpenKeyExW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegOpenKeyExW(arg1, arg2, x, arg4, arg5);
+void test___wcsicmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wcsicmp(arg1, NULL);
 }
 
-void test__RegOpenKeyExW__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegOpenKeyExW(arg1, arg2, arg3, x, arg5);
+void test___wcsicmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wcsicmp(arg1, x);
 }
 
-void test__wsprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wsprintf(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___mbsicmp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _mbsicmp(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wsprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  wsprintf(p, arg2);
-  // cppcheck-suppress memleak
+void test___mbsicmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _mbsicmp(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__wsprintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wsprintf(x, arg2);
+void test___mbsicmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbsicmp(NULL, arg2);
 }
 
-void test__wsprintf__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wsprintf(arg1, p);
+void test___mbsicmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _mbsicmp(x, arg2);
 }
 
-void test__wsprintf__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wsprintf(arg1, x);
+void test___mbsicmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbsicmp(arg1, NULL);
 }
 
-void test__wsprintfA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wsprintfA(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___mbsicmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _mbsicmp(arg1, x);
 }
 
-void test__wsprintfA__leakignore() {
-  char *p = malloc(10); *p=0;
-  wsprintfA(p, arg2);
-  // 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__wsprintfA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wsprintfA(x, arg2);
+void test___tcsicmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _tcsicmp(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__wsprintfA__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wsprintfA(arg1, p);
+void test___tcsicmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcsicmp(NULL, arg2);
 }
 
-void test__wsprintfA__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wsprintfA(arg1, x);
+void test___tcsicmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tcsicmp(x, arg2);
 }
 
-void test__wsprintfW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wsprintfW(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___tcsicmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcsicmp(arg1, NULL);
 }
 
-void test__wsprintfW__leakignore() {
-  char *p = malloc(10); *p=0;
-  wsprintfW(p, arg2);
-  // cppcheck-suppress memleak
+void test___tcsicmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tcsicmp(arg1, x);
 }
 
-void test__wsprintfW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wsprintfW(x, arg2);
+void test__GetFileAttributes__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        GetFileAttributes(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wsprintfW__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wsprintfW(arg1, p);
+void test__GetFileAttributes__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetFileAttributes(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wsprintfW__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wsprintfW(arg1, x);
+void test__GetFileAttributes__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetFileAttributes(x);
 }
 
-void test__sprintf_s__noreturn() {
-  int x = 1;
-  if (cond) { x=100; sprintf_s(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
-}
+void test__GetFileAttributesA__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        GetFileAttributesA(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
+}
 
-void test__sprintf_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  sprintf_s();
-  // cppcheck-suppress memleak
+void test__GetFileAttributesA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetFileAttributesA(p);
+    // cppcheck-suppress memleak
 }
 
-void test__swprintf_s__noreturn() {
-  int x = 1;
-  if (cond) { x=100; swprintf_s(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetFileAttributesA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetFileAttributesA(x);
 }
 
-void test__swprintf_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  swprintf_s();
-  // cppcheck-suppress memleak
+void test__GetFileAttributesW__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        GetFileAttributesW(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetFileAttributesW(p);
+    // cppcheck-suppress memleak
 }
 
-void test___sprintf_s_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  _sprintf_s_l(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__GetFileAttributesW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetFileAttributesW(x);
 }
 
-void test___sprintf_s_l__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _sprintf_s_l(arg1, x, arg3, arg4);
+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__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _sprintf_s_l(arg1, arg2, p, arg4);
+
+void test__RegOpenKeyEx__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegOpenKeyEx(arg1, arg2, arg3, x, arg5);
 }
 
-void test___sprintf_s_l__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _sprintf_s_l(arg1, arg2, x, 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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _sprintf_s_l(arg1, arg2, arg3, x);
+void test__RegOpenKeyExA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegOpenKeyExA(x, arg2, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegOpenKeyExA(arg1, arg2, x, arg4, 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__RegOpenKeyExA__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegOpenKeyExA(arg1, arg2, arg3, x, arg5);
 }
 
-void test___swprintf_s_l__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _swprintf_s_l(arg1, x, arg3, arg4);
+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__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _swprintf_s_l(arg1, arg2, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _swprintf_s_l(arg1, arg2, x, arg4);
+void test__RegOpenKeyExW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegOpenKeyExW(x, arg2, arg3, arg4, arg5);
 }
 
-void test___swprintf_s_l__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _swprintf_s_l(arg1, arg2, arg3, x);
+void test__RegOpenKeyExW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegOpenKeyExW(arg1, arg2, x, arg4, 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__RegOpenKeyExW__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegOpenKeyExW(arg1, arg2, arg3, x, arg5);
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wsprintf(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__RegEnumKeyEx__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegEnumKeyEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+void test__wsprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wsprintf(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__RegEnumKeyEx__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegEnumKeyEx(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
+void test__wsprintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wsprintf(x, arg2);
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wsprintf(arg1, NULL);
 }
 
-void test__RegEnumKeyExA__leakignore() {
-  char *p = malloc(10); *p=0;
-  RegEnumKeyExA(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-  // cppcheck-suppress memleak
+void test__wsprintf__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wsprintf(arg1, x);
 }
 
-void test__RegEnumKeyExA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegEnumKeyExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+void test__wsprintfA__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wsprintfA(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__RegEnumKeyExA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegEnumKeyExA(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
+void test__wsprintfA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wsprintfA(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wsprintfA(x, arg2);
+}
+
+void test__wsprintfA__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wsprintfA(arg1, NULL);
 }
-
-void test__RegEnumKeyExW__leakignore() {
-  char *p = malloc(10); *p=0;
-  RegEnumKeyExW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-  // cppcheck-suppress memleak
+
+void test__wsprintfA__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wsprintfA(arg1, x);
 }
 
-void test__RegEnumKeyExW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RegEnumKeyExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+void test__wsprintfW__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wsprintfW(arg1, arg2);
+    }
+    // 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__wsprintfW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wsprintfW(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__CreateFont__noreturn() {
-  int x = 1;
-  if (cond) { x=100; CreateFont(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wsprintfW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wsprintfW(x, arg2);
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wsprintfW(arg1, NULL);
 }
 
-void test__CaptureStackBackTrace__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CaptureStackBackTrace(x, arg2, arg3, arg4);
+void test__wsprintfW__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wsprintfW(arg1, x);
 }
 
-void test__CaptureStackBackTrace__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CaptureStackBackTrace(arg1, x, arg3, arg4);
+void test__sprintf_s__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        sprintf_s();
+    }
+    // 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__sprintf_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    sprintf_s();
+    // cppcheck-suppress memleak
 }
 
-void test___vsnprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  _vsnprintf(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__swprintf_s__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        swprintf_s();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___vsnprintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnprintf(x, arg2, arg3, arg4);
+void test__swprintf_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    swprintf_s();
+    // cppcheck-suppress memleak
 }
 
-void test___vsnprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnprintf(arg1, x, 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__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _vsnprintf(arg1, arg2, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _vsnprintf(arg1, arg2, x, arg4);
+void test___sprintf_s_l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _sprintf_s_l(arg1, x, arg3, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _sprintf_s_l(arg1, arg2, NULL, arg4);
 }
 
-void test___vsnwprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  _vsnwprintf(p, arg2, arg3, arg4);
-  // 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___vsnwprintf__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnwprintf(x, arg2, arg3, arg4);
+void test___sprintf_s_l__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _sprintf_s_l(arg1, arg2, arg3, x);
 }
 
-void test___vsnwprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnwprintf(arg1, x, 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__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _vsnwprintf(arg1, arg2, p, arg4);
+void test___swprintf_s_l__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _swprintf_s_l(arg1, arg2, NULL, arg4);
 }
 
-void test___vsnwprintf__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _vsnwprintf(arg1, arg2, x, arg4);
+void test___swprintf_s_l__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _swprintf_s_l(arg1, arg2, x, arg4);
 }
 
-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___swprintf_s_l__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _swprintf_s_l(arg1, arg2, arg3, 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__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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnprintf_l(x, arg2, arg3, arg4, arg5);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnprintf_l(arg1, x, 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__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _vsnprintf_l(arg1, arg2, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _vsnprintf_l(arg1, arg2, x, 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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnprintf_l(arg1, arg2, arg3, x, 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___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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    RegEnumKeyExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+}
 
-void test___vsnwprintf_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  _vsnwprintf_l(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnwprintf_l(x, arg2, arg3, arg4, arg5);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnwprintf_l(arg1, x, arg3, arg4, arg5);
+void test__CaptureStackBackTrace__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CaptureStackBackTrace(x, arg2, arg3, arg4);
 }
 
-void test___vsnwprintf_l__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _vsnwprintf_l(arg1, arg2, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _vsnwprintf_l(arg1, arg2, x, arg4, arg5);
+void test___vsnprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _vsnprintf(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test___vsnwprintf_l__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnwprintf_l(arg1, arg2, arg3, x, arg5);
+void test___vsnprintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnprintf(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnprintf(arg1, x, arg3, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _vsnprintf(arg1, arg2, NULL, arg4);
 }
 
-void test___vswprintf_l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vswprintf_l(x, arg2, arg3, arg4, arg5);
+void test___vsnprintf__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _vsnprintf(arg1, arg2, x, arg4);
 }
 
-void test___vswprintf_l__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vswprintf_l(arg1, x, 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__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _vswprintf_l(arg1, arg2, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _vswprintf_l(arg1, arg2, x, arg4, arg5);
+void test___vsnwprintf__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnwprintf(x, arg2, arg3, arg4);
 }
 
-void test___vswprintf_l__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vswprintf_l(arg1, arg2, arg3, x, arg5);
+void test___vsnwprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnwprintf(arg1, x, arg3, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _vsnwprintf(arg1, arg2, NULL, arg4);
 }
 
-void test__vsnprintf_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  vsnprintf_s(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
+void test___vsnwprintf__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _vsnwprintf(arg1, arg2, x, arg4);
 }
 
-void test__vsnprintf_s__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  vsnprintf_s(x, arg2, arg3, arg4, arg5);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  vsnprintf_s(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  vsnprintf_s(arg1, arg2, x, arg4, arg5);
+void test___vsnprintf_l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnprintf_l(x, arg2, arg3, arg4, arg5);
 }
 
-void test__vsnprintf_s__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  vsnprintf_s(arg1, arg2, arg3, p, arg5);
+void test___vsnprintf_l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnprintf_l(arg1, x, arg3, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _vsnprintf_l(arg1, arg2, NULL, 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__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _vsnprintf_l(arg1, arg2, x, arg4, arg5);
 }
 
-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__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnprintf_l(arg1, arg2, arg3, x, arg5);
 }
 
-void test___vsnprintf_s__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnprintf_s(x, arg2, arg3, arg4, arg5);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnprintf_s(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnprintf_s(arg1, arg2, x, arg4, arg5);
+void test___vsnwprintf_l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnwprintf_l(x, arg2, arg3, arg4, arg5);
 }
 
-void test___vsnprintf_s__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _vsnprintf_s(arg1, arg2, arg3, p, arg5);
+void test___vsnwprintf_l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnwprintf_l(arg1, x, arg3, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _vsnwprintf_l(arg1, arg2, NULL, 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__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _vsnwprintf_l(arg1, arg2, x, arg4, arg5);
 }
 
-void test___vsnwprintf_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  _vsnwprintf_s(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
+void test___vsnwprintf_l__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnwprintf_l(arg1, arg2, arg3, x, arg5);
 }
 
-void test___vsnwprintf_s__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnwprintf_s(x, arg2, arg3, arg4, arg5);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnwprintf_s(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnwprintf_s(arg1, arg2, x, arg4, arg5);
+void test___vswprintf_l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vswprintf_l(x, arg2, arg3, arg4, arg5);
 }
 
-void test___vsnwprintf_s__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _vsnwprintf_s(arg1, arg2, arg3, p, arg5);
+void test___vswprintf_l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vswprintf_l(arg1, x, arg3, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _vswprintf_l(arg1, arg2, NULL, 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__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _vswprintf_l(arg1, arg2, x, arg4, 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___vswprintf_l__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vswprintf_l(arg1, arg2, arg3, x, arg5);
 }
 
-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__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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnprintf_s_l(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnprintf_s_l(arg1, arg2, x, 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__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _vsnprintf_s_l(arg1, arg2, arg3, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _vsnprintf_s_l(arg1, arg2, arg3, x, 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__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnprintf_s_l(arg1, arg2, arg3, arg4, x, arg6);
+void test__vsnprintf_s__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    vsnprintf_s(arg1, arg2, arg3, NULL, 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__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    vsnprintf_s(arg1, arg2, arg3, x, arg5);
 }
 
-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__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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnwprintf_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___vsnwprintf_s_l__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnwprintf_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___vsnwprintf_s_l__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnwprintf_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___vsnwprintf_s_l__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _vsnwprintf_s_l(arg1, arg2, arg3, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _vsnwprintf_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___vsnwprintf_s_l__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsnwprintf_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___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__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__leakignore() {
-  char *p = malloc(10); *p=0;
-  _vsprintf_l(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _vsprintf_l(p, arg2, arg3, arg4);
+void test___vsnwprintf_s__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnwprintf_s(x, arg2, arg3, arg4, arg5);
 }
 
-void test___vsprintf_l__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _vsprintf_l(arg1, p, arg3, arg4);
+void test___vsnwprintf_s__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnwprintf_s(arg1, x, arg3, arg4, arg5);
 }
 
-void test___vsprintf_l__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _vsprintf_l(arg1, arg2, x, arg4);
+void test___vsnwprintf_s__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnwprintf_s(arg1, arg2, x, arg4, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _vsnwprintf_s(arg1, arg2, arg3, NULL, arg5);
 }
 
-void test____vswprintf_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  __vswprintf_l(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test___vsnwprintf_s__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _vsnwprintf_s(arg1, arg2, arg3, x, arg5);
 }
 
-void test____vswprintf_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  __vswprintf_l(p, arg2, arg3, arg4);
+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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  __vswprintf_l(arg1, p, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  __vswprintf_l(arg1, arg2, x, arg4);
+void test___vsnprintf_s_l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnprintf_s_l(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnprintf_s_l(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test___strdup__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _strdup(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _strdup(x);
+void test___vsnprintf_s_l__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _vsnprintf_s_l(arg1, arg2, arg3, NULL, 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__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _vsnprintf_s_l(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test___wcsdup__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wcsdup(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wcsdup(x);
+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___mbsdup__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _mbsdup(arg1); }
-  // 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___mbsdup__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbsdup(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _mbsdup(x);
+void test___vsnwprintf_s_l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnwprintf_s_l(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnwprintf_s_l(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test___tcsdup__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcsdup(p);
+void test___vsnwprintf_s_l__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _vsnwprintf_s_l(arg1, arg2, arg3, NULL, arg5, arg6);
 }
 
-void test___tcsdup__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tcsdup(x);
+void test___vsnwprintf_s_l__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _vsnwprintf_s_l(arg1, arg2, arg3, x, arg5, 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___vsnwprintf_s_l__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsnwprintf_s_l(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test___strdup_dbg__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _strdup_dbg(p, arg2, arg3, arg4);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _strdup_dbg(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _strdup_dbg(arg1, x, arg3, arg4);
+void test___vsprintf_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _vsprintf_l(NULL, arg2, arg3, arg4);
 }
 
-void test___strdup_dbg__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _strdup_dbg(arg1, arg2, x, arg4);
+void test___vsprintf_l__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _vsprintf_l(arg1, NULL, arg3, arg4);
 }
 
-void test___strdup_dbg__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _strdup_dbg(arg1, arg2, arg3, x);
+void test___vsprintf_l__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _vsprintf_l(arg1, arg2, x, arg4);
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        __vswprintf_l(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___wcsdup_dbg__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wcsdup_dbg(p, arg2, arg3, arg4);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wcsdup_dbg(x, arg2, arg3, arg4);
+void test____vswprintf_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    __vswprintf_l(NULL, arg2, arg3, arg4);
 }
 
-void test___wcsdup_dbg__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _wcsdup_dbg(arg1, x, arg3, arg4);
+void test____vswprintf_l__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    __vswprintf_l(arg1, NULL, arg3, arg4);
 }
 
-void test___wcsdup_dbg__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _wcsdup_dbg(arg1, arg2, x, arg4);
+void test____vswprintf_l__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    __vswprintf_l(arg1, arg2, x, arg4);
 }
 
-void test___wcsdup_dbg__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _wcsdup_dbg(arg1, arg2, arg3, x);
+void test___strdup__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _strdup(arg1);
+    }
+    // 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___strdup__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _strdup(NULL);
 }
 
-void test___tcsdup_dbg__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcsdup_dbg(p, arg2, arg3, arg4);
+void test___strdup__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _strdup(x);
 }
 
-void test___tcsdup_dbg__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tcsdup_dbg(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _tcsdup_dbg(arg1, x, arg3, arg4);
+void test___wcsdup__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wcsdup(NULL);
 }
 
-void test___tcsdup_dbg__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _tcsdup_dbg(arg1, arg2, x, arg4);
+void test___wcsdup__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wcsdup(x);
 }
 
-void test___tcsdup_dbg__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _tcsdup_dbg(arg1, arg2, arg3, x);
+void test___mbsdup__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _mbsdup(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbsdup(NULL);
 }
 
-void test___mbscmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mbscmp(arg1, arg2);
+void test___mbsdup__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _mbsdup(x);
 }
 
-void test___mbscmp__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((_mbscmp(arg1, arg2) > 10) || (_mbscmp(arg1, arg2) < 100)) {}
+void test___tcsdup__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _tcsdup(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___mbscmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _mbscmp(p, arg2);
-  // cppcheck-suppress memleak
+void test___tcsdup__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcsdup(NULL);
 }
 
-void test___mbscmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbscmp(p, arg2);
+void test___tcsdup__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tcsdup(x);
 }
 
-void test___mbscmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbscmp(x, 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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbscmp(arg1, p);
+void test___strdup_dbg__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _strdup_dbg(NULL, arg2, arg3, arg4);
 }
 
-void test___mbscmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbscmp(arg1, x);
+void test___strdup_dbg__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _strdup_dbg(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _strdup_dbg(arg1, x, arg3, arg4);
 }
 
-void test___tcscmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _tcscmp(arg1, arg2);
+void test___strdup_dbg__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _strdup_dbg(arg1, arg2, x, arg4);
 }
 
-void test___tcscmp__pure(int arg1,int arg2) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((_tcscmp(arg1, arg2) > 10) || (_tcscmp(arg1, arg2) < 100)) {}
+void test___strdup_dbg__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _strdup_dbg(arg1, arg2, arg3, x);
 }
 
-void test___tcscmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _tcscmp(p, arg2);
-  // cppcheck-suppress memleak
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tcscmp(p, arg2);
+void test___wcsdup_dbg__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wcsdup_dbg(NULL, arg2, arg3, arg4);
 }
 
-void test___tcscmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tcscmp(x, arg2);
+void test___wcsdup_dbg__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wcsdup_dbg(x, arg2, arg3, arg4);
 }
 
-void test___tcscmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tcscmp(arg1, p);
+void test___wcsdup_dbg__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _wcsdup_dbg(arg1, x, arg3, arg4);
 }
 
-void test___tcscmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tcscmp(arg1, x);
+void test___wcsdup_dbg__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _wcsdup_dbg(arg1, arg2, x, arg4);
 }
 
-void test___snprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _snprintf(arg1, arg2, arg3); }
-  // 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___snprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  _snprintf(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _snprintf(arg1, x, arg3);
+void test___tcsdup_dbg__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcsdup_dbg(NULL, arg2, arg3, arg4);
 }
 
-void test___snprintf__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _snprintf(arg1, arg2, p);
+void test___tcsdup_dbg__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tcsdup_dbg(x, arg2, arg3, arg4);
 }
 
-void test___snprintf__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _snprintf(arg1, arg2, x);
+void test___tcsdup_dbg__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _tcsdup_dbg(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _tcsdup_dbg(arg1, arg2, x, arg4);
 }
 
-void test___snwprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  _snwprintf(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test___tcsdup_dbg__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _tcsdup_dbg(arg1, arg2, arg3, x);
 }
 
-void test___snwprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _snwprintf(arg1, x, arg3);
+void test___mbscmp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _mbscmp(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___snwprintf__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _snwprintf(arg1, arg2, p);
+void test___mbscmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mbscmp(arg1, arg2);
 }
 
-void test___snwprintf__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _snwprintf(arg1, arg2, x);
+void test___mbscmp__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((_mbscmp(arg1, arg2) > 10) || (_mbscmp(arg1, arg2) < 100)) {}
 }
 
-void test___sntprintf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _sntprintf(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___mbscmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mbscmp(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___sntprintf__leakignore() {
-  char *p = malloc(10); *p=0;
-  _sntprintf(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test___mbscmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbscmp(NULL, arg2);
 }
 
-void test___sntprintf__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _sntprintf(arg1, x, arg3);
+void test___mbscmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbscmp(x, arg2);
 }
 
-void test___sntprintf__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _sntprintf(arg1, arg2, p);
+void test___mbscmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbscmp(arg1, NULL);
 }
 
-void test___sntprintf__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _sntprintf(arg1, arg2, x);
+void test___mbscmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbscmp(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _tcscmp(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__strcpy_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  strcpy_s(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test___tcscmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _tcscmp(arg1, arg2);
 }
 
-void test__strcpy_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strcpy_s(p, arg2, arg3);
+void test___tcscmp__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((_tcscmp(arg1, arg2) > 10) || (_tcscmp(arg1, arg2) < 100)) {}
 }
 
-void test__strcpy_s__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  strcpy_s(arg1, x, arg3);
+void test___tcscmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _tcscmp(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__strcpy_s__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strcpy_s(arg1, arg2, p);
+void test___tcscmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tcscmp(NULL, arg2);
 }
 
-void test__strcpy_s__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strcpy_s(arg1, arg2, x);
+void test___tcscmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tcscmp(x, arg2);
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tcscmp(arg1, NULL);
 }
 
-void test__wcscpy_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  wcscpy_s(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test___tcscmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tcscmp(arg1, x);
 }
 
-void test__wcscpy_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcscpy_s(p, arg2, arg3);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wcscpy_s(arg1, x, arg3);
+void test___snprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _snprintf(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__wcscpy_s__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wcscpy_s(arg1, arg2, p);
+void test___snprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _snprintf(arg1, x, arg3);
 }
 
-void test__wcscpy_s__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wcscpy_s(arg1, arg2, x);
+void test___snprintf__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _snprintf(arg1, arg2, NULL);
 }
 
-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___snprintf__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _snprintf(arg1, arg2, x);
 }
 
-void test___mbscpy_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  _mbscpy_s(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbscpy_s(p, arg2, arg3);
+void test___snwprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _snwprintf(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___mbscpy_s__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _mbscpy_s(arg1, x, arg3);
+void test___snwprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _snwprintf(arg1, x, arg3);
 }
 
-void test___mbscpy_s__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbscpy_s(arg1, arg2, p);
+void test___snwprintf__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _snwprintf(arg1, arg2, NULL);
 }
 
-void test___mbscpy_s__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _mbscpy_s(arg1, arg2, x);
+void test___snwprintf__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _snwprintf(arg1, arg2, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _sntprintf(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tcscpy_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  _tcscpy_s(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test___sntprintf__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _sntprintf(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___tcscpy_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcscpy_s(p, arg2, arg3);
+void test___sntprintf__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _sntprintf(arg1, x, arg3);
 }
 
-void test___tcscpy_s__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _tcscpy_s(arg1, x, arg3);
+void test___sntprintf__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _sntprintf(arg1, arg2, NULL);
 }
 
-void test___tcscpy_s__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcscpy_s(arg1, arg2, p);
+void test___sntprintf__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _sntprintf(arg1, arg2, x);
 }
 
-void test___tcscpy_s__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tcscpy_s(arg1, arg2, 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___CrtSetDbgFlag__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _CrtSetDbgFlag(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__strcpy_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    strcpy_s(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___CrtSetDbgFlag__leakignore() {
-  char *p = malloc(10); *p=0;
-  _CrtSetDbgFlag(p);
-  // cppcheck-suppress memleak
+void test__strcpy_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strcpy_s(NULL, arg2, arg3);
 }
 
-void test___CrtSetDbgFlag__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _CrtSetDbgFlag(x);
+void test__strcpy_s__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    strcpy_s(arg1, x, arg3);
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    strcpy_s(arg1, arg2, NULL);
 }
 
-void test___stat__leakignore() {
-  char *p = malloc(10); *p=0;
-  _stat(p, arg2);
-  // cppcheck-suppress memleak
+void test__strcpy_s__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    strcpy_s(arg1, arg2, x);
 }
 
-void test___stat__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stat(p, arg2);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _stat(x, arg2);
+void test__wcscpy_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wcscpy_s(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___stat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stat(arg1, p);
+void test__wcscpy_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcscpy_s(NULL, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wcscpy_s(arg1, x, arg3);
 }
 
-void test___tstat__leakignore() {
-  char *p = malloc(10); *p=0;
-  _tstat(p, arg2);
-  // cppcheck-suppress memleak
+void test__wcscpy_s__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wcscpy_s(arg1, arg2, NULL);
 }
 
-void test___tstat__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tstat(p, arg2);
+void test__wcscpy_s__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wcscpy_s(arg1, arg2, x);
 }
 
-void test___tstat__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tstat(x, 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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tstat(arg1, p);
+void test___mbscpy_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _mbscpy_s(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___stat32__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _stat32(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___mbscpy_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbscpy_s(NULL, arg2, arg3);
 }
 
-void test___stat32__leakignore() {
-  char *p = malloc(10); *p=0;
-  _stat32(p, arg2);
-  // cppcheck-suppress memleak
+void test___mbscpy_s__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _mbscpy_s(arg1, x, arg3);
 }
 
-void test___stat32__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stat32(p, arg2);
+void test___mbscpy_s__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbscpy_s(arg1, arg2, NULL);
 }
 
-void test___stat32__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _stat32(x, arg2);
+void test___mbscpy_s__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _mbscpy_s(arg1, arg2, x);
 }
 
-void test___stat32__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stat32(arg1, p);
+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___stat64__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _stat64(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___tcscpy_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _tcscpy_s(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___stat64__leakignore() {
-  char *p = malloc(10); *p=0;
-  _stat64(p, arg2);
-  // cppcheck-suppress memleak
+void test___tcscpy_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcscpy_s(NULL, arg2, arg3);
 }
 
-void test___stat64__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stat64(p, arg2);
+void test___tcscpy_s__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _tcscpy_s(arg1, x, arg3);
 }
 
-void test___stat64__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _stat64(x, arg2);
+void test___tcscpy_s__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcscpy_s(arg1, arg2, NULL);
 }
 
-void test___stat64__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stat64(arg1, p);
+void test___tcscpy_s__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tcscpy_s(arg1, arg2, x);
 }
 
-void test___tstat64__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _tstat64(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___CrtSetDbgFlag__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _CrtSetDbgFlag(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tstat64__leakignore() {
-  char *p = malloc(10); *p=0;
-  _tstat64(p, arg2);
-  // cppcheck-suppress memleak
+void test___CrtSetDbgFlag__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _CrtSetDbgFlag(p);
+    // cppcheck-suppress memleak
 }
 
-void test___tstat64__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tstat64(p, arg2);
+void test___CrtSetDbgFlag__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _CrtSetDbgFlag(x);
 }
 
-void test___tstat64__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tstat64(x, arg2);
+void test___stat__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _stat(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tstat64__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tstat64(arg1, p);
+void test___stat__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _stat(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___stati64__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _stati64(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___stat__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stat(NULL, arg2);
 }
 
-void test___stati64__leakignore() {
-  char *p = malloc(10); *p=0;
-  _stati64(p, arg2);
-  // cppcheck-suppress memleak
+void test___stat__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _stat(x, arg2);
 }
 
-void test___stati64__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stati64(p, arg2);
+void test___stat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stat(arg1, NULL);
 }
 
-void test___stati64__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _stati64(x, arg2);
+void test___tstat__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _tstat(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___stati64__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stati64(arg1, p);
+void test___tstat__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _tstat(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___tstati64__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _tstati64(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___tstat__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tstat(NULL, arg2);
 }
 
-void test___tstati64__leakignore() {
-  char *p = malloc(10); *p=0;
-  _tstati64(p, arg2);
-  // cppcheck-suppress memleak
+void test___tstat__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tstat(x, arg2);
 }
 
-void test___tstati64__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tstati64(p, arg2);
+void test___tstat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tstat(arg1, NULL);
 }
 
-void test___tstati64__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tstati64(x, arg2);
+void test___stat32__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _stat32(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tstati64__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tstati64(arg1, p);
+void test___stat32__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _stat32(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___stat32i64__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _stat32i64(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___stat32__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stat32(NULL, arg2);
 }
 
-void test___stat32i64__leakignore() {
-  char *p = malloc(10); *p=0;
-  _stat32i64(p, arg2);
-  // cppcheck-suppress memleak
+void test___stat32__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _stat32(x, arg2);
 }
 
-void test___stat32i64__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stat32i64(p, arg2);
+void test___stat32__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stat32(arg1, NULL);
 }
 
-void test___stat32i64__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _stat32i64(x, arg2);
+void test___stat64__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _stat64(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___stat32i64__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stat32i64(arg1, p);
+void test___stat64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _stat64(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___tstat32i64__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _tstat32i64(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___stat64__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stat64(NULL, arg2);
 }
 
-void test___tstat32i64__leakignore() {
-  char *p = malloc(10); *p=0;
-  _tstat32i64(p, arg2);
-  // cppcheck-suppress memleak
+void test___stat64__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _stat64(x, arg2);
 }
 
-void test___tstat32i64__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tstat32i64(p, arg2);
+void test___stat64__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stat64(arg1, NULL);
 }
 
-void test___tstat32i64__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tstat32i64(x, arg2);
+void test___tstat64__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _tstat64(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tstat32i64__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tstat32i64(arg1, p);
+void test___tstat64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _tstat64(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___stat64i32__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _stat64i32(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___tstat64__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tstat64(NULL, arg2);
 }
 
-void test___stat64i32__leakignore() {
-  char *p = malloc(10); *p=0;
-  _stat64i32(p, arg2);
-  // cppcheck-suppress memleak
+void test___tstat64__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tstat64(x, arg2);
 }
 
-void test___stat64i32__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stat64i32(p, arg2);
+void test___tstat64__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tstat64(arg1, NULL);
 }
 
-void test___stat64i32__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _stat64i32(x, arg2);
+void test___stati64__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _stati64(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___stat64i32__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _stat64i32(arg1, p);
+void test___stati64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _stati64(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___tstat64i32__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _tstat64i32(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___stati64__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stati64(NULL, arg2);
 }
 
-void test___tstat64i32__leakignore() {
-  char *p = malloc(10); *p=0;
-  _tstat64i32(p, arg2);
-  // cppcheck-suppress memleak
+void test___stati64__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _stati64(x, arg2);
 }
 
-void test___tstat64i32__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tstat64i32(p, arg2);
+void test___stati64__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stati64(arg1, NULL);
 }
 
-void test___tstat64i32__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tstat64i32(x, arg2);
+void test___tstati64__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _tstati64(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tstat64i32__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tstat64i32(arg1, p);
+void test___tstati64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _tstati64(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___wstat__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _wstat(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___tstati64__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tstati64(NULL, arg2);
 }
 
-void test___wstat__leakignore() {
-  char *p = malloc(10); *p=0;
-  _wstat(p, arg2);
-  // cppcheck-suppress memleak
+void test___tstati64__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tstati64(x, arg2);
 }
 
-void test___wstat__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wstat(p, arg2);
+void test___tstati64__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tstati64(arg1, NULL);
 }
 
-void test___wstat__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wstat(x, arg2);
+void test___stat32i64__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _stat32i64(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___wstat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wstat(arg1, p);
+void test___stat32i64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _stat32i64(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___wstat32__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _wstat32(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___stat32i64__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stat32i64(NULL, arg2);
 }
 
-void test___wstat32__leakignore() {
-  char *p = malloc(10); *p=0;
-  _wstat32(p, arg2);
-  // cppcheck-suppress memleak
+void test___stat32i64__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _stat32i64(x, arg2);
 }
 
-void test___wstat32__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wstat32(p, arg2);
+void test___stat32i64__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stat32i64(arg1, NULL);
 }
 
-void test___wstat32__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wstat32(x, arg2);
+void test___tstat32i64__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _tstat32i64(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___wstat32__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wstat32(arg1, p);
+void test___tstat32i64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _tstat32i64(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___wstat64__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _wstat64(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___tstat32i64__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tstat32i64(NULL, arg2);
 }
 
-void test___wstat64__leakignore() {
-  char *p = malloc(10); *p=0;
-  _wstat64(p, arg2);
-  // cppcheck-suppress memleak
+void test___tstat32i64__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tstat32i64(x, arg2);
 }
 
-void test___wstat64__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wstat64(p, arg2);
+void test___tstat32i64__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tstat32i64(arg1, NULL);
 }
 
-void test___wstat64__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wstat64(x, arg2);
+void test___stat64i32__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _stat64i32(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___wstat64__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wstat64(arg1, p);
+void test___stat64i32__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _stat64i32(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___wstati64__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _wstati64(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___stat64i32__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stat64i32(NULL, arg2);
 }
 
-void test___wstati64__leakignore() {
-  char *p = malloc(10); *p=0;
-  _wstati64(p, arg2);
-  // cppcheck-suppress memleak
+void test___stat64i32__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _stat64i32(x, arg2);
 }
 
-void test___wstati64__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wstati64(p, arg2);
+void test___stat64i32__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _stat64i32(arg1, NULL);
 }
 
-void test___wstati64__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wstati64(x, arg2);
+void test___tstat64i32__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _tstat64i32(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___wstati64__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wstati64(arg1, p);
+void test___tstat64i32__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _tstat64i32(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___wstat32i64__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _wstat32i64(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___tstat64i32__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tstat64i32(NULL, arg2);
 }
 
-void test___wstat32i64__leakignore() {
-  char *p = malloc(10); *p=0;
-  _wstat32i64(p, arg2);
-  // cppcheck-suppress memleak
+void test___tstat64i32__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tstat64i32(x, arg2);
 }
 
-void test___wstat32i64__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wstat32i64(p, arg2);
+void test___tstat64i32__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tstat64i32(arg1, NULL);
 }
 
-void test___wstat32i64__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wstat32i64(x, arg2);
+void test___wstat__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _wstat(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___wstat32i64__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wstat32i64(arg1, p);
+void test___wstat__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _wstat(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___wstat__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wstat(NULL, arg2);
 }
 
-void test___wstat64i32__leakignore() {
-  char *p = malloc(10); *p=0;
-  _wstat64i32(p, arg2);
-  // cppcheck-suppress memleak
+void test___wstat__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wstat(x, arg2);
 }
 
-void test___wstat64i32__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wstat64i32(p, arg2);
+void test___wstat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wstat(arg1, NULL);
 }
 
-void test___wstat64i32__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wstat64i32(x, arg2);
+void test___wstat32__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _wstat32(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___wstat64i32__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wstat64i32(arg1, p);
+void test___wstat32__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _wstat32(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___fstat__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _fstat(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___wstat32__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wstat32(NULL, arg2);
 }
 
-void test___fstat__leakignore() {
-  char *p = malloc(10); *p=0;
-  _fstat(p, arg2);
-  // cppcheck-suppress memleak
+void test___wstat32__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wstat32(x, arg2);
 }
 
-void test___fstat__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _fstat(x, arg2);
+void test___wstat32__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wstat32(arg1, NULL);
 }
 
-void test___fstat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _fstat(arg1, p);
+void test___wstat64__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _wstat64(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___fstat32__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _fstat32(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___wstat64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _wstat64(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___fstat32__leakignore() {
-  char *p = malloc(10); *p=0;
-  _fstat32(p, arg2);
-  // cppcheck-suppress memleak
+void test___wstat64__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wstat64(NULL, arg2);
 }
 
-void test___fstat32__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _fstat32(x, arg2);
+void test___wstat64__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wstat64(x, arg2);
 }
 
-void test___fstat32__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _fstat32(arg1, p);
+void test___wstat64__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wstat64(arg1, NULL);
 }
 
-void test___fstat64__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _fstat64(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___wstati64__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _wstati64(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___fstat64__leakignore() {
-  char *p = malloc(10); *p=0;
-  _fstat64(p, arg2);
-  // cppcheck-suppress memleak
+void test___wstati64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _wstati64(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___fstat64__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _fstat64(x, arg2);
+void test___wstati64__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wstati64(NULL, arg2);
 }
 
-void test___fstat64__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _fstat64(arg1, p);
+void test___wstati64__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wstati64(x, arg2);
 }
 
-void test___fstati64__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _fstati64(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___wstati64__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wstati64(arg1, NULL);
 }
 
-void test___fstati64__leakignore() {
-  char *p = malloc(10); *p=0;
-  _fstati64(p, arg2);
-  // cppcheck-suppress memleak
+void test___wstat32i64__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _wstat32i64(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___fstati64__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _fstati64(x, arg2);
+void test___wstat32i64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _wstat32i64(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___fstati64__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _fstati64(arg1, p);
+void test___wstat32i64__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wstat32i64(NULL, arg2);
 }
 
-void test___fstat32i64__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _fstat32i64(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___wstat32i64__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wstat32i64(x, arg2);
 }
 
-void test___fstat32i64__leakignore() {
-  char *p = malloc(10); *p=0;
-  _fstat32i64(p, arg2);
-  // cppcheck-suppress memleak
+void test___wstat32i64__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wstat32i64(arg1, NULL);
 }
 
-void test___fstat32i64__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _fstat32i64(x, arg2);
+void test___wstat64i32__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _wstat64i32(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___fstat32i64__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _fstat32i64(arg1, p);
+void test___wstat64i32__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _wstat64i32(p, arg2);
+    // 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___wstat64i32__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wstat64i32(NULL, arg2);
 }
 
-void test___fstat64i32__leakignore() {
-  char *p = malloc(10); *p=0;
-  _fstat64i32(p, arg2);
-  // cppcheck-suppress memleak
+void test___wstat64i32__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wstat64i32(x, arg2);
 }
 
-void test___fstat64i32__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _fstat64i32(x, arg2);
+void test___wstat64i32__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wstat64i32(arg1, NULL);
 }
 
-void test___fstat64i32__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _fstat64i32(arg1, p);
+void test___fstat__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _fstat(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___fseeki64__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _fseeki64(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___fseeki64__leakignore() {
-  char *p = malloc(10); *p=0;
-  _fseeki64(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test___fstat__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _fstat(x, arg2);
 }
 
-void test___fseeki64__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _fseeki64(p, arg2, arg3);
+void test___fstat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _fstat(arg1, NULL);
 }
 
-void test___fseeki64__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _fseeki64(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _fseeki64(arg1, x, arg3);
+void test___fstat32__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _fstat32(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___fseeki64__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _fseeki64(arg1, arg2, x);
+void test___fstat32__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _fstat32(x, arg2);
 }
 
-void test___ftelli64__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = _ftelli64(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___fstat32__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _fstat32(arg1, NULL);
 }
 
-void test___ftelli64__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _ftelli64(arg1);
+void test___fstat64__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _fstat64(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___ftelli64__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _ftelli64(p);
-  // cppcheck-suppress memleak
+void test___fstat64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _fstat64(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___ftelli64__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _ftelli64(p);
+void test___fstat64__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _fstat64(x, arg2);
 }
 
-void test___ftelli64__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _ftelli64(x);
+void test___fstat64__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _fstat64(arg1, NULL);
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _fstati64(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___ftell_nolock__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _ftell_nolock(arg1);
+void test___fstati64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _fstati64(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___fstati64__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _fstati64(x, arg2);
 }
 
-void test___ftell_nolock__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _ftell_nolock(p);
+void test___fstati64__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _fstati64(arg1, NULL);
 }
 
-void test___ftell_nolock__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _ftell_nolock(x);
+void test___fstat32i64__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _fstat32i64(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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___fstat32i64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _fstat32i64(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___ftelli64_nolock__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _ftelli64_nolock(arg1);
+void test___fstat32i64__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _fstat32i64(x, arg2);
 }
 
-void test___ftelli64_nolock__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _ftelli64_nolock(p);
-  // cppcheck-suppress memleak
+void test___fstat32i64__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _fstat32i64(arg1, NULL);
 }
 
-void test___ftelli64_nolock__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _ftelli64_nolock(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _ftelli64_nolock(x);
+void test___fstat64i32__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _fstat64i32(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___wfopen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = _wfopen(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___fstat64i32__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _fstat64i32(x, arg2);
 }
 
-void test___wfopen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _wfopen(arg1, arg2);
+void test___fstat64i32__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _fstat64i32(arg1, NULL);
 }
 
-void test___wfopen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _wfopen(p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _wfopen(x, arg2);
+void test___fseeki64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _fseeki64(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___wfopen__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _wfopen(arg1, p);
+void test___fseeki64__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _fseeki64(NULL, arg2, arg3);
 }
 
-void test___wfopen__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _wfopen(arg1, x);
+void test___fseeki64__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _fseeki64(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _fseeki64(arg1, x, arg3);
 }
 
-void test___tfopen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _tfopen(arg1, arg2);
+void test___fseeki64__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _fseeki64(arg1, arg2, x);
 }
 
-void test___tfopen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tfopen(p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tfopen(x, arg2);
+void test___ftelli64__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _ftelli64(arg1);
 }
 
-void test___tfopen__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tfopen(arg1, p);
+void test___ftelli64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _ftelli64(p);
+    // cppcheck-suppress memleak
 }
 
-void test___tfopen__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tfopen(arg1, x);
+void test___ftelli64__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _ftelli64(NULL);
 }
 
-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___ftelli64__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _ftelli64(x);
 }
 
-void test__strnlen_s__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  strnlen_s(arg1, arg2);
+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__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = strnlen_s(p, arg2);
-  // cppcheck-suppress memleak
+void test___ftell_nolock__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _ftell_nolock(arg1);
 }
 
-void test__strnlen_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = strnlen_s(p, arg2);
+void test___ftell_nolock__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _ftell_nolock(p);
+    // cppcheck-suppress memleak
 }
 
-void test__strnlen_s__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = strnlen_s(x, arg2);
+void test___ftell_nolock__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _ftell_nolock(NULL);
 }
 
-void test__strnlen_s__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = strnlen_s(arg1, x);
+void test___ftell_nolock__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _ftell_nolock(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _ftelli64_nolock(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wcsnlen_s__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wcsnlen_s(arg1, arg2);
+void test___ftelli64_nolock__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _ftelli64_nolock(arg1);
 }
 
-void test__wcsnlen_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wcsnlen_s(p, arg2);
-  // cppcheck-suppress memleak
+void test___ftelli64_nolock__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _ftelli64_nolock(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wcsnlen_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = wcsnlen_s(p, arg2);
+void test___ftelli64_nolock__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _ftelli64_nolock(NULL);
 }
 
-void test__wcsnlen_s__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = wcsnlen_s(x, arg2);
+void test___ftelli64_nolock__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _ftelli64_nolock(x);
 }
 
-void test__wcsnlen_s__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wcsnlen_s(arg1, x);
+void test___wfopen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _wfopen(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___mbsnlen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = _mbsnlen(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___wfopen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _wfopen(arg1, arg2);
 }
 
-void test___mbsnlen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mbsnlen(arg1, arg2);
+void test___wfopen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _wfopen(NULL, arg2);
 }
 
-void test___mbsnlen__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _mbsnlen(p, arg2);
-  // cppcheck-suppress memleak
+void test___wfopen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _wfopen(x, arg2);
 }
 
-void test___mbsnlen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbsnlen(p, arg2);
+void test___wfopen__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _wfopen(arg1, NULL);
 }
 
-void test___mbsnlen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbsnlen(x, arg2);
+void test___wfopen__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _wfopen(arg1, x);
 }
 
-void test___mbsnlen__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _mbsnlen(arg1, x);
+void test___tfopen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _tfopen(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___mbstrnlen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = _mbstrnlen(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___tfopen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _tfopen(arg1, arg2);
 }
 
-void test___mbstrnlen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mbstrnlen(arg1, arg2);
+void test___tfopen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tfopen(NULL, arg2);
 }
 
-void test___mbstrnlen__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _mbstrnlen(p, arg2);
-  // cppcheck-suppress memleak
+void test___tfopen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tfopen(x, arg2);
 }
 
-void test___mbstrnlen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbstrnlen(p, arg2);
+void test___tfopen__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tfopen(arg1, NULL);
 }
 
-void test___mbstrnlen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbstrnlen(x, arg2);
+void test___tfopen__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tfopen(arg1, x);
 }
 
-void test___mbstrnlen__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _mbstrnlen(arg1, 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___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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    strnlen_s(arg1, arg2);
 }
 
-void test___mbsnlen_l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mbsnlen_l(arg1, arg2, arg3);
+void test__strnlen_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = strnlen_s(p, arg2);
+    // 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__strnlen_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = strnlen_s(NULL, arg2);
 }
 
-void test___mbsnlen_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbsnlen_l(p, arg2, arg3);
+void test__strnlen_s__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = strnlen_s(x, arg2);
 }
 
-void test___mbsnlen_l__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbsnlen_l(x, arg2, arg3);
+void test__strnlen_s__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = strnlen_s(arg1, x);
 }
 
-void test___mbsnlen_l__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _mbsnlen_l(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _mbsnlen_l(arg1, arg2, x);
+void test__wcsnlen_s__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wcsnlen_s(arg1, arg2);
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wcsnlen_s(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___mbstrnlen_l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mbstrnlen_l(arg1, arg2, arg3);
+void test__wcsnlen_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = wcsnlen_s(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = wcsnlen_s(x, arg2);
 }
 
-void test___mbstrnlen_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbstrnlen_l(p, arg2, arg3);
+void test__wcsnlen_s__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = wcsnlen_s(arg1, x);
 }
 
-void test___mbstrnlen_l__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbstrnlen_l(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _mbstrnlen_l(arg1, x, arg3);
+void test___mbsnlen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mbsnlen(arg1, arg2);
 }
 
-void test___mbstrnlen_l__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _mbstrnlen_l(arg1, arg2, x);
+void test___mbsnlen__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mbsnlen(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbsnlen(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbsnlen(x, arg2);
 }
 
-void test__WideCharToMultiByte__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  WideCharToMultiByte(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+void test___mbsnlen__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _mbsnlen(arg1, x);
 }
 
-void test__WideCharToMultiByte__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  WideCharToMultiByte(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  WideCharToMultiByte(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8);
+void test___mbstrnlen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mbstrnlen(arg1, arg2);
 }
 
-void test__WideCharToMultiByte__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  WideCharToMultiByte(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8);
+void test___mbstrnlen__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mbstrnlen(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__WideCharToMultiByte__arg6__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8);
+void test___mbstrnlen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbstrnlen(NULL, arg2);
 }
 
-void test__WideCharToMultiByte__arg7__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8);
+void test___mbstrnlen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbstrnlen(x, arg2);
 }
 
-void test__PathIsDirectory__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = PathIsDirectory(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___mbstrnlen__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _mbstrnlen(arg1, x);
 }
 
-void test__PathIsDirectory__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  PathIsDirectory(arg1);
+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__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = PathIsDirectory(p);
-  // cppcheck-suppress memleak
+void test___mbsnlen_l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mbsnlen_l(arg1, arg2, arg3);
 }
 
-void test__PathIsDirectory__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = PathIsDirectory(x);
+void test___mbsnlen_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mbsnlen_l(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbsnlen_l(NULL, arg2, arg3);
 }
 
-void test__PathIsDirectoryA__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  PathIsDirectoryA(arg1);
+void test___mbsnlen_l__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbsnlen_l(x, arg2, arg3);
 }
 
-void test__PathIsDirectoryA__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = PathIsDirectoryA(p);
-  // cppcheck-suppress memleak
+void test___mbsnlen_l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _mbsnlen_l(arg1, x, arg3);
 }
 
-void test__PathIsDirectoryA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = PathIsDirectoryA(x);
+void test___mbsnlen_l__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _mbsnlen_l(arg1, arg2, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _mbstrnlen_l(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__PathIsDirectoryW__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  PathIsDirectoryW(arg1);
+void test___mbstrnlen_l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mbstrnlen_l(arg1, arg2, arg3);
 }
 
-void test__PathIsDirectoryW__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = PathIsDirectoryW(p);
-  // cppcheck-suppress memleak
+void test___mbstrnlen_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mbstrnlen_l(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__PathIsDirectoryW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = PathIsDirectoryW(x);
+void test___mbstrnlen_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbstrnlen_l(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbstrnlen_l(x, arg2, arg3);
 }
 
-void test__SetConsoleTextAttribute__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetConsoleTextAttribute(p, arg2);
-  // cppcheck-suppress memleak
+void test___mbstrnlen_l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _mbstrnlen_l(arg1, x, arg3);
 }
 
-void test__SetConsoleTextAttribute__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetConsoleTextAttribute(x, arg2);
+void test___mbstrnlen_l__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _mbstrnlen_l(arg1, arg2, x);
 }
 
-void test__SetConsoleTextAttribute__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetConsoleTextAttribute(arg1, x);
+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___wfopen_s__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _wfopen_s(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wfopen_s(p, arg2, arg3);
+void test__WideCharToMultiByte__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    WideCharToMultiByte(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
 }
 
-void test___wfopen_s__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wfopen_s(arg1, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wfopen_s(arg1, x, arg3);
+void test__WideCharToMultiByte__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    WideCharToMultiByte(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8);
 }
 
-void test___wfopen_s__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wfopen_s(arg1, arg2, p);
+void test__WideCharToMultiByte__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    WideCharToMultiByte(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8);
 }
 
-void test___wfopen_s__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wfopen_s(arg1, arg2, x);
+void test__WideCharToMultiByte__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, x, arg7, 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__WideCharToMultiByte__arg7__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8);
 }
 
-void test___tfopen_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tfopen_s(p, arg2, arg3);
+void test__PathIsDirectory__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = PathIsDirectory(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tfopen_s__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tfopen_s(arg1, p, arg3);
+void test__PathIsDirectory__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    PathIsDirectory(arg1);
 }
 
-void test___tfopen_s__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tfopen_s(arg1, x, arg3);
+void test__PathIsDirectory__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = PathIsDirectory(p);
+    // cppcheck-suppress memleak
 }
 
-void test___tfopen_s__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tfopen_s(arg1, arg2, p);
+void test__PathIsDirectory__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = PathIsDirectory(x);
 }
 
-void test___tfopen_s__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tfopen_s(arg1, arg2, x);
+void test__PathIsDirectoryA__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = PathIsDirectoryA(arg1);
+    }
+    // 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__PathIsDirectoryA__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    PathIsDirectoryA(arg1);
 }
 
-void test__DeleteFile__leakignore() {
-  char *p = malloc(10); *p=0;
-  DeleteFile(p);
-  // cppcheck-suppress memleak
+void test__PathIsDirectoryA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = PathIsDirectoryA(p);
+    // cppcheck-suppress memleak
 }
 
-void test__DeleteFile__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  DeleteFile(x);
+void test__PathIsDirectoryA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = PathIsDirectoryA(x);
 }
 
-void test__DeleteFileA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; DeleteFileA(arg1); }
-  // 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__DeleteFileA__leakignore() {
-  char *p = malloc(10); *p=0;
-  DeleteFileA(p);
-  // cppcheck-suppress memleak
+void test__PathIsDirectoryW__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    PathIsDirectoryW(arg1);
 }
 
-void test__DeleteFileA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  DeleteFileA(x);
+void test__PathIsDirectoryW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = PathIsDirectoryW(p);
+    // cppcheck-suppress memleak
 }
 
-void test__DeleteFileW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; DeleteFileW(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__PathIsDirectoryW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = PathIsDirectoryW(x);
 }
 
-void test__DeleteFileW__leakignore() {
-  char *p = malloc(10); *p=0;
-  DeleteFileW(p);
-  // cppcheck-suppress memleak
+void test__SetConsoleTextAttribute__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        SetConsoleTextAttribute(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__DeleteFileW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  DeleteFileW(x);
+void test__SetConsoleTextAttribute__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    SetConsoleTextAttribute(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__GetStdHandle__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = GetStdHandle(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__SetConsoleTextAttribute__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetConsoleTextAttribute(x, arg2);
 }
 
-void test__GetStdHandle__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  GetStdHandle(arg1);
+void test__SetConsoleTextAttribute__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetConsoleTextAttribute(arg1, x);
 }
 
-void test__GetStdHandle__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = GetStdHandle(p);
-  // 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__GetStdHandle__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = GetStdHandle(x);
+void test___wfopen_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wfopen_s(NULL, arg2, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wfopen_s(arg1, NULL, arg3);
 }
 
-void test__SetStdHandle__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetStdHandle(p, arg2);
-  // cppcheck-suppress memleak
+void test___wfopen_s__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wfopen_s(arg1, x, arg3);
 }
 
-void test__SetStdHandle__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetStdHandle(x, arg2);
+void test___wfopen_s__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wfopen_s(arg1, arg2, NULL);
 }
 
-void test__SetStdHandle__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetStdHandle(arg1, x);
+void test___wfopen_s__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wfopen_s(arg1, arg2, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _tfopen_s(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___access__leakignore() {
-  char *p = malloc(10); *p=0;
-  _access(p, arg2);
-  // cppcheck-suppress memleak
+void test___tfopen_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tfopen_s(NULL, arg2, arg3);
 }
 
-void test___access__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _access(p, arg2);
+void test___tfopen_s__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tfopen_s(arg1, NULL, arg3);
 }
 
-void test___access__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _access(x, arg2);
+void test___tfopen_s__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tfopen_s(arg1, x, arg3);
 }
 
-void test___access__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _access(arg1, x);
+void test___tfopen_s__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tfopen_s(arg1, arg2, NULL);
 }
 
-void test___waccess__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _waccess(arg1, arg2); }
-  // 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___waccess__leakignore() {
-  char *p = malloc(10); *p=0;
-  _waccess(p, arg2);
-  // cppcheck-suppress memleak
+void test__DeleteFile__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        DeleteFile(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___waccess__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _waccess(p, arg2);
+void test__DeleteFile__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    DeleteFile(p);
+    // cppcheck-suppress memleak
 }
 
-void test___waccess__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _waccess(x, arg2);
+void test__DeleteFile__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    DeleteFile(x);
 }
 
-void test___waccess__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _waccess(arg1, x);
+void test__DeleteFileA__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        DeleteFileA(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___taccess__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _taccess(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__DeleteFileA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    DeleteFileA(p);
+    // cppcheck-suppress memleak
 }
 
-void test___taccess__leakignore() {
-  char *p = malloc(10); *p=0;
-  _taccess(p, arg2);
-  // cppcheck-suppress memleak
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _taccess(p, arg2);
+void test__DeleteFileW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    DeleteFileW(p);
+    // cppcheck-suppress memleak
 }
 
-void test___taccess__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _taccess(x, arg2);
+void test__DeleteFileW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    DeleteFileW(x);
 }
 
-void test___taccess__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _taccess(arg1, x);
+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__PeekMessage__noreturn() {
-  int x = 1;
-  if (cond) { x=100; PeekMessage(arg1, arg2, arg3, arg4, arg5); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
-}
+void test__SetStdHandle__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        SetStdHandle(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
+}
 
-void test__PeekMessage__leakignore() {
-  char *p = malloc(10); *p=0;
-  PeekMessage(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  PeekMessage(p, arg2, arg3, arg4, arg5);
+void test__SetStdHandle__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetStdHandle(arg1, x);
 }
 
-void test__PeekMessage__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PeekMessage(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PeekMessage(arg1, arg2, x, arg4, arg5);
+void test___access__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _access(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__PeekMessage__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PeekMessage(arg1, arg2, arg3, x, arg5);
+void test___access__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _access(NULL, arg2);
 }
 
-void test__PeekMessage__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PeekMessage(arg1, arg2, arg3, arg4, x);
+void test___access__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _access(x, arg2);
 }
 
-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___access__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _access(arg1, x);
 }
 
-void test__PeekMessageA__leakignore() {
-  char *p = malloc(10); *p=0;
-  PeekMessageA(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
+void test___waccess__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _waccess(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__PeekMessageA__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  PeekMessageA(p, arg2, arg3, arg4, arg5);
+void test___waccess__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _waccess(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__PeekMessageA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PeekMessageA(arg1, x, arg3, arg4, arg5);
+void test___waccess__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _waccess(NULL, arg2);
 }
 
-void test__PeekMessageA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PeekMessageA(arg1, arg2, x, arg4, arg5);
+void test___waccess__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _waccess(x, arg2);
 }
 
-void test__PeekMessageA__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PeekMessageA(arg1, arg2, arg3, x, arg5);
+void test___waccess__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _waccess(arg1, x);
 }
 
-void test__PeekMessageA__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PeekMessageA(arg1, arg2, arg3, arg4, x);
+void test___taccess__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _taccess(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _taccess(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__PeekMessageW__leakignore() {
-  char *p = malloc(10); *p=0;
-  PeekMessageW(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
+void test___taccess__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _taccess(NULL, arg2);
 }
 
-void test__PeekMessageW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  PeekMessageW(p, arg2, arg3, arg4, arg5);
+void test___taccess__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _taccess(x, arg2);
 }
 
-void test__PeekMessageW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PeekMessageW(arg1, x, arg3, arg4, arg5);
+void test___taccess__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _taccess(arg1, x);
 }
 
-void test__PeekMessageW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PeekMessageW(arg1, arg2, x, 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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PeekMessageW(arg1, arg2, arg3, x, arg5);
+void test__PeekMessage__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    PeekMessage(p, arg2, arg3, arg4, arg5);
+    // cppcheck-suppress memleak
 }
 
-void test__PeekMessageW__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PeekMessageW(arg1, arg2, arg3, arg4, x);
+void test__PeekMessage__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    PeekMessage(NULL, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PeekMessage(arg1, x, arg3, arg4, arg5);
 }
 
-void test__GetMessage__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetMessage(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__PeekMessage__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PeekMessage(arg1, arg2, x, arg4, arg5);
 }
 
-void test__GetMessage__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetMessage(p, arg2, arg3, arg4);
+void test__PeekMessage__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PeekMessage(arg1, arg2, arg3, x, arg5);
 }
 
-void test__GetMessage__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetMessage(arg1, x, arg3, arg4);
+void test__PeekMessage__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PeekMessage(arg1, arg2, arg3, arg4, x);
 }
 
-void test__GetMessage__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetMessage(arg1, arg2, x, 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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetMessage(arg1, arg2, arg3, x);
+void test__PeekMessageA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    PeekMessageA(p, arg2, arg3, arg4, arg5);
+    // 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__PeekMessageA__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    PeekMessageA(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test__GetMessageA__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetMessageA(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__PeekMessageA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PeekMessageA(arg1, x, arg3, arg4, arg5);
 }
 
-void test__GetMessageA__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetMessageA(p, arg2, arg3, arg4);
+void test__PeekMessageA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PeekMessageA(arg1, arg2, x, arg4, arg5);
 }
 
-void test__GetMessageA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetMessageA(arg1, x, arg3, arg4);
+void test__PeekMessageA__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PeekMessageA(arg1, arg2, arg3, x, arg5);
 }
 
-void test__GetMessageA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetMessageA(arg1, arg2, x, arg4);
+void test__PeekMessageA__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PeekMessageA(arg1, arg2, arg3, arg4, x);
 }
 
-void test__GetMessageA__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetMessageA(arg1, arg2, arg3, x);
+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__GetMessageW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GetMessageW(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__PeekMessageW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    PeekMessageW(p, arg2, arg3, arg4, arg5);
+    // cppcheck-suppress memleak
 }
 
-void test__GetMessageW__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetMessageW(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__PeekMessageW__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    PeekMessageW(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test__GetMessageW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetMessageW(p, arg2, arg3, arg4);
+void test__PeekMessageW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PeekMessageW(arg1, x, arg3, arg4, arg5);
 }
 
-void test__GetMessageW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetMessageW(arg1, x, arg3, arg4);
+void test__PeekMessageW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PeekMessageW(arg1, arg2, x, arg4, arg5);
 }
 
-void test__GetMessageW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetMessageW(arg1, arg2, x, arg4);
+void test__PeekMessageW__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PeekMessageW(arg1, arg2, arg3, x, arg5);
 }
 
-void test__GetMessageW__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetMessageW(arg1, arg2, arg3, x);
+void test__PeekMessageW__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PeekMessageW(arg1, arg2, arg3, arg4, x);
 }
 
-void test__TranslateMessage__noreturn() {
-  int x = 1;
-  if (cond) { x=100; TranslateMessage(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__leakignore() {
-  char *p = malloc(10); *p=0;
-  TranslateMessage(p);
-  // cppcheck-suppress memleak
+void test__GetMessage__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetMessage(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__TranslateMessage__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  TranslateMessage(p);
+void test__GetMessage__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetMessage(NULL, arg2, arg3, arg4);
 }
 
-void test__TranslateMessage__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  TranslateMessage(x);
+void test__GetMessage__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetMessage(arg1, x, arg3, arg4);
 }
 
-void test__DispatchMessage__noreturn() {
-  int x = 1;
-  if (cond) { x=100; DispatchMessage(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetMessage__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetMessage(arg1, arg2, x, arg4);
 }
 
-void test__DispatchMessage__leakignore() {
-  char *p = malloc(10); *p=0;
-  DispatchMessage(p);
-  // cppcheck-suppress memleak
+void test__GetMessage__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetMessage(arg1, arg2, arg3, x);
 }
 
-void test__DispatchMessage__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  DispatchMessage(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  DispatchMessage(x);
+void test__GetMessageA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetMessageA(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__DispatchMessageA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; DispatchMessageA(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetMessageA__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetMessageA(NULL, arg2, arg3, arg4);
 }
 
-void test__DispatchMessageA__leakignore() {
-  char *p = malloc(10); *p=0;
-  DispatchMessageA(p);
-  // cppcheck-suppress memleak
+void test__GetMessageA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetMessageA(arg1, x, arg3, arg4);
 }
 
-void test__DispatchMessageA__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  DispatchMessageA(p);
+void test__GetMessageA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetMessageA(arg1, arg2, x, arg4);
 }
 
-void test__DispatchMessageA__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  DispatchMessageA(x);
+void test__GetMessageA__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetMessageA(arg1, arg2, arg3, x);
 }
 
-void test__DispatchMessageW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; DispatchMessageW(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__leakignore() {
-  char *p = malloc(10); *p=0;
-  DispatchMessageW(p);
-  // cppcheck-suppress memleak
+void test__GetMessageW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetMessageW(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__DispatchMessageW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  DispatchMessageW(p);
+void test__GetMessageW__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetMessageW(NULL, arg2, arg3, arg4);
 }
 
-void test__DispatchMessageW__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  DispatchMessageW(x);
+void test__GetMessageW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetMessageW(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetMessageW(arg1, arg2, x, arg4);
 }
 
-void test__SendMessage__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SendMessage(p, arg2, arg3, arg4);
+void test__GetMessageW__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetMessageW(arg1, arg2, arg3, x);
 }
 
-void test__SendMessage__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  SendMessage(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SendMessage(arg1, x, arg3, arg4);
+void test__TranslateMessage__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    TranslateMessage(p);
+    // cppcheck-suppress memleak
 }
 
-void test__SendMessage__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SendMessage(arg1, arg2, x, arg4);
+void test__TranslateMessage__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    TranslateMessage(NULL);
 }
 
-void test__SendMessage__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SendMessage(arg1, arg2, arg3, x);
+void test__TranslateMessage__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    TranslateMessage(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        DispatchMessage(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__SendMessageA__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SendMessageA(p, arg2, arg3, arg4);
+void test__DispatchMessage__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    DispatchMessage(p);
+    // cppcheck-suppress memleak
 }
 
-void test__SendMessageA__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  SendMessageA(x, arg2, arg3, arg4);
+void test__DispatchMessage__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    DispatchMessage(NULL);
 }
 
-void test__SendMessageA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SendMessageA(arg1, x, arg3, arg4);
+void test__DispatchMessage__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    DispatchMessage(x);
 }
 
-void test__SendMessageA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SendMessageA(arg1, arg2, x, arg4);
+void test__DispatchMessageA__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        DispatchMessageA(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__SendMessageA__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SendMessageA(arg1, arg2, arg3, x);
+void test__DispatchMessageA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    DispatchMessageA(p);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    DispatchMessageA(NULL);
 }
 
-void test__SendMessageW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SendMessageW(p, arg2, arg3, arg4);
+void test__DispatchMessageA__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    DispatchMessageA(x);
 }
 
-void test__SendMessageW__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  SendMessageW(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SendMessageW(arg1, x, arg3, arg4);
+void test__DispatchMessageW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    DispatchMessageW(p);
+    // cppcheck-suppress memleak
 }
 
-void test__SendMessageW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SendMessageW(arg1, arg2, x, arg4);
+void test__DispatchMessageW__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    DispatchMessageW(NULL);
 }
 
-void test__SendMessageW__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SendMessageW(arg1, arg2, arg3, x);
+void test__DispatchMessageW__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    DispatchMessageW(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        SendMessage(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__PostMessage__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  PostMessage(p, arg2, arg3, arg4);
+void test__SendMessage__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    SendMessage(NULL, arg2, arg3, arg4);
 }
 
-void test__PostMessage__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  PostMessage(x, arg2, arg3, arg4);
+void test__SendMessage__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    SendMessage(x, arg2, arg3, arg4);
 }
 
-void test__PostMessage__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PostMessage(arg1, x, arg3, arg4);
+void test__SendMessage__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SendMessage(arg1, x, arg3, arg4);
 }
 
-void test__PostMessage__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PostMessage(arg1, arg2, x, arg4);
+void test__SendMessage__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SendMessage(arg1, arg2, x, arg4);
 }
 
-void test__PostMessage__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PostMessage(arg1, arg2, arg3, x);
+void test__SendMessage__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SendMessage(arg1, arg2, arg3, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        SendMessageA(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__PostMessageA__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  PostMessageA(p, arg2, arg3, arg4);
+void test__SendMessageA__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    SendMessageA(NULL, arg2, arg3, arg4);
 }
 
-void test__PostMessageA__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  PostMessageA(x, arg2, arg3, arg4);
+void test__SendMessageA__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    SendMessageA(x, arg2, arg3, arg4);
 }
 
-void test__PostMessageA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PostMessageA(arg1, x, arg3, arg4);
+void test__SendMessageA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SendMessageA(arg1, x, arg3, arg4);
 }
 
-void test__PostMessageA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PostMessageA(arg1, arg2, x, arg4);
+void test__SendMessageA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SendMessageA(arg1, arg2, x, arg4);
 }
 
-void test__PostMessageA__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PostMessageA(arg1, arg2, arg3, x);
+void test__SendMessageA__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SendMessageA(arg1, arg2, arg3, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        SendMessageW(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__PostMessageW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  PostMessageW(p, arg2, arg3, arg4);
+void test__SendMessageW__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    SendMessageW(NULL, arg2, arg3, arg4);
 }
 
-void test__PostMessageW__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  PostMessageW(x, arg2, arg3, arg4);
+void test__SendMessageW__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    SendMessageW(x, arg2, arg3, arg4);
 }
 
-void test__PostMessageW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PostMessageW(arg1, x, arg3, arg4);
+void test__SendMessageW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SendMessageW(arg1, x, arg3, arg4);
 }
 
-void test__PostMessageW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PostMessageW(arg1, arg2, x, arg4);
+void test__SendMessageW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SendMessageW(arg1, arg2, x, arg4);
 }
 
-void test__PostMessageW__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PostMessageW(arg1, arg2, arg3, x);
+void test__SendMessageW__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SendMessageW(arg1, arg2, arg3, x);
 }
 
-void test__PostQuitMessage__noreturn() {
-  int x = 1;
-  if (cond) { x=100; PostQuitMessage(arg1); }
-  // 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__PostQuitMessage__leakignore() {
-  char *p = malloc(10); *p=0;
-  PostQuitMessage(p);
-  // cppcheck-suppress memleak
+void test__PostMessage__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    PostMessage(NULL, arg2, arg3, arg4);
 }
 
-void test__PostQuitMessage__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  PostQuitMessage(x);
+void test__PostMessage__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    PostMessage(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__PostMessage__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PostMessage(arg1, x, arg3, arg4);
 }
 
-void test__DefWindowProc__leakignore() {
-  char *p = malloc(10); *p=0;
-  DefWindowProc(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__PostMessage__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PostMessage(arg1, arg2, x, arg4);
 }
 
-void test__DefWindowProc__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  DefWindowProc(p, arg2, arg3, arg4);
+void test__PostMessage__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PostMessage(arg1, arg2, arg3, x);
 }
 
-void test__DefWindowProc__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  DefWindowProc(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  DefWindowProc(arg1, x, arg3, arg4);
+void test__PostMessageA__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    PostMessageA(NULL, arg2, arg3, arg4);
 }
 
-void test__DefWindowProc__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  DefWindowProc(arg1, arg2, x, arg4);
+void test__PostMessageA__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    PostMessageA(x, arg2, arg3, arg4);
 }
 
-void test__DefWindowProc__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  DefWindowProc(arg1, arg2, arg3, x);
+void test__PostMessageA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PostMessageA(arg1, x, 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__PostMessageA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PostMessageA(arg1, arg2, x, arg4);
 }
 
-void test__DefWindowProcA__leakignore() {
-  char *p = malloc(10); *p=0;
-  DefWindowProcA(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__PostMessageA__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PostMessageA(arg1, arg2, arg3, x);
 }
 
-void test__DefWindowProcA__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  DefWindowProcA(p, arg2, arg3, arg4);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  DefWindowProcA(x, arg2, arg3, arg4);
+void test__PostMessageW__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    PostMessageW(NULL, arg2, arg3, arg4);
 }
 
-void test__DefWindowProcA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  DefWindowProcA(arg1, x, arg3, arg4);
+void test__PostMessageW__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    PostMessageW(x, arg2, arg3, arg4);
 }
 
-void test__DefWindowProcA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  DefWindowProcA(arg1, arg2, x, arg4);
+void test__PostMessageW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PostMessageW(arg1, x, arg3, arg4);
 }
 
-void test__DefWindowProcA__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  DefWindowProcA(arg1, arg2, arg3, x);
+void test__PostMessageW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PostMessageW(arg1, arg2, x, arg4);
 }
 
-void test__DefWindowProcW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; DefWindowProcW(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__PostMessageW__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PostMessageW(arg1, arg2, arg3, x);
 }
 
-void test__DefWindowProcW__leakignore() {
-  char *p = malloc(10); *p=0;
-  DefWindowProcW(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__PostQuitMessage__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        PostQuitMessage(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__DefWindowProcW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  DefWindowProcW(p, arg2, arg3, arg4);
+void test__PostQuitMessage__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    PostQuitMessage(p);
+    // cppcheck-suppress memleak
 }
 
-void test__DefWindowProcW__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  DefWindowProcW(x, arg2, arg3, arg4);
+void test__PostQuitMessage__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    PostQuitMessage(x);
 }
 
-void test__DefWindowProcW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  DefWindowProcW(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__DefWindowProcW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  DefWindowProcW(arg1, arg2, x, arg4);
+void test__DefWindowProc__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    DefWindowProc(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__DefWindowProcW__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  DefWindowProcW(arg1, arg2, arg3, x);
+void test__DefWindowProc__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    DefWindowProc(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    DefWindowProc(x, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileInt__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  GetPrivateProfileInt(arg1, arg2, arg3, arg4);
+void test__DefWindowProc__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    DefWindowProc(arg1, x, arg3, arg4);
 }
 
-void test__GetPrivateProfileInt__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = GetPrivateProfileInt(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__DefWindowProc__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    DefWindowProc(arg1, arg2, x, arg4);
 }
 
-void test__GetPrivateProfileInt__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = GetPrivateProfileInt(p, arg2, arg3, arg4);
+void test__DefWindowProc__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    DefWindowProc(arg1, arg2, arg3, x);
 }
 
-void test__GetPrivateProfileInt__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = GetPrivateProfileInt(x, 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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = GetPrivateProfileInt(arg1, p, arg3, arg4);
+void test__DefWindowProcA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    DefWindowProcA(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileInt__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = GetPrivateProfileInt(arg1, x, arg3, arg4);
+void test__DefWindowProcA__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    DefWindowProcA(NULL, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileInt__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = GetPrivateProfileInt(arg1, arg2, x, arg4);
+void test__DefWindowProcA__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    DefWindowProcA(x, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileInt__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = GetPrivateProfileInt(arg1, arg2, arg3, p);
+void test__DefWindowProcA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    DefWindowProcA(arg1, x, arg3, arg4);
 }
 
-void test__GetPrivateProfileInt__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = GetPrivateProfileInt(arg1, arg2, arg3, x);
+void test__DefWindowProcA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    DefWindowProcA(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__DefWindowProcA__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    DefWindowProcA(arg1, arg2, arg3, x);
 }
 
-void test__GetPrivateProfileIntA__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  GetPrivateProfileIntA(arg1, arg2, arg3, arg4);
+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__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = GetPrivateProfileIntA(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__DefWindowProcW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    DefWindowProcW(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileIntA__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = GetPrivateProfileIntA(p, arg2, arg3, arg4);
+void test__DefWindowProcW__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    DefWindowProcW(NULL, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileIntA__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = GetPrivateProfileIntA(x, arg2, arg3, arg4);
+void test__DefWindowProcW__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    DefWindowProcW(x, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileIntA__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = GetPrivateProfileIntA(arg1, p, arg3, arg4);
+void test__DefWindowProcW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    DefWindowProcW(arg1, x, arg3, arg4);
 }
 
-void test__GetPrivateProfileIntA__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = GetPrivateProfileIntA(arg1, x, arg3, arg4);
+void test__DefWindowProcW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    DefWindowProcW(arg1, arg2, x, arg4);
 }
 
-void test__GetPrivateProfileIntA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = GetPrivateProfileIntA(arg1, arg2, x, arg4);
+void test__DefWindowProcW__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    DefWindowProcW(arg1, arg2, arg3, x);
 }
 
-void test__GetPrivateProfileIntA__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = GetPrivateProfileIntA(arg1, arg2, arg3, p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = GetPrivateProfileIntA(arg1, arg2, arg3, x);
+void test__GetPrivateProfileInt__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    GetPrivateProfileInt(arg1, arg2, arg3, arg4);
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = GetPrivateProfileInt(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileIntW__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  GetPrivateProfileIntW(arg1, arg2, arg3, arg4);
+void test__GetPrivateProfileInt__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = GetPrivateProfileInt(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = GetPrivateProfileInt(x, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileIntW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = GetPrivateProfileIntW(p, arg2, arg3, arg4);
+void test__GetPrivateProfileInt__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = GetPrivateProfileInt(arg1, NULL, arg3, arg4);
 }
 
-void test__GetPrivateProfileIntW__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = GetPrivateProfileIntW(x, arg2, arg3, arg4);
+void test__GetPrivateProfileInt__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = GetPrivateProfileInt(arg1, x, arg3, arg4);
 }
 
-void test__GetPrivateProfileIntW__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = GetPrivateProfileIntW(arg1, p, arg3, arg4);
+void test__GetPrivateProfileInt__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = GetPrivateProfileInt(arg1, arg2, x, arg4);
 }
 
-void test__GetPrivateProfileIntW__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = GetPrivateProfileIntW(arg1, x, arg3, arg4);
+void test__GetPrivateProfileInt__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = GetPrivateProfileInt(arg1, arg2, arg3, NULL);
 }
 
-void test__GetPrivateProfileIntW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = GetPrivateProfileIntW(arg1, arg2, x, arg4);
+void test__GetPrivateProfileInt__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = GetPrivateProfileInt(arg1, arg2, arg3, x);
 }
 
-void test__GetPrivateProfileIntW__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = GetPrivateProfileIntW(arg1, arg2, arg3, p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = GetPrivateProfileIntW(arg1, arg2, arg3, x);
+void test__GetPrivateProfileIntA__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    GetPrivateProfileIntA(arg1, arg2, arg3, arg4);
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = GetPrivateProfileIntA(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileSection__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetPrivateProfileSection(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__GetPrivateProfileIntA__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = GetPrivateProfileIntA(NULL, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileSection__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileSection(p, arg2, arg3, arg4);
+void test__GetPrivateProfileIntA__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = GetPrivateProfileIntA(x, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileSection__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileSection(x, arg2, arg3, arg4);
+void test__GetPrivateProfileIntA__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = GetPrivateProfileIntA(arg1, NULL, arg3, arg4);
 }
 
-void test__GetPrivateProfileSection__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileSection(arg1, p, arg3, arg4);
+void test__GetPrivateProfileIntA__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = GetPrivateProfileIntA(arg1, x, arg3, arg4);
 }
 
-void test__GetPrivateProfileSection__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileSection(arg1, arg2, x, arg4);
+void test__GetPrivateProfileIntA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = GetPrivateProfileIntA(arg1, arg2, x, arg4);
 }
 
-void test__GetPrivateProfileSection__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileSection(arg1, arg2, arg3, p);
+void test__GetPrivateProfileIntA__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = GetPrivateProfileIntA(arg1, arg2, arg3, NULL);
 }
 
-void test__GetPrivateProfileSection__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileSection(arg1, arg2, arg3, x);
+void test__GetPrivateProfileIntA__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = GetPrivateProfileIntA(arg1, arg2, arg3, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = GetPrivateProfileIntW(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__GetPrivateProfileSectionA__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetPrivateProfileSectionA(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__GetPrivateProfileIntW__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    GetPrivateProfileIntW(arg1, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileSectionA__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileSectionA(p, arg2, arg3, arg4);
+void test__GetPrivateProfileIntW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = GetPrivateProfileIntW(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileSectionA__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileSectionA(x, arg2, arg3, arg4);
+void test__GetPrivateProfileIntW__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = GetPrivateProfileIntW(NULL, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileSectionA__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileSectionA(arg1, p, arg3, arg4);
+void test__GetPrivateProfileIntW__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = GetPrivateProfileIntW(x, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileSectionA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileSectionA(arg1, arg2, x, arg4);
+void test__GetPrivateProfileIntW__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = GetPrivateProfileIntW(arg1, NULL, arg3, arg4);
 }
 
-void test__GetPrivateProfileSectionA__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileSectionA(arg1, arg2, arg3, p);
+void test__GetPrivateProfileIntW__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = GetPrivateProfileIntW(arg1, x, arg3, arg4);
 }
 
-void test__GetPrivateProfileSectionA__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileSectionA(arg1, arg2, arg3, x);
+void test__GetPrivateProfileIntW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = GetPrivateProfileIntW(arg1, arg2, x, arg4);
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = GetPrivateProfileIntW(arg1, arg2, arg3, NULL);
 }
 
-void test__GetPrivateProfileSectionW__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetPrivateProfileSectionW(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__GetPrivateProfileIntW__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = GetPrivateProfileIntW(arg1, arg2, arg3, x);
 }
 
-void test__GetPrivateProfileSectionW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileSectionW(p, arg2, arg3, arg4);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileSectionW(x, arg2, arg3, arg4);
+void test__GetPrivateProfileSection__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetPrivateProfileSection(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileSectionW__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileSectionW(arg1, p, arg3, arg4);
+void test__GetPrivateProfileSection__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileSection(NULL, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileSectionW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileSectionW(arg1, arg2, x, arg4);
+void test__GetPrivateProfileSection__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileSection(x, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileSectionW__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileSectionW(arg1, arg2, arg3, p);
+void test__GetPrivateProfileSection__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileSection(arg1, NULL, arg3, arg4);
 }
 
-void test__GetPrivateProfileSectionW__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileSectionW(arg1, arg2, arg3, x);
+void test__GetPrivateProfileSection__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileSection(arg1, arg2, x, arg4);
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileSection(arg1, arg2, arg3, NULL);
 }
 
-void test__GetPrivateProfileSectionNames__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetPrivateProfileSectionNames(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__GetPrivateProfileSection__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileSection(arg1, arg2, arg3, x);
 }
 
-void test__GetPrivateProfileSectionNames__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileSectionNames(p, arg2, arg3);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileSectionNames(arg1, x, arg3);
+void test__GetPrivateProfileSectionA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetPrivateProfileSectionA(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileSectionNames__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileSectionNames(arg1, arg2, p);
+void test__GetPrivateProfileSectionA__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileSectionA(NULL, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileSectionNames__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileSectionNames(arg1, arg2, x);
+void test__GetPrivateProfileSectionA__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileSectionA(x, arg2, 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__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileSectionA(arg1, NULL, arg3, arg4);
 }
 
-void test__GetPrivateProfileSectionNamesA__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetPrivateProfileSectionNamesA(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__GetPrivateProfileSectionA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileSectionA(arg1, arg2, x, arg4);
 }
 
-void test__GetPrivateProfileSectionNamesA__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileSectionNamesA(p, arg2, arg3);
+void test__GetPrivateProfileSectionA__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileSectionA(arg1, arg2, arg3, NULL);
 }
 
-void test__GetPrivateProfileSectionNamesA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileSectionNamesA(arg1, x, arg3);
+void test__GetPrivateProfileSectionA__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileSectionA(arg1, arg2, arg3, x);
 }
 
-void test__GetPrivateProfileSectionNamesA__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileSectionNamesA(arg1, arg2, p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileSectionNamesA(arg1, arg2, x);
+void test__GetPrivateProfileSectionW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetPrivateProfileSectionW(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileSectionW(NULL, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileSectionNamesW__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetPrivateProfileSectionNamesW(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__GetPrivateProfileSectionW__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileSectionW(x, arg2, arg3, arg4);
 }
 
-void test__GetPrivateProfileSectionNamesW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileSectionNamesW(p, arg2, arg3);
+void test__GetPrivateProfileSectionW__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileSectionW(arg1, NULL, arg3, arg4);
 }
 
-void test__GetPrivateProfileSectionNamesW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileSectionNamesW(arg1, x, arg3);
+void test__GetPrivateProfileSectionW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileSectionW(arg1, arg2, x, arg4);
 }
 
-void test__GetPrivateProfileSectionNamesW__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileSectionNamesW(arg1, arg2, p);
+void test__GetPrivateProfileSectionW__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileSectionW(arg1, arg2, arg3, NULL);
 }
 
-void test__GetPrivateProfileSectionNamesW__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileSectionNamesW(arg1, arg2, x);
+void test__GetPrivateProfileSectionW__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileSectionW(arg1, arg2, arg3, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        GetPrivateProfileSectionNames(arg1, arg2, arg3);
+    }
+    // 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__GetPrivateProfileSectionNames__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetPrivateProfileSectionNames(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileString__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileString(x, arg2, arg3, arg4, arg5, arg6);
+void test__GetPrivateProfileSectionNames__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileSectionNames(NULL, arg2, arg3);
 }
 
-void test__GetPrivateProfileString__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileString(arg1, x, arg3, arg4, arg5, arg6);
+void test__GetPrivateProfileSectionNames__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileSectionNames(arg1, x, arg3);
 }
 
-void test__GetPrivateProfileString__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileString(arg1, arg2, x, arg4, arg5, arg6);
+void test__GetPrivateProfileSectionNames__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileSectionNames(arg1, arg2, NULL);
 }
 
-void test__GetPrivateProfileString__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileString(arg1, arg2, arg3, p, arg5, arg6);
+void test__GetPrivateProfileSectionNames__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileSectionNames(arg1, arg2, x);
 }
 
-void test__GetPrivateProfileString__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileString(arg1, arg2, arg3, arg4, x, 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__arg6__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, p);
+void test__GetPrivateProfileSectionNamesA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetPrivateProfileSectionNamesA(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileString__arg6__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, x);
+void test__GetPrivateProfileSectionNamesA__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileSectionNamesA(NULL, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileSectionNamesA(arg1, x, arg3);
 }
 
-void test__GetPrivateProfileStringA__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetPrivateProfileStringA(p, arg2, arg3, arg4, arg5, arg6);
-  // cppcheck-suppress memleak
+void test__GetPrivateProfileSectionNamesA__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileSectionNamesA(arg1, arg2, NULL);
 }
 
-void test__GetPrivateProfileStringA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStringA(x, arg2, arg3, arg4, arg5, arg6);
+void test__GetPrivateProfileSectionNamesA__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileSectionNamesA(arg1, arg2, x);
 }
 
-void test__GetPrivateProfileStringA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStringA(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStringA(arg1, arg2, x, arg4, arg5, arg6);
+void test__GetPrivateProfileSectionNamesW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetPrivateProfileSectionNamesW(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileStringA__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStringA(arg1, arg2, arg3, p, arg5, arg6);
+void test__GetPrivateProfileSectionNamesW__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileSectionNamesW(NULL, arg2, arg3);
 }
 
-void test__GetPrivateProfileStringA__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStringA(arg1, arg2, arg3, arg4, x, arg6);
+void test__GetPrivateProfileSectionNamesW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileSectionNamesW(arg1, x, arg3);
 }
 
-void test__GetPrivateProfileStringA__arg6__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, p);
+void test__GetPrivateProfileSectionNamesW__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileSectionNamesW(arg1, arg2, NULL);
 }
 
-void test__GetPrivateProfileStringA__arg6__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, x);
+void test__GetPrivateProfileSectionNamesW__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileSectionNamesW(arg1, arg2, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, arg6);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__GetPrivateProfileStringW__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetPrivateProfileStringW(p, arg2, arg3, arg4, arg5, arg6);
-  // 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__GetPrivateProfileStringW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStringW(x, arg2, arg3, arg4, arg5, arg6);
+void test__GetPrivateProfileString__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileString(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileStringW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStringW(arg1, x, arg3, arg4, arg5, arg6);
+void test__GetPrivateProfileString__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileString(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileStringW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStringW(arg1, arg2, x, arg4, arg5, arg6);
+void test__GetPrivateProfileString__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileString(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileStringW__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStringW(arg1, arg2, arg3, p, arg5, arg6);
+void test__GetPrivateProfileString__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileString(arg1, arg2, arg3, NULL, arg5, arg6);
 }
 
-void test__GetPrivateProfileStringW__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStringW(arg1, arg2, arg3, arg4, x, arg6);
+void test__GetPrivateProfileString__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileString(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__GetPrivateProfileStringW__arg6__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStringW(arg1, arg2, arg3, arg4, arg5, p);
+void test__GetPrivateProfileString__arg6__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, NULL);
 }
 
-void test__GetPrivateProfileStringW__arg6__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStringW(arg1, arg2, arg3, arg4, arg5, x);
+void test__GetPrivateProfileString__arg6__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, arg6);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__GetPrivateProfileStruct__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetPrivateProfileStruct(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
+void test__GetPrivateProfileStringA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetPrivateProfileStringA(p, arg2, arg3, arg4, arg5, arg6);
+    // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileStruct__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStruct(p, arg2, arg3, arg4, arg5);
+void test__GetPrivateProfileStringA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStringA(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileStruct__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStruct(x, arg2, arg3, arg4, arg5);
+void test__GetPrivateProfileStringA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStringA(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileStruct__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStruct(arg1, p, arg3, arg4, arg5);
+void test__GetPrivateProfileStringA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStringA(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileStruct__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStruct(arg1, x, arg3, arg4, arg5);
+void test__GetPrivateProfileStringA__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStringA(arg1, arg2, arg3, NULL, arg5, arg6);
 }
 
-void test__GetPrivateProfileStruct__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStruct(arg1, arg2, p, arg4, arg5);
+void test__GetPrivateProfileStringA__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStringA(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__GetPrivateProfileStruct__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStruct(arg1, arg2, arg3, x, arg5);
+void test__GetPrivateProfileStringA__arg6__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, NULL);
 }
 
-void test__GetPrivateProfileStruct__arg5__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStruct(arg1, arg2, arg3, arg4, p);
+void test__GetPrivateProfileStringA__arg6__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__GetPrivateProfileStruct__arg5__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStruct(arg1, arg2, arg3, arg4, 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__GetPrivateProfileStructA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GetPrivateProfileStructA(arg1, arg2, arg3, arg4, arg5); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetPrivateProfileStringW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetPrivateProfileStringW(p, arg2, arg3, arg4, arg5, arg6);
+    // cppcheck-suppress memleak
 }
 
-void test__GetPrivateProfileStructA__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetPrivateProfileStructA(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
+void test__GetPrivateProfileStringW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStringW(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileStructA__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStructA(p, arg2, arg3, arg4, arg5);
+void test__GetPrivateProfileStringW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStringW(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileStructA__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStructA(x, arg2, arg3, arg4, arg5);
+void test__GetPrivateProfileStringW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStringW(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__GetPrivateProfileStructA__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStructA(arg1, p, arg3, arg4, arg5);
+void test__GetPrivateProfileStringW__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStringW(arg1, arg2, arg3, NULL, arg5, arg6);
 }
 
-void test__GetPrivateProfileStructA__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStructA(arg1, x, arg3, arg4, arg5);
+void test__GetPrivateProfileStringW__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStringW(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__GetPrivateProfileStructA__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStructA(arg1, arg2, p, arg4, arg5);
+void test__GetPrivateProfileStringW__arg6__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStringW(arg1, arg2, arg3, arg4, arg5, NULL);
 }
 
-void test__GetPrivateProfileStructA__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStructA(arg1, arg2, arg3, x, arg5);
+void test__GetPrivateProfileStringW__arg6__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStringW(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__GetPrivateProfileStructA__arg5__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStructA(arg1, arg2, arg3, arg4, p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStructA(arg1, arg2, arg3, arg4, x);
+void test__GetPrivateProfileStruct__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetPrivateProfileStruct(p, arg2, arg3, arg4, arg5);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStruct(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStruct(x, arg2, arg3, arg4, arg5);
 }
 
-void test__GetPrivateProfileStructW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStructW(p, arg2, arg3, arg4, arg5);
+void test__GetPrivateProfileStruct__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStruct(arg1, NULL, arg3, arg4, arg5);
 }
 
-void test__GetPrivateProfileStructW__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStructW(x, arg2, arg3, arg4, arg5);
+void test__GetPrivateProfileStruct__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStruct(arg1, x, arg3, arg4, arg5);
 }
 
-void test__GetPrivateProfileStructW__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStructW(arg1, p, arg3, arg4, arg5);
+void test__GetPrivateProfileStruct__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStruct(arg1, arg2, NULL, arg4, arg5);
 }
 
-void test__GetPrivateProfileStructW__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStructW(arg1, x, arg3, arg4, arg5);
+void test__GetPrivateProfileStruct__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStruct(arg1, arg2, arg3, x, arg5);
 }
 
-void test__GetPrivateProfileStructW__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStructW(arg1, arg2, p, arg4, arg5);
+void test__GetPrivateProfileStruct__arg5__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStruct(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test__GetPrivateProfileStructW__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStructW(arg1, arg2, arg3, x, arg5);
+void test__GetPrivateProfileStruct__arg5__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStruct(arg1, arg2, arg3, arg4, x);
 }
 
-void test__GetPrivateProfileStructW__arg5__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetPrivateProfileStructW(arg1, arg2, arg3, arg4, p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetPrivateProfileStructW(arg1, arg2, arg3, arg4, x);
+void test__GetPrivateProfileStructA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetPrivateProfileStructA(p, arg2, arg3, arg4, arg5);
+    // cppcheck-suppress memleak
 }
 
-void test__BeginPaint__noreturn() {
-  int x = 1;
-  if (cond) { x=100; BeginPaint(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetPrivateProfileStructA__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStructA(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test__BeginPaint__leakignore() {
-  char *p = malloc(10); *p=0;
-  BeginPaint(p, arg2);
-  // cppcheck-suppress memleak
+void test__GetPrivateProfileStructA__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStructA(x, arg2, arg3, arg4, arg5);
 }
 
-void test__BeginPaint__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  BeginPaint(x, arg2);
+void test__GetPrivateProfileStructA__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStructA(arg1, NULL, arg3, arg4, arg5);
 }
 
-void test__BeginPaint__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  BeginPaint(arg1, p);
+void test__GetPrivateProfileStructA__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStructA(arg1, x, arg3, 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__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStructA(arg1, arg2, NULL, arg4, arg5);
 }
 
-void test__EndPaint__leakignore() {
-  char *p = malloc(10); *p=0;
-  EndPaint(p, arg2);
-  // cppcheck-suppress memleak
+void test__GetPrivateProfileStructA__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStructA(arg1, arg2, arg3, x, arg5);
 }
 
-void test__EndPaint__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  EndPaint(x, arg2);
+void test__GetPrivateProfileStructA__arg5__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStructA(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test__EndPaint__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  EndPaint(arg1, p);
+void test__GetPrivateProfileStructA__arg5__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStructA(arg1, arg2, arg3, arg4, x);
 }
 
-void test__GetStockObject__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = GetStockObject(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  GetStockObject(arg1);
+void test__GetPrivateProfileStructW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetPrivateProfileStructW(p, arg2, arg3, arg4, arg5);
+    // cppcheck-suppress memleak
 }
 
-void test__GetStockObject__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((GetStockObject(arg1) > 10) || (GetStockObject(arg1) < 100)) {}
+void test__GetPrivateProfileStructW__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStructW(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test__GetStockObject__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = GetStockObject(p);
-  // cppcheck-suppress memleak
+void test__GetPrivateProfileStructW__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStructW(x, arg2, arg3, arg4, arg5);
 }
 
-void test__GetStockObject__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = GetStockObject(x);
+void test__GetPrivateProfileStructW__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStructW(arg1, NULL, 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__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStructW(arg1, x, arg3, arg4, arg5);
 }
 
-void test__LoadIcon__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  LoadIcon(arg1, arg2);
+void test__GetPrivateProfileStructW__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStructW(arg1, arg2, NULL, arg4, arg5);
 }
 
-void test__LoadIcon__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = LoadIcon(p, arg2);
-  // cppcheck-suppress memleak
+void test__GetPrivateProfileStructW__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStructW(arg1, arg2, arg3, x, arg5);
 }
 
-void test__LoadIcon__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = LoadIcon(x, arg2);
+void test__GetPrivateProfileStructW__arg5__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetPrivateProfileStructW(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test__LoadIcon__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = LoadIcon(arg1, p);
+void test__GetPrivateProfileStructW__arg5__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetPrivateProfileStructW(arg1, arg2, arg3, arg4, x);
 }
 
-void test__LoadIcon__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = LoadIcon(arg1, x);
+void test__BeginPaint__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        BeginPaint(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__LoadIconA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = LoadIconA(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__BeginPaint__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    BeginPaint(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__LoadIconA__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  LoadIconA(arg1, arg2);
+void test__BeginPaint__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    BeginPaint(x, arg2);
 }
 
-void test__LoadIconA__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = LoadIconA(p, arg2);
-  // cppcheck-suppress memleak
+void test__BeginPaint__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    BeginPaint(arg1, NULL);
 }
 
-void test__LoadIconA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = LoadIconA(x, arg2);
+void test__EndPaint__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        EndPaint(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__LoadIconA__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = LoadIconA(arg1, p);
+void test__EndPaint__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    EndPaint(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__LoadIconA__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = LoadIconA(arg1, x);
+void test__EndPaint__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    EndPaint(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__EndPaint__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    EndPaint(arg1, NULL);
 }
 
-void test__LoadIconW__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  LoadIconW(arg1, arg2);
+void test__GetStockObject__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = GetStockObject(arg1);
+    }
+    // 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__GetStockObject__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    GetStockObject(arg1);
 }
 
-void test__LoadIconW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = LoadIconW(x, arg2);
+void test__GetStockObject__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((GetStockObject(arg1) > 10) || (GetStockObject(arg1) < 100)) {}
 }
 
-void test__LoadIconW__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = LoadIconW(arg1, p);
+void test__GetStockObject__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = GetStockObject(p);
+    // cppcheck-suppress memleak
 }
 
-void test__LoadIconW__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = LoadIconW(arg1, x);
+void test__GetStockObject__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = GetStockObject(x);
 }
 
-void test__CreateSolidBrush__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = CreateSolidBrush(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  CreateSolidBrush(arg1);
+void test__LoadIcon__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    LoadIcon(arg1, arg2);
 }
 
-void test__CreateSolidBrush__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = CreateSolidBrush(p);
-  // cppcheck-suppress memleak
+void test__LoadIcon__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = LoadIcon(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__CreateSolidBrush__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateSolidBrush(x);
+void test__LoadIcon__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = LoadIcon(x, arg2);
 }
 
-void test__UpdateWindow__noreturn() {
-  int x = 1;
-  if (cond) { x=100; UpdateWindow(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__LoadIcon__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = LoadIcon(arg1, NULL);
 }
 
-void test__UpdateWindow__leakignore() {
-  char *p = malloc(10); *p=0;
-  UpdateWindow(p);
-  // cppcheck-suppress memleak
+void test__LoadIcon__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = LoadIcon(arg1, x);
 }
 
-void test__UpdateWindow__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  UpdateWindow(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  UpdateWindow(x);
+void test__LoadIconA__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    LoadIconA(arg1, arg2);
 }
 
-void test__EnableWindow__noreturn() {
-  int x = 1;
-  if (cond) { x=100; EnableWindow(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__LoadIconA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = LoadIconA(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__EnableWindow__leakignore() {
-  char *p = malloc(10); *p=0;
-  EnableWindow(p, arg2);
-  // cppcheck-suppress memleak
+void test__LoadIconA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = LoadIconA(x, arg2);
 }
 
-void test__EnableWindow__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  EnableWindow(p, arg2);
+void test__LoadIconA__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = LoadIconA(arg1, NULL);
 }
 
-void test__EnableWindow__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  EnableWindow(x, arg2);
+void test__LoadIconA__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = LoadIconA(arg1, x);
 }
 
-void test__EnableWindow__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  EnableWindow(arg1, x);
+void test__LoadIconW__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = LoadIconW(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    LoadIconW(arg1, arg2);
 }
 
-void test__CreateWindow__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__LoadIconW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = LoadIconW(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = LoadIconW(x, arg2);
 }
 
-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__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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateWindow(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateSolidBrush__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    CreateSolidBrush(arg1);
 }
 
-void test__CreateWindow__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateWindow(arg1, arg2, x, 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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateWindow(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
+void test__CreateSolidBrush__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateSolidBrush(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        UpdateWindow(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__CreateWindow__arg6__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateWindow(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
+void test__UpdateWindow__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    UpdateWindow(p);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    UpdateWindow(NULL);
 }
 
-void test__CreateWindow__arg8__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
+void test__UpdateWindow__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    UpdateWindow(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        EnableWindow(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    EnableWindow(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__CreateWindowA__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__EnableWindow__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    EnableWindow(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    EnableWindow(x, arg2);
 }
 
-void test__CreateWindowA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateWindowA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateWindowA(arg1, x, 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__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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindow(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindow(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindow(arg1, arg2, x, 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__CreateWindow__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindow(arg1, arg2, arg3, x, arg5, 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__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindow(arg1, arg2, arg3, arg4, x, 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__CreateWindow__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindow(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
 }
 
-void test__CreateWindowW__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+void test__CreateWindow__arg7__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, x, 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__CreateWindow__arg8__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
 }
 
-void test__CreateWindowW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateWindowW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateWindowW(arg1, x, 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__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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowA(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowA(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowA(arg1, arg2, x, arg4, 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__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowA(arg1, arg2, arg3, x, 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__CreateWindowA__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowA(arg1, arg2, arg3, arg4, x, arg6, 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__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
 }
 
-void test__CreateWindowEx__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  CreateWindowEx(arg1, arg2, arg3, 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__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__arg8__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
 }
 
-void test__CreateWindowEx__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateWindowEx(x, arg2, arg3, arg4, arg5, 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__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__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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowW(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowW(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowW(arg1, arg2, x, arg4, 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__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowW(arg1, arg2, arg3, x, arg5, 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__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowW(arg1, arg2, arg3, arg4, x, 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__CreateWindowW__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, x, arg7, 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__arg7__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
 }
 
-void test__CreateWindowExA__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  CreateWindowExA(arg1, arg2, arg3, arg4, 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__CreateWindowExA__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = CreateWindowExA(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-  // cppcheck-suppress memleak
+void test__CreateWindowW__arg9__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, 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__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__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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowEx(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowEx(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowEx(arg1, arg2, x, arg4, 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__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowEx(arg1, arg2, arg3, x, arg5, 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__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowEx(arg1, arg2, arg3, arg4, x, arg6, 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__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, x, arg7, 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__arg7__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
 }
 
-void test__CreateWindowExW__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  CreateWindowExW(arg1, arg2, arg3, arg4, arg5, 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__CreateWindowExW__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = CreateWindowExW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-  // cppcheck-suppress memleak
+void test__CreateWindowEx__arg9__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, 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__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__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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowExA(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowExA(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowExA(arg1, arg2, x, arg4, 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__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowExA(arg1, arg2, arg3, x, arg5, 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__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowExA(arg1, arg2, arg3, arg4, x, arg6, 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__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, x, arg7, 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__arg7__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
 }
 
-void test__SetWindowText__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetWindowText(p, arg2);
-  // cppcheck-suppress memleak
+void test__CreateWindowExA__arg8__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
 }
 
-void test__SetWindowText__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SetWindowText(p, arg2);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  SetWindowText(x, 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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SetWindowText(arg1, p);
+void test__CreateWindowExW__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__SetWindowText__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  SetWindowText(arg1, 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__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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SetWindowTextA(p, 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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__SetWindowTextA__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SetWindowTextA(arg1, p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  SetWindowTextA(arg1, x);
+void test__CreateWindowExW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowExW(arg1, arg2, x, arg4, 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__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowExW(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
 }
 
-void test__SetWindowTextW__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetWindowTextW(p, arg2);
-  // cppcheck-suppress memleak
+void test__CreateWindowExW__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowExW(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
 }
 
-void test__SetWindowTextW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SetWindowTextW(p, arg2);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  SetWindowTextW(x, 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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SetWindowTextW(arg1, p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  SetWindowTextW(arg1, x);
+void test__CreateWindowExW__arg9__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
 }
 
-void test__RegisterClass__noreturn() {
-  int x = 1;
-  if (cond) { x=100; RegisterClass(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__SetWindowText__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        SetWindowText(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__RegisterClass__leakignore() {
-  char *p = malloc(10); *p=0;
-  RegisterClass(p);
-  // cppcheck-suppress memleak
+void test__SetWindowText__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    SetWindowText(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__RegisterClass__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  RegisterClass(p);
+void test__SetWindowText__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    SetWindowText(NULL, arg2);
 }
 
-void test__RegisterClass__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  RegisterClass(x);
+void test__SetWindowText__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    SetWindowText(x, arg2);
 }
 
-void test__RegisterClassEx__noreturn() {
-  int x = 1;
-  if (cond) { x=100; RegisterClassEx(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__SetWindowText__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    SetWindowText(arg1, NULL);
 }
 
-void test__RegisterClassEx__leakignore() {
-  char *p = malloc(10); *p=0;
-  RegisterClassEx(p);
-  // cppcheck-suppress memleak
+void test__SetWindowText__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    SetWindowText(arg1, x);
 }
 
-void test__RegisterClassEx__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  RegisterClassEx(p);
+void test__SetWindowTextA__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        SetWindowTextA(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__RegisterClassEx__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  RegisterClassEx(x);
+void test__SetWindowTextA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    SetWindowTextA(p, arg2);
+    // 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__SetWindowTextA__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    SetWindowTextA(NULL, arg2);
 }
 
-void test__UnregisterClass__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  UnregisterClass(x, arg2);
+void test__SetWindowTextA__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    SetWindowTextA(x, arg2);
 }
 
-void test__UnregisterClass__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  UnregisterClass(arg1, x);
+void test__SetWindowTextA__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    SetWindowTextA(arg1, NULL);
 }
 
-void test__UnregisterClassA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; UnregisterClassA(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__SetWindowTextA__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    SetWindowTextA(arg1, x);
 }
 
-void test__UnregisterClassA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  UnregisterClassA(x, arg2);
+void test__SetWindowTextW__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        SetWindowTextW(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__UnregisterClassA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  UnregisterClassA(arg1, x);
+void test__SetWindowTextW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    SetWindowTextW(p, arg2);
+    // 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__SetWindowTextW__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    SetWindowTextW(NULL, arg2);
 }
 
-void test__UnregisterClassW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  UnregisterClassW(x, arg2);
+void test__SetWindowTextW__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    SetWindowTextW(x, arg2);
 }
 
-void test__UnregisterClassW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  UnregisterClassW(arg1, x);
+void test__SetWindowTextW__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    SetWindowTextW(arg1, NULL);
 }
 
-void test__MessageBox__noreturn() {
-  int x = 1;
-  if (cond) { x=100; MessageBox(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__SetWindowTextW__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    SetWindowTextW(arg1, x);
 }
 
-void test__MessageBox__leakignore() {
-  char *p = malloc(10); *p=0;
-  MessageBox(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__RegisterClass__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        RegisterClass(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__MessageBox__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  MessageBox(x, arg2, arg3, arg4);
+void test__RegisterClass__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    RegisterClass(p);
+    // cppcheck-suppress memleak
 }
 
-void test__MessageBox__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  MessageBox(arg1, x, arg3, arg4);
+void test__RegisterClass__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    RegisterClass(NULL);
 }
 
-void test__MessageBox__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  MessageBox(arg1, arg2, x, arg4);
+void test__RegisterClass__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    RegisterClass(x);
 }
 
-void test__MessageBox__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  MessageBox(arg1, arg2, arg3, x);
+void test__RegisterClassEx__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        RegisterClassEx(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    RegisterClassEx(p);
+    // cppcheck-suppress memleak
 }
 
-void test__MessageBoxA__leakignore() {
-  char *p = malloc(10); *p=0;
-  MessageBoxA(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  MessageBoxA(x, arg2, arg3, arg4);
+void test__UnregisterClass__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        UnregisterClass(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__MessageBoxA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  MessageBoxA(arg1, x, arg3, arg4);
+void test__UnregisterClass__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    UnregisterClass(x, arg2);
 }
 
-void test__MessageBoxA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  MessageBoxA(arg1, arg2, x, arg4);
+void test__UnregisterClass__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    UnregisterClass(arg1, x);
 }
 
-void test__MessageBoxA__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  MessageBoxA(arg1, arg2, arg3, x);
+void test__UnregisterClassA__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        UnregisterClassA(arg1, arg2);
+    }
+    // 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__UnregisterClassA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    UnregisterClassA(x, arg2);
 }
 
-void test__MessageBoxW__leakignore() {
-  char *p = malloc(10); *p=0;
-  MessageBoxW(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__UnregisterClassA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    UnregisterClassA(arg1, x);
 }
 
-void test__MessageBoxW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  MessageBoxW(x, arg2, arg3, arg4);
+void test__UnregisterClassW__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        UnregisterClassW(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__MessageBoxW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  MessageBoxW(arg1, x, arg3, arg4);
+void test__UnregisterClassW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    UnregisterClassW(x, arg2);
 }
 
-void test__MessageBoxW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  MessageBoxW(arg1, arg2, x, arg4);
+void test__UnregisterClassW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    UnregisterClassW(arg1, x);
 }
 
-void test__MessageBoxW__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  MessageBoxW(arg1, arg2, arg3, 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__GlobalLock__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GlobalLock(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__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__leakignore() {
-  char *p = malloc(10); *p=0;
-  GlobalLock(p);
-  // cppcheck-suppress memleak
+void test__MessageBox__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    MessageBox(arg1, arg2, x, arg4);
 }
 
-void test__GlobalLock__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GlobalLock(p);
+void test__MessageBox__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    MessageBox(arg1, arg2, arg3, x);
 }
 
-void test__GlobalLock__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GlobalLock(x);
+void test__MessageBoxA__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        MessageBoxA(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__GlobalUnlock__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GlobalUnlock(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__MessageBoxA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    MessageBoxA(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__GlobalUnlock__leakignore() {
-  char *p = malloc(10); *p=0;
-  GlobalUnlock(p);
-  // cppcheck-suppress memleak
+void test__MessageBoxA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    MessageBoxA(x, arg2, arg3, arg4);
 }
 
-void test__GlobalUnlock__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GlobalUnlock(p);
+void test__MessageBoxA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    MessageBoxA(arg1, x, arg3, arg4);
 }
 
-void test__GlobalUnlock__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GlobalUnlock(x);
+void test__MessageBoxA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    MessageBoxA(arg1, arg2, x, arg4);
 }
 
-void test__OpenClipboard__noreturn() {
-  int x = 1;
-  if (cond) { x=100; OpenClipboard(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__MessageBoxA__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    MessageBoxA(arg1, arg2, arg3, x);
 }
 
-void test__OpenClipboard__leakignore() {
-  char *p = malloc(10); *p=0;
-  OpenClipboard(p);
-  // cppcheck-suppress memleak
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenClipboard(x);
+void test__MessageBoxW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    MessageBoxW(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__EmptyClipboard__noreturn() {
-  int x = 1;
-  if (cond) { x=100; EmptyClipboard(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__MessageBoxW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    MessageBoxW(x, arg2, arg3, arg4);
 }
 
-void test__EmptyClipboard__leakignore() {
-  char *p = malloc(10); *p=0;
-  EmptyClipboard();
-  // cppcheck-suppress memleak
+void test__MessageBoxW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    MessageBoxW(arg1, x, arg3, arg4);
 }
 
-void test__CloseClipboard__noreturn() {
-  int x = 1;
-  if (cond) { x=100; CloseClipboard(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__MessageBoxW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    MessageBoxW(arg1, arg2, x, arg4);
 }
 
-void test__CloseClipboard__leakignore() {
-  char *p = malloc(10); *p=0;
-  CloseClipboard();
-  // cppcheck-suppress memleak
+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__SetClipboardData__noreturn() {
-  int x = 1;
-  if (cond) { x=100; SetClipboardData(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+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__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetClipboardData(p, arg2);
-  // cppcheck-suppress memleak
+
+void test__GlobalLock__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GlobalLock(x);
 }
-
-void test__SetClipboardData__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetClipboardData(x, arg2);
+
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetClipboardData(arg1, x);
+void test___wrmdir__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wrmdir(NULL);
 }
 
-void test___rmdir__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _rmdir(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___wrmdir__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wrmdir(x);
 }
 
-void test___rmdir__leakignore() {
-  char *p = malloc(10); *p=0;
-  _rmdir(p);
-  // cppcheck-suppress memleak
+void test___mkdir__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _mkdir(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___rmdir__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _rmdir(p);
+void test___mkdir__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _mkdir(p);
+    // cppcheck-suppress memleak
 }
 
-void test___rmdir__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _rmdir(x);
+void test___mkdir__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mkdir(NULL);
 }
 
-void test___wrmdir__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _wrmdir(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___mkdir__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _mkdir(x);
 }
 
-void test___wrmdir__leakignore() {
-  char *p = malloc(10); *p=0;
-  _wrmdir(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___wrmdir__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wrmdir(p);
+void test___wmkdir__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _wmkdir(p);
+    // cppcheck-suppress memleak
 }
 
-void test___wrmdir__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wrmdir(x);
+void test___wmkdir__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wmkdir(NULL);
 }
 
-void test___mkdir__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _mkdir(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___wmkdir__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wmkdir(x);
 }
 
-void test___mkdir__leakignore() {
-  char *p = malloc(10); *p=0;
-  _mkdir(p);
-  // cppcheck-suppress memleak
+void test___abs64__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _abs64(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___mkdir__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mkdir(p);
+void test___abs64__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _abs64(arg1);
 }
 
-void test___mkdir__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _mkdir(x);
+void test___abs64__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((_abs64(arg1) > 10) || (_abs64(arg1) < 100)) {}
 }
 
-void test___wmkdir__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _wmkdir(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___abs64__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _abs64(p);
+    // cppcheck-suppress memleak
 }
 
-void test___wmkdir__leakignore() {
-  char *p = malloc(10); *p=0;
-  _wmkdir(p);
-  // cppcheck-suppress memleak
+void test___abs64__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = _abs64(!x);
 }
 
-void test___wmkdir__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wmkdir(p);
+void test___abs64__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _abs64(x);
 }
 
-void test___wmkdir__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wmkdir(x);
+void test__CreateWaitableTimer__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = CreateWaitableTimer(arg1, arg2, arg3);
+    }
+    // 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__CreateWaitableTimer__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    CreateWaitableTimer(arg1, arg2, arg3);
 }
 
-void test___abs64__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _abs64(arg1);
+void test__CreateWaitableTimer__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWaitableTimer(x, arg2, arg3);
 }
 
-void test___abs64__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((_abs64(arg1) > 10) || (_abs64(arg1) < 100)) {}
+void test__CreateWaitableTimer__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWaitableTimer(arg1, x, arg3);
 }
 
-void test___abs64__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _abs64(p);
-  // cppcheck-suppress memleak
+void test__CreateWaitableTimer__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateWaitableTimer(arg1, arg2, x);
 }
 
-void test___abs64__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = _abs64(!x);
+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__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__CreateWaitableTimer__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = CreateWaitableTimer(arg1, arg2, arg3); }
-  // 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__CreateWaitableTimer__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  CreateWaitableTimer(arg1, arg2, arg3);
+void test__SetWaitableTimer__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    SetWaitableTimer(arg1, NULL, arg3, arg4, arg5, arg6);
 }
 
-void test__CreateWaitableTimer__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateWaitableTimer(x, arg2, arg3);
+void test__SetWaitableTimer__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    SetWaitableTimer(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__CreateWaitableTimer__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateWaitableTimer(arg1, x, arg3);
+void test__SetWaitableTimer__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetWaitableTimer(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__CreateWaitableTimer__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateWaitableTimer(arg1, arg2, x);
+void test__SetWaitableTimer__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetWaitableTimer(arg1, arg2, arg3, x, arg5, 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__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetWaitableTimer(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__SetWaitableTimer__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetWaitableTimer(p, arg2, arg3, arg4, arg5, arg6);
-  // cppcheck-suppress memleak
+void test__SetWaitableTimer__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetWaitableTimer(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__SetWaitableTimer__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetWaitableTimer(x, arg2, arg3, arg4, arg5, arg6);
+void test__WaitForSingleObject__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        WaitForSingleObject(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__SetWaitableTimer__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SetWaitableTimer(arg1, p, arg3, arg4, arg5, arg6);
+void test__WaitForSingleObject__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    WaitForSingleObject(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__SetWaitableTimer__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  SetWaitableTimer(arg1, x, arg3, arg4, arg5, arg6);
+void test__WaitForSingleObject__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    WaitForSingleObject(x, arg2);
 }
 
-void test__SetWaitableTimer__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetWaitableTimer(arg1, arg2, x, arg4, arg5, arg6);
+void test__WaitForSingleObject__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    WaitForSingleObject(arg1, x);
 }
 
-void test__SetWaitableTimer__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetWaitableTimer(arg1, arg2, arg3, x, arg5, arg6);
+void test___pclose__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _pclose(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__SetWaitableTimer__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetWaitableTimer(arg1, arg2, arg3, arg4, x, arg6);
+void test___pclose__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _pclose(NULL);
 }
 
-void test__SetWaitableTimer__arg6__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetWaitableTimer(arg1, arg2, arg3, arg4, arg5, x);
+void test___pclose__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _pclose(x);
 }
 
-void test__WaitForSingleObject__noreturn() {
-  int x = 1;
-  if (cond) { x=100; WaitForSingleObject(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__leakignore() {
-  char *p = malloc(10); *p=0;
-  WaitForSingleObject(p, arg2);
-  // cppcheck-suppress memleak
+void test___popen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _popen(arg1, arg2);
 }
 
-void test__WaitForSingleObject__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  WaitForSingleObject(x, arg2);
+void test___popen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _popen(NULL, arg2);
 }
 
-void test__WaitForSingleObject__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  WaitForSingleObject(arg1, x);
+void test___popen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _popen(x, arg2);
 }
 
-void test___pclose__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _pclose(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___popen__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _popen(arg1, NULL);
 }
 
-void test___pclose__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _pclose(p);
+void test___popen__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _popen(arg1, x);
 }
 
-void test___pclose__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _pclose(x);
+void test___wpopen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _wpopen(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___popen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = _popen(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___wpopen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _wpopen(arg1, arg2);
 }
 
-void test___popen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _popen(arg1, arg2);
+void test___wpopen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _wpopen(NULL, arg2);
 }
 
-void test___popen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _popen(p, arg2);
+void test___wpopen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _wpopen(x, arg2);
 }
 
-void test___popen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _popen(x, arg2);
+void test___wpopen__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _wpopen(arg1, NULL);
 }
 
-void test___popen__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _popen(arg1, p);
+void test___wpopen__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _wpopen(arg1, x);
 }
 
-void test___popen__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _popen(arg1, x);
+void test___tpopen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _tpopen(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___wpopen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = _wpopen(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___tpopen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _tpopen(arg1, arg2);
 }
 
-void test___wpopen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _wpopen(arg1, arg2);
+void test___tpopen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tpopen(NULL, arg2);
 }
 
-void test___wpopen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _wpopen(p, arg2);
+void test___tpopen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tpopen(x, arg2);
 }
 
-void test___wpopen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _wpopen(x, arg2);
+void test___tpopen__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tpopen(arg1, NULL);
 }
 
-void test___wpopen__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _wpopen(arg1, p);
+void test___tpopen__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tpopen(arg1, x);
 }
 
-void test___wpopen__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _wpopen(arg1, x);
+void test___mktemp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _mktemp(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tpopen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = _tpopen(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___mktemp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mktemp(arg1);
 }
 
-void test___tpopen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _tpopen(arg1, arg2);
+void test___mktemp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mktemp(p);
+    // cppcheck-suppress memleak
 }
 
-void test___tpopen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tpopen(p, arg2);
+void test___mktemp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mktemp(NULL);
 }
 
-void test___tpopen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tpopen(x, arg2);
+void test___mktemp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mktemp(x);
 }
 
-void test___tpopen__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tpopen(arg1, p);
+void test___wmktemp__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _wmktemp(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tpopen__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tpopen(arg1, x);
+void test___wmktemp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _wmktemp(arg1);
 }
 
-void test___mktemp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = _mktemp(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___wmktemp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _wmktemp(p);
+    // cppcheck-suppress memleak
 }
 
-void test___mktemp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mktemp(arg1);
+void test___wmktemp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _wmktemp(NULL);
 }
 
-void test___mktemp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _mktemp(p);
-  // cppcheck-suppress memleak
+void test___wmktemp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _wmktemp(x);
 }
 
-void test___mktemp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mktemp(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mktemp(x);
+void test__FindFirstFileEx__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    FindFirstFileEx(arg1, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindFirstFileEx(NULL, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test___wmktemp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _wmktemp(arg1);
+void test__FindFirstFileEx__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = FindFirstFileEx(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test___wmktemp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _wmktemp(p);
-  // cppcheck-suppress memleak
+void test__FindFirstFileEx__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = FindFirstFileEx(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test___wmktemp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _wmktemp(p);
+void test__FindFirstFileEx__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindFirstFileEx(arg1, arg2, NULL, arg4, arg5, arg6);
 }
 
-void test___wmktemp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _wmktemp(x);
+void test__FindFirstFileEx__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = FindFirstFileEx(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-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__FindFirstFileEx__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = FindFirstFileEx(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__FindFirstFileEx__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  FindFirstFileEx(arg1, arg2, arg3, arg4, arg5, arg6);
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindFirstFileEx(p, arg2, arg3, arg4, arg5, arg6);
+void test__FindFirstFileExA__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    FindFirstFileExA(arg1, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindFirstFileExA(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = FindFirstFileExA(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileEx__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindFirstFileEx(arg1, arg2, p, arg4, arg5, arg6);
+void test__FindFirstFileExA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = FindFirstFileExA(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileEx__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = FindFirstFileEx(arg1, arg2, arg3, x, arg5, arg6);
+void test__FindFirstFileExA__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindFirstFileExA(arg1, arg2, NULL, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileEx__arg6__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = FindFirstFileEx(arg1, arg2, arg3, arg4, arg5, x);
+void test__FindFirstFileExA__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = FindFirstFileExA(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-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__FindFirstFileExA__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = FindFirstFileExA(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__FindFirstFileExA__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  FindFirstFileExA(arg1, arg2, arg3, arg4, arg5, arg6);
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindFirstFileExA(p, arg2, arg3, arg4, arg5, arg6);
+void test__FindFirstFileExW__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    FindFirstFileExW(arg1, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindFirstFileExW(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = FindFirstFileExW(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileExA__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindFirstFileExA(arg1, arg2, p, arg4, arg5, arg6);
+void test__FindFirstFileExW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = FindFirstFileExW(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileExA__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = FindFirstFileExA(arg1, arg2, arg3, x, arg5, arg6);
+void test__FindFirstFileExW__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindFirstFileExW(arg1, arg2, NULL, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileExA__arg6__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = FindFirstFileExA(arg1, arg2, arg3, arg4, arg5, x);
+void test__FindFirstFileExW__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = FindFirstFileExW(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-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__FindFirstFileExW__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = FindFirstFileExW(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__FindFirstFileExW__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  FindFirstFileExW(arg1, arg2, arg3, arg4, arg5, arg6);
+void test__FindFirstFile__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = FindFirstFile(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__FindFirstFileExW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindFirstFileExW(p, arg2, arg3, arg4, arg5, arg6);
+void test__FindFirstFile__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    FindFirstFile(arg1, arg2);
 }
 
-void test__FindFirstFileExW__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = FindFirstFileExW(x, arg2, arg3, arg4, arg5, arg6);
+void test__FindFirstFile__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindFirstFile(NULL, arg2);
 }
 
-void test__FindFirstFileExW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = FindFirstFileExW(arg1, x, arg3, arg4, arg5, arg6);
+void test__FindFirstFile__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = FindFirstFile(x, arg2);
 }
 
-void test__FindFirstFileExW__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindFirstFileExW(arg1, arg2, p, arg4, arg5, arg6);
+void test__FindFirstFile__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindFirstFile(arg1, NULL);
 }
 
-void test__FindFirstFileExW__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = FindFirstFileExW(arg1, arg2, arg3, x, 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__arg6__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = FindFirstFileExW(arg1, arg2, arg3, arg4, arg5, x);
+void test__FindFirstFileW__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    FindFirstFileW(arg1, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindFirstFileW(NULL, arg2);
 }
 
-void test__FindFirstFile__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  FindFirstFile(arg1, arg2);
+void test__FindFirstFileW__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = FindFirstFileW(x, arg2);
 }
 
-void test__FindFirstFile__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindFirstFile(p, arg2);
+void test__FindFirstFileW__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindFirstFileW(arg1, NULL);
 }
 
-void test__FindFirstFile__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = FindFirstFile(x, 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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindFirstFile(arg1, p);
+void test__FindFirstFileA__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    FindFirstFileA(arg1, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindFirstFileA(NULL, arg2);
 }
 
-void test__FindFirstFileW__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  FindFirstFileW(arg1, arg2);
+void test__FindFirstFileA__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = FindFirstFileA(x, arg2);
 }
 
-void test__FindFirstFileW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindFirstFileW(p, arg2);
+void test__FindFirstFileA__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindFirstFileA(arg1, NULL);
 }
 
-void test__FindFirstFileW__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = FindFirstFileW(x, arg2);
+void test__FindClose__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        FindClose(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__FindFirstFileW__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindFirstFileW(arg1, p);
+void test__FindClose__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    FindClose(NULL);
 }
 
-void test__FindFirstFileA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = FindFirstFileA(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__FindClose__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    FindClose(x);
 }
 
-void test__FindFirstFileA__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  FindFirstFileA(arg1, arg2);
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindFirstFileA(p, arg2);
+void test__CreateThread__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    CreateThread(arg1, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileA__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = FindFirstFileA(x, arg2);
+void test__CreateThread__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateThread(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__FindFirstFileA__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindFirstFileA(arg1, p);
+void test__CreateThread__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateThread(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateThread(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__FindClose__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  FindClose(p);
+void test__CreateThread__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateThread(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__FindClose__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  FindClose(x);
+void test__CreateThread__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = CreateThread(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = FindNextFile(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__CreateThread__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  CreateThread(arg1, arg2, arg3, arg4, arg5, arg6);
+void test__FindNextFile__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    FindNextFile(arg1, arg2);
 }
 
-void test__CreateThread__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateThread(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateThread(arg1, x, arg3, arg4, arg5, arg6);
+void test__FindNextFile__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindNextFile(NULL, arg2);
 }
 
-void test__CreateThread__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateThread(arg1, arg2, x, arg4, arg5, arg6);
+void test__FindNextFile__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = FindNextFile(x, arg2);
 }
 
-void test__CreateThread__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateThread(arg1, arg2, arg3, x, arg5, arg6);
+void test__FindNextFile__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindNextFile(arg1, NULL);
 }
 
-void test__CreateThread__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = CreateThread(arg1, arg2, arg3, arg4, x, arg6);
+void test__FindNextFileW__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = FindNextFileW(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__FindNextFile__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = FindNextFile(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__FindNextFileW__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    FindNextFileW(arg1, arg2);
 }
 
-void test__FindNextFile__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  FindNextFile(arg1, arg2);
+void test__FindNextFileW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = FindNextFileW(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__FindNextFile__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = FindNextFile(p, arg2);
-  // cppcheck-suppress memleak
+void test__FindNextFileW__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindNextFileW(NULL, arg2);
 }
 
-void test__FindNextFile__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindNextFile(p, arg2);
+void test__FindNextFileW__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = FindNextFileW(x, arg2);
 }
 
-void test__FindNextFile__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = FindNextFile(x, arg2);
+void test__FindNextFileW__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindNextFileW(arg1, NULL);
 }
 
-void test__FindNextFile__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindNextFile(arg1, p);
+void test__FindNextFileA__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = FindNextFileA(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__FindNextFileW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = FindNextFileW(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__FindNextFileA__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    FindNextFileA(arg1, arg2);
 }
 
-void test__FindNextFileW__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  FindNextFileW(arg1, arg2);
+void test__FindNextFileA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = FindNextFileA(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__FindNextFileW__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = FindNextFileW(p, arg2);
-  // cppcheck-suppress memleak
+void test__FindNextFileA__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindNextFileA(NULL, arg2);
 }
 
-void test__FindNextFileW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindNextFileW(p, arg2);
+void test__FindNextFileA__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = FindNextFileA(x, arg2);
 }
 
-void test__FindNextFileW__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = FindNextFileW(x, arg2);
+void test__FindNextFileA__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = FindNextFileA(arg1, NULL);
 }
 
-void test__FindNextFileW__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindNextFileW(arg1, p);
+void test__SetEnvironmentVariable__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        SetEnvironmentVariable(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__FindNextFileA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = FindNextFileA(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__SetEnvironmentVariable__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    SetEnvironmentVariable(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__FindNextFileA__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  FindNextFileA(arg1, arg2);
+void test__SetEnvironmentVariable__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetEnvironmentVariable(x, arg2);
 }
 
-void test__FindNextFileA__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = FindNextFileA(p, arg2);
-  // cppcheck-suppress memleak
+void test__SetEnvironmentVariableW__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        SetEnvironmentVariableW(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__FindNextFileA__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindNextFileA(p, arg2);
+void test__SetEnvironmentVariableW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    SetEnvironmentVariableW(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__FindNextFileA__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = FindNextFileA(x, arg2);
+void test__SetEnvironmentVariableW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetEnvironmentVariableW(x, arg2);
 }
 
-void test__FindNextFileA__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = FindNextFileA(arg1, p);
+void test__SetEnvironmentVariableA__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        SetEnvironmentVariableA(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__SetEnvironmentVariable__noreturn() {
-  int x = 1;
-  if (cond) { x=100; SetEnvironmentVariable(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__SetEnvironmentVariableA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    SetEnvironmentVariableA(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__SetEnvironmentVariable__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetEnvironmentVariable(p, arg2);
-  // cppcheck-suppress memleak
+void test__SetEnvironmentVariableA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetEnvironmentVariableA(x, arg2);
 }
 
-void test__SetEnvironmentVariable__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetEnvironmentVariable(x, arg2);
+void test__QueryDosDevice__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = QueryDosDevice(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__SetEnvironmentVariableW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; SetEnvironmentVariableW(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__QueryDosDevice__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QueryDosDevice(arg1, arg2, arg3);
 }
 
-void test__SetEnvironmentVariableW__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetEnvironmentVariableW(p, arg2);
-  // cppcheck-suppress memleak
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetEnvironmentVariableW(x, arg2);
+void test__QueryDosDevice__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QueryDosDevice(arg1, arg2, x);
 }
 
-void test__SetEnvironmentVariableA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; SetEnvironmentVariableA(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+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__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetEnvironmentVariableA(p, arg2);
-  // cppcheck-suppress memleak
+void test__QueryDosDeviceW__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QueryDosDeviceW(arg1, arg2, arg3);
 }
 
-void test__SetEnvironmentVariableA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetEnvironmentVariableA(x, arg2);
+void test__QueryDosDeviceW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = QueryDosDeviceW(p, arg2, arg3);
+    // 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__QueryDosDeviceW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QueryDosDeviceW(x, arg2, arg3);
 }
 
-void test__QueryDosDevice__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QueryDosDevice(arg1, arg2, arg3);
+void test__QueryDosDeviceW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QueryDosDeviceW(arg1, arg2, x);
 }
 
-void test__QueryDosDevice__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = QueryDosDevice(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QueryDosDevice(x, arg2, arg3);
+void test__QueryDosDeviceA__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    QueryDosDeviceA(arg1, arg2, arg3);
 }
 
-void test__QueryDosDevice__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QueryDosDevice(arg1, arg2, x);
+void test__QueryDosDeviceA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = QueryDosDeviceA(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QueryDosDeviceA(x, arg2, arg3);
 }
 
-void test__QueryDosDeviceW__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QueryDosDeviceW(arg1, arg2, arg3);
+void test__QueryDosDeviceA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = QueryDosDeviceA(arg1, arg2, x);
 }
 
-void test__QueryDosDeviceW__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = QueryDosDeviceW(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QueryDosDeviceW(x, arg2, arg3);
+void test__GetDefaultCommConfig__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    GetDefaultCommConfig(arg1, arg2, arg3);
 }
 
-void test__QueryDosDeviceW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QueryDosDeviceW(arg1, arg2, x);
+void test__GetDefaultCommConfig__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = GetDefaultCommConfig(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = GetDefaultCommConfig(x, arg2, arg3);
 }
 
-void test__QueryDosDeviceA__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  QueryDosDeviceA(arg1, arg2, arg3);
+void test__GetDefaultCommConfig__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = GetDefaultCommConfig(arg1, NULL, arg3);
 }
 
-void test__QueryDosDeviceA__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = QueryDosDeviceA(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QueryDosDeviceA(x, arg2, arg3);
+void test__GetDefaultCommConfigW__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    GetDefaultCommConfigW(arg1, arg2, arg3);
 }
 
-void test__QueryDosDeviceA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = QueryDosDeviceA(arg1, arg2, x);
+void test__GetDefaultCommConfigW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = GetDefaultCommConfigW(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = GetDefaultCommConfigW(x, arg2, arg3);
 }
 
-void test__GetDefaultCommConfig__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  GetDefaultCommConfig(arg1, arg2, arg3);
+void test__GetDefaultCommConfigW__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = GetDefaultCommConfigW(arg1, NULL, arg3);
 }
 
-void test__GetDefaultCommConfig__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = GetDefaultCommConfig(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = GetDefaultCommConfig(x, arg2, arg3);
+void test__GetDefaultCommConfigA__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    GetDefaultCommConfigA(arg1, arg2, arg3);
 }
 
-void test__GetDefaultCommConfig__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = GetDefaultCommConfig(arg1, p, 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__GetDefaultCommConfigW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = GetDefaultCommConfigW(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetDefaultCommConfigA__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = GetDefaultCommConfigA(arg1, NULL, arg3);
 }
 
-void test__GetDefaultCommConfigW__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  GetDefaultCommConfigW(arg1, arg2, arg3);
+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__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = GetDefaultCommConfigW(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__GetTempPathW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetTempPathW(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__GetDefaultCommConfigW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = GetDefaultCommConfigW(x, arg2, arg3);
+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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = GetDefaultCommConfigW(arg1, p, arg3);
+void test__GetTempPathA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetTempPathA(x, arg2);
 }
 
-void test__GetDefaultCommConfigA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = GetDefaultCommConfigA(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  GetDefaultCommConfigA(arg1, arg2, arg3);
+
+void test__SetupDiGetDeviceInstanceId__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetupDiGetDeviceInstanceId(arg1, arg2, arg3, x, arg5);
 }
 
-void test__GetDefaultCommConfigA__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = GetDefaultCommConfigA(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
+void test__SetupDiEnumDeviceInfo__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        SetupDiEnumDeviceInfo(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
+}
 
-void test__GetDefaultCommConfigA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = GetDefaultCommConfigA(x, arg2, arg3);
+void test__SetupDiEnumDeviceInfo__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    SetupDiEnumDeviceInfo(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__GetDefaultCommConfigA__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = GetDefaultCommConfigA(arg1, p, arg3);
+void test__SetupDiEnumDeviceInfo__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetupDiEnumDeviceInfo(x, arg2, arg3);
 }
 
-void test__GetTempPath__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GetTempPath(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__SetupDiEnumDeviceInfo__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetupDiEnumDeviceInfo(arg1, x, arg3);
 }
 
-void test__GetTempPath__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetTempPath(p, arg2);
-  // cppcheck-suppress memleak
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetTempPath(x, arg2);
+void test__SetupDiGetClassDevs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    SetupDiGetClassDevs(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__GetTempPathW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GetTempPathW(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__SetupDiGetClassDevs__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetupDiGetClassDevs(arg1, x, arg3, arg4);
 }
 
-void test__GetTempPathW__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetTempPathW(p, arg2);
-  // cppcheck-suppress memleak
+void test__SetupDiGetClassDevs__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetupDiGetClassDevs(arg1, arg2, x, arg4);
 }
 
-void test__GetTempPathW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetTempPathW(x, arg2);
+void test__SetupDiGetClassDevs__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetupDiGetClassDevs(arg1, arg2, arg3, x);
 }
 
-void test__GetTempPathA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GetTempPathA(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___mbsstr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _mbsstr(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___mbsstr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mbsstr(arg1, arg2);
 }
 
-void test__GetTempPathA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetTempPathA(x, arg2);
+void test___mbsstr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mbsstr(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__SetupDiDestroyDeviceInfoList__noreturn() {
-  int x = 1;
-  if (cond) { x=100; SetupDiDestroyDeviceInfoList(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___mbsstr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbsstr(NULL, arg2);
 }
 
-void test__SetupDiDestroyDeviceInfoList__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetupDiDestroyDeviceInfoList(p);
-  // cppcheck-suppress memleak
+void test___mbsstr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbsstr(x, arg2);
 }
 
-void test__SetupDiDestroyDeviceInfoList__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetupDiDestroyDeviceInfoList(x);
+void test___mbsstr__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbsstr(arg1, NULL);
 }
 
-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___mbsstr__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbsstr(arg1, x);
 }
 
-void test__SetupDiGetDeviceInstanceId__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetupDiGetDeviceInstanceId(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
+void test___tcsstr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _tcsstr(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__SetupDiGetDeviceInstanceId__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetupDiGetDeviceInstanceId(x, arg2, arg3, arg4, arg5);
+void test___tcsstr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _tcsstr(arg1, arg2);
 }
 
-void test__SetupDiGetDeviceInstanceId__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetupDiGetDeviceInstanceId(arg1, x, arg3, arg4, arg5);
+void test___tcsstr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _tcsstr(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__SetupDiGetDeviceInstanceId__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetupDiGetDeviceInstanceId(arg1, arg2, arg3, x, arg5);
+void test___tcsstr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tcsstr(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tcsstr(x, arg2);
 }
 
-void test__SetupDiEnumDeviceInfo__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetupDiEnumDeviceInfo(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test___tcsstr__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tcsstr(arg1, NULL);
 }
 
-void test__SetupDiEnumDeviceInfo__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetupDiEnumDeviceInfo(x, arg2, arg3);
+void test___tcsstr__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tcsstr(arg1, x);
 }
 
-void test__SetupDiEnumDeviceInfo__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetupDiEnumDeviceInfo(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__SetupDiGetClassDevs__noreturn() {
-  int x = 1;
-  if (cond) { x=100; SetupDiGetClassDevs(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___mbsstr_l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mbsstr_l(arg1, arg2, arg3);
 }
 
-void test__SetupDiGetClassDevs__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetupDiGetClassDevs(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test___mbsstr_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mbsstr_l(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__SetupDiGetClassDevs__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetupDiGetClassDevs(arg1, x, arg3, arg4);
+void test___mbsstr_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbsstr_l(NULL, arg2, arg3);
 }
 
-void test__SetupDiGetClassDevs__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetupDiGetClassDevs(arg1, arg2, x, arg4);
+void test___mbsstr_l__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbsstr_l(x, arg2, arg3);
 }
 
-void test__SetupDiGetClassDevs__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetupDiGetClassDevs(arg1, arg2, arg3, x);
+void test___mbsstr_l__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbsstr_l(arg1, NULL, 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__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbsstr_l(arg1, x, arg3);
 }
 
-void test___mbsstr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mbsstr(arg1, arg2);
+void test___mbsstr_l__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _mbsstr_l(arg1, arg2, x);
 }
 
-void test___mbsstr__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _mbsstr(p, arg2);
-  // cppcheck-suppress memleak
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbsstr(p, arg2);
+void test___memccpy__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _memccpy(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test___mbsstr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbsstr(x, arg2);
+void test___memccpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _memccpy(NULL, arg2, arg3, arg4);
 }
 
-void test___mbsstr__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbsstr(arg1, p);
+void test___memccpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _memccpy(arg1, NULL, arg3, arg4);
 }
 
-void test___mbsstr__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbsstr(arg1, x);
+void test___memccpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _memccpy(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _memccpy(arg1, arg2, x, arg4);
 }
 
-void test___tcsstr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _tcsstr(arg1, arg2);
+void test___memccpy__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _memccpy(arg1, arg2, arg3, x);
 }
 
-void test___tcsstr__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _tcsstr(p, arg2);
-  // cppcheck-suppress memleak
+void test___fcloseall__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _fcloseall();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tcsstr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tcsstr(p, arg2);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tcsstr(x, arg2);
+void test___open__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _open(arg1, arg2, arg3);
 }
 
-void test___tcsstr__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tcsstr(arg1, p);
+void test___open__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _open(NULL, arg2, arg3);
 }
 
-void test___tcsstr__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tcsstr(arg1, x);
+void test___open__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _open(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___open__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _open(arg1, x, arg3);
 }
 
-void test___mbsstr_l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mbsstr_l(arg1, arg2, arg3);
+void test___open__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _open(arg1, arg2, x);
 }
 
-void test___mbsstr_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _mbsstr_l(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbsstr_l(p, arg2, arg3);
+void test___wopen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _wopen(arg1, arg2, arg3);
 }
 
-void test___mbsstr_l__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbsstr_l(x, arg2, arg3);
+void test___wopen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _wopen(NULL, arg2, arg3);
 }
 
-void test___mbsstr_l__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbsstr_l(arg1, p, arg3);
+void test___wopen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _wopen(x, arg2, arg3);
 }
 
-void test___mbsstr_l__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbsstr_l(arg1, x, arg3);
+void test___wopen__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _wopen(arg1, x, arg3);
 }
 
-void test___mbsstr_l__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _mbsstr_l(arg1, arg2, x);
+void test___wopen__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _wopen(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___topen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _topen(arg1, arg2, arg3);
+    }
+    // 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___topen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _topen(arg1, arg2, arg3);
 }
 
-void test___memccpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _memccpy(p, arg2, arg3, arg4);
+void test___topen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _topen(NULL, arg2, arg3);
 }
 
-void test___memccpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _memccpy(arg1, p, arg3, arg4);
+void test___topen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _topen(x, arg2, arg3);
 }
 
-void test___memccpy__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _memccpy(arg1, x, arg3, arg4);
+void test___topen__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _topen(arg1, x, arg3);
 }
 
-void test___memccpy__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _memccpy(arg1, arg2, x, arg4);
+void test___topen__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _topen(arg1, arg2, x);
 }
 
-void test___memccpy__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _memccpy(arg1, arg2, arg3, x);
+void test___close__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _close(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___fcloseall__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _fcloseall(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___close__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _close(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _swab(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___open__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _open(arg1, arg2, arg3);
+void test___swab__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _swab(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___open__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _open(p, arg2, arg3);
+void test___swab__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _swab(NULL, arg2, arg3);
 }
 
-void test___open__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _open(x, arg2, arg3);
+void test___swab__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _swab(arg1, NULL, arg3);
 }
 
-void test___open__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _open(arg1, x, arg3);
+void test___swab__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _swab(arg1, x, arg3);
 }
 
-void test___open__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _open(arg1, arg2, x);
+void test___swab__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    _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___swab__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _swab(arg1, arg2, x);
 }
 
-void test___wopen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _wopen(arg1, arg2, arg3);
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _wopen(p, arg2, arg3);
+void test___strnicmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _strnicmp(arg1, arg2, arg3);
 }
 
-void test___wopen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _wopen(x, arg2, arg3);
+void test___strnicmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _strnicmp(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___wopen__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _wopen(arg1, x, arg3);
+void test___strnicmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _strnicmp(NULL, arg2, arg3);
 }
 
-void test___wopen__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _wopen(arg1, arg2, x);
+void test___strnicmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _strnicmp(x, arg2, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _strnicmp(arg1, NULL, arg3);
 }
 
-void test___topen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _topen(arg1, arg2, arg3);
+void test___strnicmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _strnicmp(arg1, x, arg3);
 }
 
-void test___topen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _topen(p, arg2, arg3);
+void test___strnicmp__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = _strnicmp(arg1, arg2, !x);
 }
 
-void test___topen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _topen(x, arg2, arg3);
+void test___strnicmp__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _strnicmp(arg1, arg2, x);
 }
 
-void test___topen__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _topen(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _topen(arg1, arg2, x);
+void test___wcsnicmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _wcsnicmp(arg1, arg2, arg3);
 }
 
-void test___close__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _close(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___wcsnicmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _wcsnicmp(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___close__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _close(x);
+void test___wcsnicmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _wcsnicmp(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _wcsnicmp(x, arg2, arg3);
 }
 
-void test___swab__leakignore() {
-  char *p = malloc(10); *p=0;
-  _swab(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test___wcsnicmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _wcsnicmp(arg1, NULL, arg3);
 }
 
-void test___swab__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _swab(p, arg2, arg3);
+void test___wcsnicmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _wcsnicmp(arg1, x, arg3);
 }
 
-void test___swab__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _swab(arg1, p, arg3);
+void test___wcsnicmp__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = _wcsnicmp(arg1, arg2, !x);
 }
 
-void test___swab__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _swab(arg1, x, arg3);
+void test___wcsnicmp__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _wcsnicmp(arg1, arg2, x);
 }
 
-void test___swab__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  _swab(arg1, arg2, !x);
+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__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _swab(arg1, arg2, x);
+void test___mbsnicmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mbsnicmp(arg1, arg2, arg3);
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mbsnicmp(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___strnicmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _strnicmp(arg1, arg2, arg3);
+void test___mbsnicmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbsnicmp(NULL, arg2, arg3);
 }
 
-void test___strnicmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _strnicmp(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test___mbsnicmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbsnicmp(x, arg2, arg3);
 }
 
-void test___strnicmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _strnicmp(p, arg2, arg3);
+void test___mbsnicmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbsnicmp(arg1, NULL, arg3);
 }
 
-void test___strnicmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _strnicmp(x, arg2, arg3);
+void test___mbsnicmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbsnicmp(arg1, x, arg3);
 }
 
-void test___strnicmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _strnicmp(arg1, p, arg3);
+void test___mbsnicmp__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = _mbsnicmp(arg1, arg2, !x);
 }
 
-void test___strnicmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _strnicmp(arg1, x, arg3);
+void test___mbsnicmp__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _mbsnicmp(arg1, arg2, x);
 }
 
-void test___strnicmp__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = _strnicmp(arg1, arg2, !x);
+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__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _strnicmp(arg1, arg2, x);
+void test___tcsncicmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _tcsncicmp(arg1, 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___tcsncicmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _tcsncicmp(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___wcsnicmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _wcsnicmp(arg1, arg2, arg3);
+void test___tcsncicmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tcsncicmp(NULL, arg2, arg3);
 }
 
-void test___wcsnicmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _wcsnicmp(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test___tcsncicmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tcsncicmp(x, arg2, arg3);
 }
 
-void test___wcsnicmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _wcsnicmp(p, arg2, arg3);
+void test___tcsncicmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tcsncicmp(arg1, NULL, arg3);
 }
 
-void test___wcsnicmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _wcsnicmp(x, arg2, arg3);
+void test___tcsncicmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tcsncicmp(arg1, x, arg3);
 }
 
-void test___wcsnicmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _wcsnicmp(arg1, p, arg3);
+void test___tcsncicmp__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = _tcsncicmp(arg1, arg2, !x);
 }
 
-void test___wcsnicmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _wcsnicmp(arg1, x, arg3);
+void test___tcsncicmp__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _tcsncicmp(arg1, arg2, x);
 }
 
-void test___wcsnicmp__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = _wcsnicmp(arg1, arg2, !x);
+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__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _wcsnicmp(arg1, arg2, x);
+void test___tcsnicmp__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _tcsnicmp(arg1, arg2, 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___tcsnicmp__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _tcsnicmp(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___mbsnicmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mbsnicmp(arg1, arg2, arg3);
+void test___tcsnicmp__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tcsnicmp(NULL, arg2, arg3);
 }
 
-void test___mbsnicmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _mbsnicmp(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test___tcsnicmp__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tcsnicmp(x, arg2, arg3);
 }
 
-void test___mbsnicmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbsnicmp(p, arg2, arg3);
+void test___tcsnicmp__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tcsnicmp(arg1, NULL, arg3);
 }
 
-void test___mbsnicmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbsnicmp(x, arg2, arg3);
+void test___tcsnicmp__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tcsnicmp(arg1, x, arg3);
 }
 
-void test___mbsnicmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbsnicmp(arg1, p, arg3);
+void test___tcsnicmp__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = _tcsnicmp(arg1, arg2, !x);
 }
 
-void test___mbsnicmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbsnicmp(arg1, x, arg3);
+void test___tcsnicmp__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _tcsnicmp(arg1, arg2, x);
 }
 
-void test___mbsnicmp__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = _mbsnicmp(arg1, arg2, !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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _mbsnicmp(arg1, arg2, x);
+void test___strnicmp_l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _strnicmp_l(arg1, arg2, arg3, arg4);
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _strnicmp_l(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test___tcsncicmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _tcsncicmp(arg1, arg2, arg3);
+void test___strnicmp_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _strnicmp_l(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _strnicmp_l(x, arg2, arg3, arg4);
 }
 
-void test___tcsncicmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tcsncicmp(p, arg2, arg3);
+void test___strnicmp_l__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _strnicmp_l(arg1, NULL, arg3, arg4);
 }
 
-void test___tcsncicmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tcsncicmp(x, arg2, arg3);
+void test___strnicmp_l__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _strnicmp_l(arg1, x, arg3, arg4);
 }
 
-void test___tcsncicmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tcsncicmp(arg1, p, arg3);
+void test___strnicmp_l__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _strnicmp_l(arg1, arg2, x, arg4);
 }
 
-void test___tcsncicmp__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = _tcsncicmp(arg1, arg2, !x);
+void test___strnicmp_l__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _strnicmp_l(arg1, arg2, arg3, x);
 }
 
-void test___tcsncicmp__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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___tcsnicmp__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = _tcsnicmp(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___wcsnicmp_l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _wcsnicmp_l(arg1, arg2, arg3, arg4);
 }
 
-void test___tcsnicmp__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _tcsnicmp(arg1, arg2, arg3);
+void test___wcsnicmp_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _wcsnicmp_l(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test___tcsnicmp__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _tcsnicmp(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test___wcsnicmp_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _wcsnicmp_l(NULL, arg2, arg3, arg4);
 }
 
-void test___tcsnicmp__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tcsnicmp(p, arg2, arg3);
+void test___wcsnicmp_l__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _wcsnicmp_l(x, arg2, arg3, arg4);
 }
 
-void test___tcsnicmp__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tcsnicmp(x, arg2, arg3);
+void test___wcsnicmp_l__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _wcsnicmp_l(arg1, NULL, arg3, arg4);
 }
 
-void test___tcsnicmp__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tcsnicmp(arg1, p, arg3);
+void test___wcsnicmp_l__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _wcsnicmp_l(arg1, x, arg3, arg4);
 }
 
-void test___tcsnicmp__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tcsnicmp(arg1, x, arg3);
+void test___wcsnicmp_l__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = _wcsnicmp_l(arg1, arg2, !x, arg4);
 }
 
-void test___tcsnicmp__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = _tcsnicmp(arg1, arg2, !x);
+void test___wcsnicmp_l__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _wcsnicmp_l(arg1, arg2, x, arg4);
 }
 
-void test___tcsnicmp__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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___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__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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _strnicmp_l(arg1, arg2, arg3, arg4);
+void test___mbsnicmp_l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mbsnicmp_l(arg1, arg2, arg3, arg4);
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mbsnicmp_l(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test___strnicmp_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _strnicmp_l(p, arg2, arg3, arg4);
+void test___mbsnicmp_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbsnicmp_l(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbsnicmp_l(x, arg2, arg3, arg4);
 }
 
-void test___strnicmp_l__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _strnicmp_l(arg1, p, arg3, arg4);
+void test___mbsnicmp_l__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbsnicmp_l(arg1, NULL, 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__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbsnicmp_l(arg1, x, arg3, arg4);
 }
 
-void test___strnicmp_l__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = _strnicmp_l(arg1, arg2, !x, arg4);
+void test___mbsnicmp_l__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _mbsnicmp_l(arg1, arg2, x, arg4);
 }
 
-void test___strnicmp_l__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _strnicmp_l(arg1, arg2, arg3, x);
+void test___mbsnicmp_l__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _mbsnicmp_l(arg1, arg2, arg3, 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__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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _wcsnicmp_l(arg1, arg2, arg3, arg4);
+void test___tcsncicmp_l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _tcsncicmp_l(arg1, arg2, arg3, arg4);
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _tcsncicmp_l(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test___wcsnicmp_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _wcsnicmp_l(p, arg2, arg3, arg4);
+void test___tcsncicmp_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tcsncicmp_l(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tcsncicmp_l(x, arg2, arg3, arg4);
 }
 
-void test___wcsnicmp_l__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _wcsnicmp_l(arg1, p, arg3, arg4);
+void test___tcsncicmp_l__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tcsncicmp_l(arg1, NULL, 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__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tcsncicmp_l(arg1, x, arg3, arg4);
 }
 
-void test___wcsnicmp_l__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = _wcsnicmp_l(arg1, arg2, !x, arg4);
+void test___tcsncicmp_l__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _tcsncicmp_l(arg1, arg2, x, arg4);
 }
 
-void test___wcsnicmp_l__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _wcsnicmp_l(arg1, arg2, arg3, x);
+void test___tcsncicmp_l__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _tcsncicmp_l(arg1, arg2, arg3, 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__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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mbsnicmp_l(arg1, arg2, arg3, arg4);
+void test___malloc_dbg__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _malloc_dbg(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___malloc_dbg__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _malloc_dbg(x, arg2, arg3, arg4);
 }
 
-void test___mbsnicmp_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbsnicmp_l(p, arg2, arg3, arg4);
+void test___malloc_dbg__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _malloc_dbg(arg1, x, arg3, arg4);
 }
 
-void test___mbsnicmp_l__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbsnicmp_l(x, 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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbsnicmp_l(arg1, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbsnicmp_l(arg1, x, 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__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = _mbsnicmp_l(arg1, arg2, !x, arg4);
+void test___aligned_malloc_dbg__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _aligned_malloc_dbg(arg1, 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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _aligned_malloc_dbg(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _aligned_malloc_dbg(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _aligned_malloc_dbg(arg1, arg2, x, arg4);
 }
 
-void test___tcsncicmp_l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _tcsncicmp_l(arg1, arg2, arg3, arg4);
+void test___aligned_malloc_dbg__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _aligned_malloc_dbg(arg1, arg2, arg3, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _aligned_malloc(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tcsncicmp_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tcsncicmp_l(p, arg2, arg3, arg4);
+void test___aligned_malloc__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _aligned_malloc(arg1, arg2);
 }
 
-void test___tcsncicmp_l__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tcsncicmp_l(x, arg2, arg3, arg4);
+void test___aligned_malloc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _aligned_malloc(x, arg2);
 }
 
-void test___tcsncicmp_l__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tcsncicmp_l(arg1, p, arg3, arg4);
+void test___aligned_malloc__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _aligned_malloc(arg1, x);
 }
 
-void test___tcsncicmp_l__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tcsncicmp_l(arg1, x, 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__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = _tcsncicmp_l(arg1, arg2, !x, arg4);
+void test___mbslen_l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mbslen_l(arg1, arg2);
 }
 
-void test___tcsncicmp_l__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _tcsncicmp_l(arg1, arg2, arg3, x);
+void test___mbslen_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mbslen_l(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbslen_l(NULL, arg2);
 }
 
-void test___malloc_dbg__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _malloc_dbg(arg1, arg2, arg3, arg4);
+void test___mbslen_l__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbslen_l(x, arg2);
 }
 
-void test___malloc_dbg__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _malloc_dbg(x, arg2, arg3, arg4);
+void test___mbslen_l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _mbslen_l(arg1, x);
 }
 
-void test___malloc_dbg__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _malloc_dbg(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _malloc_dbg(arg1, arg2, x, arg4);
+void test___mbstrlen_l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mbstrlen_l(arg1, arg2);
 }
 
-void test___malloc_dbg__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _malloc_dbg(arg1, arg2, arg3, x);
+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___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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mbstrlen_l(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___aligned_malloc_dbg__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _aligned_malloc_dbg(arg1, arg2, arg3, arg4);
+void test___mbstrlen_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbstrlen_l(NULL, 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__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbstrlen_l(x, arg2);
 }
 
-void test___aligned_malloc_dbg__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _aligned_malloc_dbg(arg1, x, arg3, arg4);
+void test___mbstrlen_l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _mbstrlen_l(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _tcsclen_l(arg1, arg2);
+    }
+    // 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___tcsclen_l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _tcsclen_l(arg1, arg2);
 }
 
-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__pure(int arg1,int arg2)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((_tcsclen_l(arg1, arg2) > 10) || (_tcsclen_l(arg1, arg2) < 100)) {}
 }
 
-void test___aligned_malloc__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _aligned_malloc(arg1, arg2);
+void test___tcsclen_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _tcsclen_l(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___aligned_malloc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _aligned_malloc(x, arg2);
+void test___tcsclen_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tcsclen_l(NULL, arg2);
 }
 
-void test___aligned_malloc__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _aligned_malloc(arg1, x);
+void test___tcsclen_l__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tcsclen_l(x, arg2);
 }
 
-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___tcsclen_l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _tcsclen_l(arg1, x);
 }
 
-void test___mbslen_l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mbslen_l(arg1, arg2);
+void test___mbslen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _mbslen(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mbslen(arg1);
 }
 
-void test___mbslen_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _mbslen_l(p, arg2);
-  // cppcheck-suppress memleak
+void test___mbslen__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((_mbslen(arg1) > 10) || (_mbslen(arg1) < 100)) {}
 }
 
-void test___mbslen_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbslen_l(p, arg2);
+void test___mbslen__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mbslen(p);
+    // cppcheck-suppress memleak
 }
 
-void test___mbslen_l__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbslen_l(x, arg2);
+void test___mbslen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbslen(NULL);
 }
 
-void test___mbslen_l__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _mbslen_l(arg1, x);
+void test___mbslen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbslen(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _mbstrlen(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___mbstrlen_l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mbstrlen_l(arg1, arg2);
+void test___mbstrlen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mbstrlen(arg1);
 }
 
-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__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((_mbstrlen(arg1) > 10) || (_mbstrlen(arg1) < 100)) {}
 }
 
-void test___mbstrlen_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _mbstrlen_l(p, arg2);
-  // cppcheck-suppress memleak
+void test___mbstrlen__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mbstrlen(p);
+    // cppcheck-suppress memleak
 }
 
-void test___mbstrlen_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbstrlen_l(p, arg2);
+void test___mbstrlen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbstrlen(NULL);
 }
 
-void test___mbstrlen_l__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbstrlen_l(x, arg2);
+void test___mbstrlen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbstrlen(x);
 }
 
-void test___mbstrlen_l__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _mbstrlen_l(arg1, x);
+void test___tcslen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _tcslen(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _tcslen(arg1);
 }
 
-void test___tcsclen_l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _tcsclen_l(arg1, arg2);
+void test___tcslen__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((_tcslen(arg1) > 10) || (_tcslen(arg1) < 100)) {}
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _tcslen(p);
+    // cppcheck-suppress memleak
 }
 
-void test___tcsclen_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _tcsclen_l(p, arg2);
-  // cppcheck-suppress memleak
+void test___tcslen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tcslen(NULL);
 }
 
-void test___tcsclen_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tcsclen_l(p, arg2);
+void test___tcslen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tcslen(x);
 }
 
-void test___tcsclen_l__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tcsclen_l(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _tcsclen_l(arg1, x);
+void test___tcsclen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _tcsclen(arg1);
 }
 
-void test___mbslen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = _mbslen(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___tcsclen__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((_tcsclen(arg1) > 10) || (_tcsclen(arg1) < 100)) {}
 }
 
-void test___mbslen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mbslen(arg1);
+void test___tcsclen__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _tcsclen(p);
+    // cppcheck-suppress memleak
 }
 
-void test___mbslen__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((_mbslen(arg1) > 10) || (_mbslen(arg1) < 100)) {}
+void test___tcsclen__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tcsclen(NULL);
 }
 
-void test___mbslen__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _mbslen(p);
-  // cppcheck-suppress memleak
+void test___tcsclen__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tcsclen(x);
 }
 
-void test___mbslen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbslen(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbslen(x);
+void test___mbsrchr_l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mbsrchr_l(arg1, arg2, arg3);
 }
 
-void test___mbstrlen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = _mbstrlen(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___mbsrchr_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mbsrchr_l(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___mbstrlen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mbstrlen(arg1);
+void test___mbsrchr_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbsrchr_l(NULL, arg2, arg3);
 }
 
-void test___mbstrlen__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((_mbstrlen(arg1) > 10) || (_mbstrlen(arg1) < 100)) {}
+void test___mbsrchr_l__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbsrchr_l(x, arg2, arg3);
 }
 
-void test___mbstrlen__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _mbstrlen(p);
-  // cppcheck-suppress memleak
+void test___mbsrchr_l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _mbsrchr_l(arg1, x, arg3);
 }
 
-void test___mbstrlen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbstrlen(p);
+void test___mbsrchr_l__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _mbsrchr_l(arg1, arg2, x);
 }
 
-void test___mbstrlen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbstrlen(x);
+void test___mbsrchr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _mbsrchr(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tcslen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = _tcslen(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___mbsrchr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _mbsrchr(arg1, arg2);
 }
 
-void test___tcslen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _tcslen(arg1);
+void test___mbsrchr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _mbsrchr(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___tcslen__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((_tcslen(arg1) > 10) || (_tcslen(arg1) < 100)) {}
+void test___mbsrchr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _mbsrchr(NULL, arg2);
 }
 
-void test___tcslen__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _tcslen(p);
-  // cppcheck-suppress memleak
+void test___mbsrchr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _mbsrchr(x, arg2);
 }
 
-void test___tcslen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tcslen(p);
+void test___mbsrchr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _mbsrchr(arg1, x);
 }
 
-void test___tcslen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tcslen(x);
+void test___tcsrchr__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _tcsrchr(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tcsclen__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = _tcsclen(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___tcsrchr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _tcsrchr(arg1, arg2);
 }
 
-void test___tcsclen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _tcsclen(arg1);
+void test___tcsrchr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _tcsrchr(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___tcsclen__pure(int arg1) {
-  // cppcheck-suppress incorrectLogicOperator
-  if ((_tcsclen(arg1) > 10) || (_tcsclen(arg1) < 100)) {}
+void test___tcsrchr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tcsrchr(NULL, arg2);
 }
 
-void test___tcsclen__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _tcsclen(p);
-  // cppcheck-suppress memleak
+void test___tcsrchr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tcsrchr(x, arg2);
 }
 
-void test___tcsclen__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tcsclen(p);
+void test___tcsrchr__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _tcsrchr(arg1, x);
 }
 
-void test___tcsclen__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tcsclen(x);
+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___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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _strftime_l(p, arg2, arg3, arg4, arg5);
+    // cppcheck-suppress memleak
 }
 
-void test___mbsrchr_l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mbsrchr_l(arg1, arg2, arg3);
+void test___strftime_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _strftime_l(NULL, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _strftime_l(arg1, x, arg3, arg4, arg5);
 }
 
-void test___mbsrchr_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbsrchr_l(p, arg2, arg3);
+void test___strftime_l__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _strftime_l(arg1, arg2, NULL, arg4, arg5);
 }
 
-void test___mbsrchr_l__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbsrchr_l(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _mbsrchr_l(arg1, x, arg3);
+void test___strftime_l__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _strftime_l(arg1, arg2, arg3, NULL, arg5);
 }
 
-void test___mbsrchr_l__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _mbsrchr_l(arg1, arg2, x);
+void test___strftime_l__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _strftime_l(arg1, arg2, arg3, x, arg5);
 }
 
-void test___mbsrchr__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = _mbsrchr(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test___strftime_l__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _strftime_l(arg1, arg2, arg3, arg4, x);
 }
 
-void test___mbsrchr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _mbsrchr(arg1, arg2);
+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__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _mbsrchr(p, arg2);
-  // cppcheck-suppress memleak
+void test___wcsftime_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _wcsftime_l(p, arg2, arg3, arg4, arg5);
+    // cppcheck-suppress memleak
 }
 
-void test___mbsrchr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _mbsrchr(p, arg2);
+void test___wcsftime_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wcsftime_l(NULL, arg2, arg3, arg4, arg5);
 }
 
-void test___mbsrchr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _mbsrchr(x, arg2);
+void test___wcsftime_l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _wcsftime_l(arg1, x, arg3, arg4, arg5);
 }
 
-void test___mbsrchr__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _mbsrchr(arg1, x);
+void test___wcsftime_l__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wcsftime_l(arg1, arg2, NULL, 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__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wcsftime_l(arg1, arg2, x, arg4, arg5);
 }
 
-void test___tcsrchr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _tcsrchr(arg1, arg2);
+void test___wcsftime_l__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wcsftime_l(arg1, arg2, arg3, NULL, arg5);
 }
 
-void test___tcsrchr__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _tcsrchr(p, arg2);
-  // cppcheck-suppress memleak
+void test___wcsftime_l__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wcsftime_l(arg1, arg2, arg3, x, arg5);
 }
 
-void test___tcsrchr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tcsrchr(p, arg2);
+void test___wcsftime_l__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _wcsftime_l(arg1, arg2, arg3, arg4, x);
 }
 
-void test___tcsrchr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tcsrchr(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _tcsrchr(arg1, x);
+void test___tcsftime__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _tcsftime(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-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__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcsftime(NULL, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _tcsftime(arg1, x, arg3, arg4);
 }
 
-void test___strftime_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _strftime_l(p, arg2, arg3, arg4, arg5);
+void test___tcsftime__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcsftime(arg1, arg2, NULL, arg4);
 }
 
-void test___strftime_l__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _strftime_l(arg1, x, arg3, arg4, arg5);
+void test___tcsftime__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tcsftime(arg1, arg2, x, arg4);
 }
 
-void test___strftime_l__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _strftime_l(arg1, arg2, p, arg4, arg5);
+void test___tcsftime__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcsftime(arg1, arg2, arg3, NULL);
 }
 
-void test___strftime_l__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _strftime_l(arg1, arg2, x, arg4, arg5);
+void test___tcsftime__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tcsftime(arg1, arg2, arg3, x);
 }
 
-void test___strftime_l__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _strftime_l(arg1, arg2, arg3, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _strftime_l(arg1, arg2, arg3, x, arg5);
+void test___wfreopen_s__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _wfreopen_s(arg1, 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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _wfreopen_s(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _wfreopen_s(arg1, x, arg3, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _wfreopen_s(arg1, arg2, NULL, arg4);
 }
 
-void test___wcsftime_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wcsftime_l(p, arg2, arg3, arg4, arg5);
+void test___wfreopen_s__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _wfreopen_s(arg1, arg2, x, arg4);
 }
 
-void test___wcsftime_l__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _wcsftime_l(arg1, x, arg3, arg4, arg5);
+void test___wfreopen_s__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _wfreopen_s(arg1, arg2, arg3, NULL);
 }
 
-void test___wcsftime_l__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wcsftime_l(arg1, arg2, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wcsftime_l(arg1, arg2, x, 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__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wcsftime_l(arg1, arg2, arg3, p, arg5);
+void test___tfreopen_s__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _tfreopen_s(arg1, 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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _tfreopen_s(x, arg2, arg3, arg4);
 }
 
-void test___wcsftime_l__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _wcsftime_l(arg1, arg2, arg3, arg4, x);
+void test___tfreopen_s__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _tfreopen_s(arg1, x, arg3, 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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tfreopen_s(arg1, arg2, NULL, arg4);
 }
 
-void test___tcsftime__leakignore() {
-  char *p = malloc(10); *p=0;
-  _tcsftime(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test___tfreopen_s__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tfreopen_s(arg1, arg2, x, arg4);
 }
 
-void test___tcsftime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcsftime(p, arg2, arg3, arg4);
+void test___tfreopen_s__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tfreopen_s(arg1, arg2, arg3, NULL);
 }
 
-void test___tcsftime__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _tcsftime(arg1, x, arg3, arg4);
+void test___tfreopen_s__arg4__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tfreopen_s(arg1, arg2, arg3, x);
 }
 
-void test___tcsftime__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcsftime(arg1, arg2, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tcsftime(arg1, arg2, x, arg4);
+void test___wfreopen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _wfreopen(arg1, arg2, arg3);
 }
 
-void test___tcsftime__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcsftime(arg1, arg2, arg3, p);
+void test___wfreopen__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _wfreopen(x, arg2, arg3);
 }
 
-void test___tcsftime__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tcsftime(arg1, arg2, arg3, x);
+void test___wfreopen__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _wfreopen(arg1, NULL, 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__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _wfreopen(arg1, x, arg3);
 }
 
-void test___wfreopen_s__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _wfreopen_s(arg1, arg2, arg3, arg4);
+void test___wfreopen__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _wfreopen(arg1, arg2, NULL);
 }
 
-void test___wfreopen_s__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _wfreopen_s(x, arg2, arg3, arg4);
+void test___wfreopen__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _wfreopen(arg1, arg2, x);
 }
 
-void test___wfreopen_s__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _wfreopen_s(arg1, x, 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__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _wfreopen_s(arg1, arg2, p, arg4);
+void test___tfreopen__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _tfreopen(arg1, arg2, arg3);
 }
 
-void test___wfreopen_s__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _wfreopen_s(arg1, arg2, x, arg4);
+void test___tfreopen__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _tfreopen(x, arg2, arg3);
 }
 
-void test___wfreopen_s__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _wfreopen_s(arg1, arg2, arg3, p);
+void test___tfreopen__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tfreopen(arg1, NULL, arg3);
 }
 
-void test___wfreopen_s__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _wfreopen_s(arg1, arg2, arg3, x);
+void test___tfreopen__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tfreopen(arg1, x, arg3);
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _tfreopen(arg1, arg2, NULL);
 }
 
-void test___tfreopen_s__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _tfreopen_s(arg1, arg2, arg3, arg4);
+void test___tfreopen__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _tfreopen(arg1, arg2, x);
 }
 
-void test___tfreopen_s__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _tfreopen_s(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _tfreopen_s(arg1, x, arg3, arg4);
+void test___mbsncpy__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _mbsncpy(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___tfreopen_s__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tfreopen_s(arg1, arg2, p, arg4);
+void test___mbsncpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbsncpy(NULL, arg2, arg3);
 }
 
-void test___tfreopen_s__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tfreopen_s(arg1, arg2, x, arg4);
+void test___mbsncpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbsncpy(arg1, NULL, arg3);
 }
 
-void test___tfreopen_s__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tfreopen_s(arg1, arg2, arg3, p);
+void test___mbsncpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _mbsncpy(arg1, x, arg3);
 }
 
-void test___tfreopen_s__arg4__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tfreopen_s(arg1, arg2, arg3, x);
+void test___mbsncpy__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    _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___mbsncpy__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _mbsncpy(arg1, arg2, x);
 }
 
-void test___wfreopen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _wfreopen(arg1, arg2, arg3);
+void test___mbsnbcpy__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _mbsnbcpy(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___wfreopen__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _wfreopen(x, arg2, arg3);
+void test___mbsnbcpy__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _mbsnbcpy(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___wfreopen__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _wfreopen(arg1, p, arg3);
+void test___mbsnbcpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbsnbcpy(NULL, arg2, arg3);
 }
 
-void test___wfreopen__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _wfreopen(arg1, x, arg3);
+void test___mbsnbcpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbsnbcpy(arg1, NULL, arg3);
 }
 
-void test___wfreopen__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _wfreopen(arg1, arg2, p);
+void test___mbsnbcpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _mbsnbcpy(arg1, x, arg3);
 }
 
-void test___wfreopen__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _wfreopen(arg1, arg2, x);
+void test___mbsnbcpy__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    _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___mbsnbcpy__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _mbsnbcpy(arg1, arg2, x);
 }
 
-void test___tfreopen__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _tfreopen(arg1, arg2, arg3);
+void test___tcsncpy__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _tcsncpy(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tfreopen__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _tfreopen(x, arg2, arg3);
+void test___tcsncpy__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _tcsncpy(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___tfreopen__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tfreopen(arg1, p, arg3);
+void test___tcsncpy__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcsncpy(NULL, arg2, arg3);
 }
 
-void test___tfreopen__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tfreopen(arg1, x, arg3);
+void test___tcsncpy__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcsncpy(arg1, NULL, arg3);
 }
 
-void test___tfreopen__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _tfreopen(arg1, arg2, p);
+void test___tcsncpy__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tcsncpy(arg1, x, arg3);
 }
 
-void test___tfreopen__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = _tfreopen(arg1, arg2, x);
+void test___tcsncpy__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    _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___tcsncpy__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _tcsncpy(arg1, arg2, x);
 }
 
-void test___mbsncpy__leakignore() {
-  char *p = malloc(10); *p=0;
-  _mbsncpy(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbsncpy(p, arg2, arg3);
+void test___strncpy_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _strncpy_l(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test___mbsncpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbsncpy(arg1, p, arg3);
+void test___strncpy_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _strncpy_l(NULL, arg2, arg3, arg4);
 }
 
-void test___mbsncpy__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _mbsncpy(arg1, x, arg3);
+void test___strncpy_l__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _strncpy_l(arg1, NULL, arg3, arg4);
 }
 
-void test___mbsncpy__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  _mbsncpy(arg1, arg2, !x);
+void test___strncpy_l__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _strncpy_l(arg1, x, arg3, arg4);
 }
 
-void test___mbsncpy__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _mbsncpy(arg1, arg2, x);
+void test___strncpy_l__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    _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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _strncpy_l(arg1, arg2, x, arg4);
 }
 
-void test___mbsnbcpy__leakignore() {
-  char *p = malloc(10); *p=0;
-  _mbsnbcpy(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test___strncpy_l__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _strncpy_l(arg1, arg2, arg3, x);
 }
 
-void test___mbsnbcpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbsnbcpy(p, arg2, arg3);
+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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbsnbcpy(arg1, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _mbsnbcpy(arg1, x, arg3);
+void test___wcsncpy_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wcsncpy_l(NULL, arg2, arg3, arg4);
 }
 
-void test___mbsnbcpy__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  _mbsnbcpy(arg1, arg2, !x);
+void test___wcsncpy_l__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _wcsncpy_l(arg1, NULL, arg3, arg4);
 }
 
-void test___mbsnbcpy__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _mbsnbcpy(arg1, arg2, x);
+void test___wcsncpy_l__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _wcsncpy_l(arg1, x, arg3, 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__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    _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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _wcsncpy_l(arg1, arg2, x, arg4);
 }
 
-void test___tcsncpy__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcsncpy(p, arg2, arg3);
+void test___wcsncpy_l__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _wcsncpy_l(arg1, arg2, arg3, x);
 }
 
-void test___tcsncpy__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcsncpy(arg1, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tcsncpy(arg1, x, arg3);
+void test___mbsncpy_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _mbsncpy_l(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test___tcsncpy__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  _tcsncpy(arg1, arg2, !x);
+void test___mbsncpy_l__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbsncpy_l(NULL, arg2, arg3, arg4);
 }
 
-void test___tcsncpy__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _tcsncpy(arg1, arg2, x);
+void test___mbsncpy_l__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _mbsncpy_l(arg1, NULL, 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__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _mbsncpy_l(arg1, x, arg3, 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__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    _mbsncpy_l(arg1, arg2, !x, arg4);
 }
 
-void test___strncpy_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _strncpy_l(p, arg2, arg3, arg4);
+void test___mbsncpy_l__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _mbsncpy_l(arg1, arg2, x, arg4);
 }
 
-void test___strncpy_l__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _strncpy_l(arg1, p, arg3, arg4);
+void test___mbsncpy_l__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _mbsncpy_l(arg1, arg2, arg3, x);
 }
 
-void test___strncpy_l__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _strncpy_l(arg1, x, 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__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  _strncpy_l(arg1, arg2, !x, 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__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _strncpy_l(arg1, arg2, arg3, x);
+void test___tcsncpy_l__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _tcsncpy_l(arg1, NULL, 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__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    _tcsncpy_l(arg1, x, arg3, 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__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    _tcsncpy_l(arg1, arg2, !x, arg4);
 }
 
-void test___wcsncpy_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wcsncpy_l(p, arg2, arg3, arg4);
+void test___tcsncpy_l__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _tcsncpy_l(arg1, arg2, x, arg4);
 }
 
-void test___wcsncpy_l__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _wcsncpy_l(arg1, p, arg3, arg4);
+void test___tcsncpy_l__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _tcsncpy_l(arg1, arg2, arg3, x);
 }
 
-void test___wcsncpy_l__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _wcsncpy_l(arg1, x, 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__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  _wcsncpy_l(arg1, arg2, !x, arg4);
+void test___localtime32_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _localtime32_s(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___wcsncpy_l__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _wcsncpy_l(arg1, arg2, x, arg4);
+void test___localtime32_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _localtime32_s(NULL, arg2);
 }
 
-void test___wcsncpy_l__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _wcsncpy_l(arg1, arg2, arg3, x);
+void test___localtime32_s__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _localtime32_s(arg1, NULL);
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _localtime64_s(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___mbsncpy_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  _mbsncpy_l(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test___localtime64_s__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    _localtime64_s(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___mbsncpy_l__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbsncpy_l(p, arg2, arg3, arg4);
+void test___localtime64_s__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _localtime64_s(NULL, arg2);
 }
 
-void test___mbsncpy_l__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _mbsncpy_l(arg1, p, arg3, arg4);
+void test___localtime64_s__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    _localtime64_s(arg1, NULL);
 }
 
-void test___mbsncpy_l__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _mbsncpy_l(arg1, x, 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__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  _mbsncpy_l(arg1, arg2, !x, arg4);
+void test__CreateDirectory__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    CreateDirectory(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___mbsncpy_l__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _mbsncpy_l(arg1, arg2, x, arg4);
+void test__CreateDirectory__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateDirectory(x, arg2);
 }
 
-void test___mbsncpy_l__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _mbsncpy_l(arg1, arg2, arg3, x);
-}
+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___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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    CreateDirectoryA(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___tcsncpy_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  _tcsncpy_l(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
-}
+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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcsncpy_l(p, arg2, arg3, arg4);
+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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _tcsncpy_l(arg1, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  _tcsncpy_l(arg1, x, arg3, arg4);
+void test__LoadLibrary__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    LoadLibrary(x);
 }
 
-void test___tcsncpy_l__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  _tcsncpy_l(arg1, arg2, !x, 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__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _tcsncpy_l(arg1, arg2, x, arg4);
+void test__LoadLibraryA__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    LoadLibraryA(NULL);
 }
 
-void test___tcsncpy_l__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _tcsncpy_l(arg1, arg2, arg3, x);
+void test__LoadLibraryA__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    LoadLibraryA(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        LoadLibraryW(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___localtime32_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  _localtime32_s(p, arg2);
-  // cppcheck-suppress memleak
+void test__LoadLibraryW__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    LoadLibraryW(NULL);
 }
 
-void test___localtime32_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _localtime32_s(p, arg2);
+void test__LoadLibraryW__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    LoadLibraryW(x);
 }
 
-void test___localtime32_s__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _localtime32_s(arg1, p);
+void test__LoadLibraryEx__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        LoadLibraryEx(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << 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__LoadLibraryEx__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    LoadLibraryEx(x, arg2, arg3);
+}
 
-void test___localtime64_s__leakignore() {
-  char *p = malloc(10); *p=0;
-  _localtime64_s(p, arg2);
-  // cppcheck-suppress memleak
+void test__LoadLibraryEx__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    LoadLibraryEx(arg1, arg2, x);
 }
 
-void test___localtime64_s__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _localtime64_s(p, arg2);
+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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  _localtime64_s(arg1, p);
+void test__LoadLibraryExA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    LoadLibraryExA(x, arg2, arg3);
 }
 
-void test__CreateDirectory__noreturn() {
-  int x = 1;
-  if (cond) { x=100; CreateDirectory(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
-}
+void test__LoadLibraryExA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    LoadLibraryExA(arg1, arg2, x);
+}
 
-void test__CreateDirectory__leakignore() {
-  char *p = malloc(10); *p=0;
-  CreateDirectory(p, arg2);
-  // cppcheck-suppress memleak
+void test__LoadLibraryExW__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        LoadLibraryExW(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__CreateDirectory__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateDirectory(x, arg2);
+void test__LoadLibraryExW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    LoadLibraryExW(x, arg2, arg3);
 }
 
-void test__CreateDirectory__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateDirectory(arg1, x);
+void test__LoadLibraryExW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    LoadLibraryExW(arg1, arg2, x);
 }
 
-void test__CreateDirectoryA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; CreateDirectoryA(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetModuleHandle__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = GetModuleHandle(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__CreateDirectoryA__leakignore() {
-  char *p = malloc(10); *p=0;
-  CreateDirectoryA(p, arg2);
-  // cppcheck-suppress memleak
+void test__GetModuleHandle__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    GetModuleHandle(arg1);
 }
 
-void test__CreateDirectoryA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateDirectoryA(x, arg2);
+void test__GetModuleHandle__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = GetModuleHandle(p);
+    // cppcheck-suppress memleak
 }
-
-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__GetModuleHandle__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = GetModuleHandle(x);
 }
 
-void test__CreateDirectoryW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateDirectoryW(x, arg2);
+void test__GetModuleHandleA__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = GetModuleHandleA(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
-
-void test__CreateDirectoryW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateDirectoryW(arg1, x);
+
+void test__GetModuleHandleA__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    GetModuleHandleA(arg1);
 }
 
-void test__RemoveDirectory__noreturn() {
-  int x = 1;
-  if (cond) { x=100; RemoveDirectory(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetModuleHandleA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = GetModuleHandleA(p);
+    // cppcheck-suppress memleak
 }
 
-void test__RemoveDirectory__leakignore() {
-  char *p = malloc(10); *p=0;
-  RemoveDirectory(p);
-  // cppcheck-suppress memleak
+void test__GetModuleHandleA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = GetModuleHandleA(x);
 }
 
-void test__RemoveDirectory__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RemoveDirectory(x);
+void test__GetModuleHandleW__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = GetModuleHandleW(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__RemoveDirectoryA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; RemoveDirectoryA(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetModuleHandleW__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    GetModuleHandleW(arg1);
 }
 
-void test__RemoveDirectoryA__leakignore() {
-  char *p = malloc(10); *p=0;
-  RemoveDirectoryA(p);
-  // cppcheck-suppress memleak
+void test__GetModuleHandleW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = GetModuleHandleW(p);
+    // cppcheck-suppress memleak
 }
 
-void test__RemoveDirectoryA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RemoveDirectoryA(x);
+void test__GetModuleHandleW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = GetModuleHandleW(x);
 }
 
-void test__RemoveDirectoryW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; RemoveDirectoryW(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__leakignore() {
-  char *p = malloc(10); *p=0;
-  RemoveDirectoryW(p);
-  // cppcheck-suppress memleak
+void test__GetModuleHandleEx__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetModuleHandleEx(x, arg2, arg3);
 }
 
-void test__RemoveDirectoryW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  RemoveDirectoryW(x);
+void test__GetModuleHandleEx__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetModuleHandleEx(arg1, x, arg3);
 }
 
-void test____isascii__noreturn() {
-  int x = 1;
-  if (cond) { x=100; __isascii(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetModuleHandleEx__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetModuleHandleEx(arg1, arg2, NULL);
 }
 
-void test____isascii__leakignore() {
-  char *p = malloc(10); *p=0;
-  __isascii(p);
-  // cppcheck-suppress memleak
+void test__GetModuleHandleExA__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        GetModuleHandleExA(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test____isascii__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  __isascii(x);
+void test__GetModuleHandleExA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetModuleHandleExA(x, arg2, arg3);
 }
 
-void test__iswascii__noreturn() {
-  int x = 1;
-  if (cond) { x=100; iswascii(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetModuleHandleExA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetModuleHandleExA(arg1, x, arg3);
 }
 
-void test__iswascii__leakignore() {
-  char *p = malloc(10); *p=0;
-  iswascii(p);
-  // cppcheck-suppress memleak
+void test__GetModuleHandleExA__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetModuleHandleExA(arg1, arg2, NULL);
 }
 
-void test__iswascii__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  iswascii(x);
+void test__GetModuleHandleExW__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        GetModuleHandleExW(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___getchar__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _getchar(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetModuleHandleExW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetModuleHandleExW(x, arg2, arg3);
 }
 
-void test___getchar__leakignore() {
-  char *p = malloc(10); *p=0;
-  _getchar();
-  // cppcheck-suppress memleak
+void test__GetModuleHandleExW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetModuleHandleExW(arg1, x, arg3);
 }
 
-void test___getch_nolock__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _getch_nolock(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetModuleHandleExW__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetModuleHandleExW(arg1, arg2, NULL);
 }
 
-void test___getch_nolock__leakignore() {
-  char *p = malloc(10); *p=0;
-  _getch_nolock();
-  // cppcheck-suppress memleak
+void test__FreeLibrary__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        FreeLibrary(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___getwch__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _getwch(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__FreeLibrary__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    FreeLibrary(!x);
 }
 
-void test___getwch__leakignore() {
-  char *p = malloc(10); *p=0;
-  _getwch();
-  // cppcheck-suppress memleak
+void test__FreeLibrary__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    FreeLibrary(x);
 }
 
-void test___getwch_nolock__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _getwch_nolock(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__FreeLibraryAndExitThread__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        FreeLibraryAndExitThread(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___getwch_nolock__leakignore() {
-  char *p = malloc(10); *p=0;
-  _getwch_nolock();
-  // cppcheck-suppress memleak
+void test__FreeLibraryAndExitThread__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    FreeLibraryAndExitThread(x, arg2);
 }
 
-void test__Sleep__leakignore() {
-  char *p = malloc(10); *p=0;
-  Sleep(p);
-  // cppcheck-suppress memleak
+void test__FreeLibraryAndExitThread__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    FreeLibraryAndExitThread(arg1, !x);
 }
 
-void test__Sleep__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  Sleep(!x);
+void test__FreeLibraryAndExitThread__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    FreeLibraryAndExitThread(arg1, x);
 }
 
-void test__Sleep__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__SleepEx__noreturn() {
-  int x = 1;
-  if (cond) { x=100; SleepEx(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetProcAddress__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    GetProcAddress(arg1, arg2);
 }
 
-void test__SleepEx__leakignore() {
-  char *p = malloc(10); *p=0;
-  SleepEx(p, arg2);
-  // cppcheck-suppress memleak
+void test__GetProcAddress__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = GetProcAddress(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__SleepEx__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  SleepEx(!x, arg2);
+void test__GetProcAddress__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = GetProcAddress(!x, arg2);
 }
 
-void test__SleepEx__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SleepEx(x, arg2);
+void test__GetProcAddress__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = GetProcAddress(NULL, arg2);
 }
 
-void test__SleepEx__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SleepEx(arg1, x);
+void test__GetProcAddress__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = GetProcAddress(x, arg2);
 }
 
-void test__LoadLibrary__noreturn() {
-  int x = 1;
-  if (cond) { x=100; LoadLibrary(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetProcAddress__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = GetProcAddress(arg1, x);
 }
 
-void test__LoadLibrary__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  LoadLibrary(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  LoadLibrary(x);
+void test__CreateEvent__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEvent(x, arg2, arg3, arg4);
 }
 
-void test__LoadLibraryA__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  LoadLibraryA(p);
+void test__CreateEvent__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEvent(arg1, x, arg3, arg4);
 }
 
-void test__LoadLibraryA__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  LoadLibraryA(x);
+void test__CreateEvent__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEvent(arg1, arg2, x, arg4);
 }
 
-void test__LoadLibraryW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; LoadLibraryW(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__CreateEvent__arg4__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateEvent(arg1, arg2, arg3, !x);
 }
 
-void test__LoadLibraryW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  LoadLibraryW(p);
+void test__CreateEvent__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEvent(arg1, arg2, arg3, x);
 }
 
-void test__LoadLibraryW__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  LoadLibraryW(x);
+void test__CreateEventA__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        CreateEventA(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateEventA(!x, arg2, arg3, arg4);
 }
 
-void test__LoadLibraryEx__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  LoadLibraryEx(x, arg2, arg3);
+void test__CreateEventA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventA(x, arg2, arg3, arg4);
 }
 
-void test__LoadLibraryEx__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  LoadLibraryEx(arg1, arg2, x);
+void test__CreateEventA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventA(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventA(arg1, arg2, x, arg4);
 }
 
-void test__LoadLibraryExA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  LoadLibraryExA(x, arg2, arg3);
+void test__CreateEventA__arg4__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateEventA(arg1, arg2, arg3, !x);
 }
 
-void test__LoadLibraryExA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  LoadLibraryExA(arg1, arg2, x);
+void test__CreateEventA__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventA(arg1, arg2, arg3, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        CreateEventW(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__LoadLibraryExW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  LoadLibraryExW(x, arg2, arg3);
+void test__CreateEventW__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateEventW(!x, arg2, arg3, arg4);
 }
 
-void test__LoadLibraryExW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  LoadLibraryExW(arg1, arg2, x);
+void test__CreateEventW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventW(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventW(arg1, x, arg3, arg4);
 }
 
-void test__GetModuleHandle__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  GetModuleHandle(arg1);
+void test__CreateEventW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventW(arg1, arg2, x, arg4);
 }
 
-void test__GetModuleHandle__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = GetModuleHandle(p);
-  // cppcheck-suppress memleak
+void test__CreateEventW__arg4__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateEventW(arg1, arg2, arg3, !x);
 }
 
-void test__GetModuleHandle__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = GetModuleHandle(x);
+void test__CreateEventW__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventW(arg1, arg2, arg3, x);
 }
 
-void test__GetModuleHandleA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = GetModuleHandleA(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  GetModuleHandleA(arg1);
+void test__CreateEventEx__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateEventEx(!x, arg2, arg3, arg4);
 }
 
-void test__GetModuleHandleA__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = GetModuleHandleA(p);
-  // cppcheck-suppress memleak
+void test__CreateEventEx__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventEx(x, arg2, arg3, arg4);
 }
 
-void test__GetModuleHandleA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = GetModuleHandleA(x);
+void test__CreateEventEx__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventEx(arg1, x, arg3, arg4);
 }
 
-void test__GetModuleHandleW__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  GetModuleHandleW(arg1);
+void test__CreateEventEx__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateEventEx(arg1, arg2, !x, arg4);
 }
 
-void test__GetModuleHandleW__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = GetModuleHandleW(p);
-  // cppcheck-suppress memleak
+void test__CreateEventEx__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventEx(arg1, arg2, x, arg4);
 }
 
-void test__GetModuleHandleW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = GetModuleHandleW(x);
+void test__CreateEventEx__arg4__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    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__CreateEventEx__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventEx(arg1, arg2, arg3, x);
 }
 
-void test__GetModuleHandleEx__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetModuleHandleEx(x, arg2, arg3);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetModuleHandleEx(arg1, x, arg3);
+void test__CreateEventExA__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateEventExA(!x, arg2, arg3, arg4);
 }
 
-void test__GetModuleHandleEx__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetModuleHandleEx(arg1, arg2, p);
+void test__CreateEventExA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventExA(x, arg2, 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__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateEventExA(arg1, !x, arg3, arg4);
 }
 
-void test__GetModuleHandleExA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetModuleHandleExA(x, arg2, arg3);
+void test__CreateEventExA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventExA(arg1, x, arg3, arg4);
 }
 
-void test__GetModuleHandleExA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetModuleHandleExA(arg1, x, arg3);
+void test__CreateEventExA__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateEventExA(arg1, arg2, !x, arg4);
 }
 
-void test__GetModuleHandleExA__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetModuleHandleExA(arg1, arg2, p);
+void test__CreateEventExA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventExA(arg1, arg2, x, arg4);
 }
 
-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__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateEventExA(arg1, arg2, arg3, !x);
 }
 
-void test__GetModuleHandleExW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetModuleHandleExW(x, arg2, arg3);
+void test__CreateEventExA__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventExA(arg1, arg2, arg3, x);
 }
 
-void test__GetModuleHandleExW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetModuleHandleExW(arg1, x, 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__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetModuleHandleExW(arg1, arg2, p);
+void test__CreateEventExW__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventExW(x, arg2, arg3, arg4);
 }
 
-void test__FreeLibrary__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  FreeLibrary(!x);
+void test__CreateEventExW__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateEventExW(arg1, !x, arg3, arg4);
 }
 
-void test__FreeLibrary__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  FreeLibrary(x);
+void test__CreateEventExW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventExW(arg1, x, arg3, 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__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateEventExW(arg1, arg2, !x, arg4);
 }
 
-void test__FreeLibraryAndExitThread__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  FreeLibraryAndExitThread(!x, arg2);
+void test__CreateEventExW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventExW(arg1, arg2, x, arg4);
 }
 
-void test__FreeLibraryAndExitThread__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  FreeLibraryAndExitThread(x, arg2);
+void test__CreateEventExW__arg4__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateEventExW(arg1, arg2, arg3, !x);
 }
 
-void test__FreeLibraryAndExitThread__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  FreeLibraryAndExitThread(arg1, !x);
+void test__CreateEventExW__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateEventExW(arg1, arg2, arg3, x);
 }
 
-void test__FreeLibraryAndExitThread__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__GetProcAddress__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = GetProcAddress(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__OpenEvent__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    OpenEvent(!x, arg2, arg3);
 }
 
-void test__GetProcAddress__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  GetProcAddress(arg1, arg2);
+void test__OpenEvent__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenEvent(x, arg2, arg3);
 }
 
-void test__GetProcAddress__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = GetProcAddress(p, arg2);
-  // cppcheck-suppress memleak
+void test__OpenEvent__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenEvent(arg1, x, arg3);
 }
 
-void test__GetProcAddress__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  result = GetProcAddress(!x, arg2);
+void test__OpenEvent__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    OpenEvent(arg1, arg2, NULL);
 }
 
-void test__GetProcAddress__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = GetProcAddress(p, arg2);
+void test__OpenEvent__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    OpenEvent(arg1, arg2, x);
 }
 
-void test__GetProcAddress__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = GetProcAddress(x, 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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = GetProcAddress(arg1, x);
+void test__OpenEventA__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenEventA(x, arg2, arg3);
 }
 
-void test__CreateEvent__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEvent(!x, arg2, arg3, arg4);
+void test__OpenEventA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenEventA(arg1, x, arg3);
 }
 
-void test__CreateEvent__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEvent(x, arg2, arg3, arg4);
+void test__OpenEventA__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    OpenEventA(arg1, arg2, NULL);
 }
 
-void test__CreateEvent__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEvent(arg1, x, arg3, arg4);
+void test__OpenEventA__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    OpenEventA(arg1, arg2, x);
 }
 
-void test__CreateEvent__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEvent(arg1, arg2, x, 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__arg4__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEvent(arg1, arg2, arg3, !x);
+void test__OpenEventW__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    OpenEventW(!x, arg2, arg3);
 }
 
-void test__CreateEvent__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEvent(arg1, arg2, arg3, x);
+void test__OpenEventW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenEventW(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenEventW(arg1, x, arg3);
 }
 
-void test__CreateEventA__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventA(!x, arg2, arg3, arg4);
+void test__OpenEventW__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    OpenEventW(arg1, arg2, NULL);
 }
 
-void test__CreateEventA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventA(x, arg2, arg3, arg4);
+void test__OpenEventW__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    OpenEventW(arg1, arg2, x);
 }
 
-void test__CreateEventA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventA(arg1, x, arg3, arg4);
+void test__PulseEvent__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        PulseEvent(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__CreateEventA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventA(arg1, arg2, x, arg4);
+void test__PulseEvent__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    PulseEvent(p);
+    // cppcheck-suppress memleak
 }
 
-void test__CreateEventA__arg4__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventA(arg1, arg2, arg3, !x);
+void test__PulseEvent__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    PulseEvent(NULL);
 }
 
-void test__CreateEventA__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventA(arg1, arg2, arg3, x);
+void test__PulseEvent__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    PulseEvent(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        ResetEvent(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__CreateEventW__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventW(!x, arg2, arg3, arg4);
+void test__ResetEvent__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    ResetEvent(p);
+    // cppcheck-suppress memleak
 }
 
-void test__CreateEventW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventW(x, arg2, arg3, arg4);
+void test__ResetEvent__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    ResetEvent(NULL);
 }
 
-void test__CreateEventW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventW(arg1, x, arg3, arg4);
+void test__ResetEvent__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    ResetEvent(x);
 }
 
-void test__CreateEventW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventW(arg1, arg2, x, arg4);
+void test__SetEvent__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        SetEvent(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__CreateEventW__arg4__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventW(arg1, arg2, arg3, !x);
+void test__SetEvent__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    SetEvent(p);
+    // cppcheck-suppress memleak
 }
 
-void test__CreateEventW__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventW(arg1, arg2, arg3, x);
+void test__SetEvent__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    SetEvent(NULL);
 }
 
-void test__CreateEventEx__noreturn() {
-  int x = 1;
-  if (cond) { x=100; CreateEventEx(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__SetEvent__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    SetEvent(x);
 }
 
-void test__CreateEventEx__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventEx(!x, arg2, arg3, arg4);
+void test__InitializeCriticalSection__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        InitializeCriticalSection(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__CreateEventEx__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventEx(x, arg2, arg3, arg4);
+void test__InitializeCriticalSection__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    InitializeCriticalSection(!x);
 }
 
-void test__CreateEventEx__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventEx(arg1, !x, arg3, arg4);
+void test__InitializeCriticalSection__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    InitializeCriticalSection(NULL);
 }
 
-void test__CreateEventEx__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventEx(arg1, arg2, !x, arg4);
+void test__InitializeCriticalSectionAndSpinCount__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    InitializeCriticalSectionAndSpinCount(!x, arg2);
 }
 
-void test__CreateEventEx__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventEx(arg1, arg2, x, arg4);
+void test__InitializeCriticalSectionAndSpinCount__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    InitializeCriticalSectionAndSpinCount(NULL, arg2);
 }
 
-void test__CreateEventEx__arg4__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventEx(arg1, arg2, arg3, !x);
+void test__InitializeCriticalSectionAndSpinCount__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    InitializeCriticalSectionAndSpinCount(arg1, !x);
 }
 
-void test__CreateEventEx__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventEx(arg1, arg2, arg3, x);
+void test__InitializeCriticalSectionAndSpinCount__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    InitializeCriticalSectionAndSpinCount(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        InitializeCriticalSectionEx(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__CreateEventExA__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventExA(!x, arg2, arg3, arg4);
+void test__InitializeCriticalSectionEx__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    InitializeCriticalSectionEx(!x, arg2, arg3);
 }
 
-void test__CreateEventExA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventExA(x, arg2, arg3, arg4);
+void test__InitializeCriticalSectionEx__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    InitializeCriticalSectionEx(NULL, arg2, arg3);
 }
 
-void test__CreateEventExA__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventExA(arg1, !x, arg3, arg4);
+void test__InitializeCriticalSectionEx__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    InitializeCriticalSectionEx(arg1, !x, arg3);
 }
 
-void test__CreateEventExA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventExA(arg1, x, arg3, arg4);
+void test__InitializeCriticalSectionEx__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    InitializeCriticalSectionEx(arg1, x, arg3);
 }
 
-void test__CreateEventExA__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventExA(arg1, arg2, !x, arg4);
+void test__InitializeCriticalSectionEx__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    InitializeCriticalSectionEx(arg1, arg2, !x);
 }
 
-void test__CreateEventExA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventExA(arg1, arg2, x, arg4);
+void test__InitializeCriticalSectionEx__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    InitializeCriticalSectionEx(arg1, arg2, x);
 }
 
-void test__CreateEventExA__arg4__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventExA(arg1, arg2, arg3, !x);
+void test__SetCriticalSectionSpinCount__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        SetCriticalSectionSpinCount(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__CreateEventExA__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventExA(arg1, arg2, arg3, x);
+void test__SetCriticalSectionSpinCount__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    SetCriticalSectionSpinCount(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-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__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    SetCriticalSectionSpinCount(!x, arg2);
 }
 
-void test__CreateEventExW__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventExW(!x, arg2, arg3, arg4);
+void test__SetCriticalSectionSpinCount__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    SetCriticalSectionSpinCount(NULL, arg2);
 }
 
-void test__CreateEventExW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventExW(x, arg2, arg3, arg4);
+void test__SetCriticalSectionSpinCount__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    SetCriticalSectionSpinCount(arg1, !x);
 }
 
-void test__CreateEventExW__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventExW(arg1, !x, arg3, arg4);
+void test__SetCriticalSectionSpinCount__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    SetCriticalSectionSpinCount(arg1, x);
 }
 
-void test__CreateEventExW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventExW(arg1, arg2, !x, arg4);
+void test__DeleteCriticalSection__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    DeleteCriticalSection(!x);
 }
 
-void test__CreateEventExW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateEventExW(arg1, arg2, x, arg4);
+void test__DeleteCriticalSection__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    DeleteCriticalSection(NULL);
 }
 
-void test__CreateEventExW__arg4__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateEventExW(arg1, arg2, arg3, !x);
+void test__DeleteCriticalSection__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    DeleteCriticalSection(x);
 }
 
-void test__CreateEventExW__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__OpenEvent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; OpenEvent(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__EnterCriticalSection__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    EnterCriticalSection(p);
+    // cppcheck-suppress memleak
 }
 
-void test__OpenEvent__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  OpenEvent(!x, arg2, arg3);
+void test__EnterCriticalSection__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    EnterCriticalSection(!x);
 }
 
-void test__OpenEvent__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenEvent(x, arg2, arg3);
+void test__EnterCriticalSection__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    EnterCriticalSection(NULL);
 }
 
-void test__OpenEvent__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenEvent(arg1, x, arg3);
+void test__EnterCriticalSection__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    EnterCriticalSection(x);
 }
 
-void test__OpenEvent__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  OpenEvent(arg1, arg2, p);
+void test__TryEnterCriticalSection__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        TryEnterCriticalSection(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__OpenEvent__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  OpenEvent(arg1, arg2, x);
+void test__TryEnterCriticalSection__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    TryEnterCriticalSection(p);
+    // cppcheck-suppress memleak
 }
 
-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__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    TryEnterCriticalSection(!x);
 }
 
-void test__OpenEventA__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  OpenEventA(!x, arg2, arg3);
+void test__TryEnterCriticalSection__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    TryEnterCriticalSection(NULL);
 }
 
-void test__OpenEventA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenEventA(x, arg2, arg3);
+void test__TryEnterCriticalSection__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    TryEnterCriticalSection(x);
 }
 
-void test__OpenEventA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenEventA(arg1, x, arg3);
+void test__LeaveCriticalSection__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        LeaveCriticalSection(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__OpenEventA__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  OpenEventA(arg1, arg2, p);
+void test__LeaveCriticalSection__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    LeaveCriticalSection(p);
+    // cppcheck-suppress memleak
 }
 
-void test__OpenEventA__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  OpenEventA(arg1, arg2, x);
+void test__LeaveCriticalSection__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    LeaveCriticalSection(!x);
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    LeaveCriticalSection(NULL);
 }
 
-void test__OpenEventW__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  OpenEventW(!x, arg2, arg3);
+void test__LeaveCriticalSection__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    LeaveCriticalSection(x);
 }
 
-void test__OpenEventW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenEventW(arg1, x, arg3);
+void test__lstrcat__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    lstrcat(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__OpenEventW__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  OpenEventW(arg1, arg2, p);
+void test__lstrcat__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    lstrcat(NULL, arg2);
 }
 
-void test__OpenEventW__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  OpenEventW(arg1, arg2, x);
+void test__lstrcat__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    lstrcat(x, arg2);
 }
 
-void test__PulseEvent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; PulseEvent(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__lstrcat__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    lstrcat(arg1, NULL);
 }
 
-void test__PulseEvent__leakignore() {
-  char *p = malloc(10); *p=0;
-  PulseEvent(p);
-  // cppcheck-suppress memleak
+void test__lstrcat__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    lstrcat(arg1, x);
 }
 
-void test__PulseEvent__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  PulseEvent(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  PulseEvent(x);
+void test__CreateSemaphore__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphore(x, arg2, arg3, arg4);
 }
 
-void test__ResetEvent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; ResetEvent(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__CreateSemaphore__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphore(arg1, x, arg3, arg4);
 }
 
-void test__ResetEvent__leakignore() {
-  char *p = malloc(10); *p=0;
-  ResetEvent(p);
-  // cppcheck-suppress memleak
+void test__CreateSemaphore__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphore(arg1, arg2, x, arg4);
 }
 
-void test__ResetEvent__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ResetEvent(p);
+void test__CreateSemaphore__arg4__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateSemaphore(arg1, arg2, arg3, !x);
 }
 
-void test__ResetEvent__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  ResetEvent(x);
+void test__CreateSemaphore__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphore(arg1, arg2, arg3, x);
 }
 
-void test__SetEvent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; SetEvent(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetEvent(p);
-  // cppcheck-suppress memleak
+void test__CreateSemaphoreA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreA(x, arg2, arg3, arg4);
 }
 
-void test__SetEvent__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SetEvent(p);
+void test__CreateSemaphoreA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreA(arg1, x, arg3, arg4);
 }
 
-void test__SetEvent__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  SetEvent(x);
+void test__CreateSemaphoreA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreA(arg1, arg2, x, arg4);
 }
 
-void test__InitializeCriticalSection__noreturn() {
-  int x = 1;
-  if (cond) { x=100; InitializeCriticalSection(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__CreateSemaphoreA__arg4__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateSemaphoreA(arg1, arg2, arg3, !x);
 }
 
-void test__InitializeCriticalSection__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  InitializeCriticalSection(!x);
+void test__CreateSemaphoreA__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreA(arg1, arg2, arg3, x);
 }
 
-void test__InitializeCriticalSection__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  InitializeCriticalSection(p);
+void test__CreateSemaphoreW__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        CreateSemaphoreW(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__InitializeCriticalSectionAndSpinCount__noreturn() {
-  int x = 1;
-  if (cond) { x=100; InitializeCriticalSectionAndSpinCount(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__CreateSemaphoreW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreW(x, arg2, arg3, arg4);
 }
 
-void test__InitializeCriticalSectionAndSpinCount__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  InitializeCriticalSectionAndSpinCount(!x, arg2);
+void test__CreateSemaphoreW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreW(arg1, x, arg3, arg4);
 }
 
-void test__InitializeCriticalSectionAndSpinCount__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  InitializeCriticalSectionAndSpinCount(p, arg2);
+void test__CreateSemaphoreW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreW(arg1, arg2, x, arg4);
 }
 
-void test__InitializeCriticalSectionAndSpinCount__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  InitializeCriticalSectionAndSpinCount(arg1, !x);
+void test__CreateSemaphoreW__arg4__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateSemaphoreW(arg1, arg2, arg3, !x);
 }
 
-void test__InitializeCriticalSectionAndSpinCount__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  InitializeCriticalSectionAndSpinCount(arg1, x);
+void test__CreateSemaphoreW__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreW(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__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__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  InitializeCriticalSectionEx(!x, arg2, arg3);
+void test__CreateSemaphoreEx__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreEx(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__InitializeCriticalSectionEx__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  InitializeCriticalSectionEx(p, arg2, arg3);
+void test__CreateSemaphoreEx__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreEx(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__InitializeCriticalSectionEx__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  InitializeCriticalSectionEx(arg1, !x, arg3);
+void test__CreateSemaphoreEx__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreEx(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__InitializeCriticalSectionEx__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  InitializeCriticalSectionEx(arg1, x, arg3);
+void test__CreateSemaphoreEx__arg4__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateSemaphoreEx(arg1, arg2, arg3, !x, arg5, arg6);
 }
 
-void test__InitializeCriticalSectionEx__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  InitializeCriticalSectionEx(arg1, arg2, !x);
+void test__CreateSemaphoreEx__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreEx(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__InitializeCriticalSectionEx__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  InitializeCriticalSectionEx(arg1, arg2, x);
+void test__CreateSemaphoreEx__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreEx(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__SetCriticalSectionSpinCount__noreturn() {
-  int x = 1;
-  if (cond) { x=100; SetCriticalSectionSpinCount(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__CreateSemaphoreEx__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreEx(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__SetCriticalSectionSpinCount__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetCriticalSectionSpinCount(p, arg2);
-  // cppcheck-suppress memleak
+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__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  SetCriticalSectionSpinCount(!x, arg2);
+void test__CreateSemaphoreExA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreExA(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__SetCriticalSectionSpinCount__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  SetCriticalSectionSpinCount(p, arg2);
+void test__CreateSemaphoreExA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreExA(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__SetCriticalSectionSpinCount__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  SetCriticalSectionSpinCount(arg1, !x);
+void test__CreateSemaphoreExA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreExA(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__SetCriticalSectionSpinCount__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetCriticalSectionSpinCount(arg1, x);
+void test__CreateSemaphoreExA__arg4__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    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__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreExA(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__DeleteCriticalSection__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  DeleteCriticalSection(!x);
+void test__CreateSemaphoreExA__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreExA(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__DeleteCriticalSection__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  DeleteCriticalSection(p);
+void test__CreateSemaphoreExA__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreExA(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__DeleteCriticalSection__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  DeleteCriticalSection(x);
+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__EnterCriticalSection__noreturn() {
-  int x = 1;
-  if (cond) { x=100; EnterCriticalSection(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__CreateSemaphoreExW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreExW(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__EnterCriticalSection__leakignore() {
-  char *p = malloc(10); *p=0;
-  EnterCriticalSection(p);
-  // cppcheck-suppress memleak
+void test__CreateSemaphoreExW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreExW(arg1, x, arg3, arg4, arg5, arg6);
 }
 
-void test__EnterCriticalSection__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  EnterCriticalSection(!x);
+void test__CreateSemaphoreExW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreExW(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__EnterCriticalSection__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  EnterCriticalSection(p);
+void test__CreateSemaphoreExW__arg4__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateSemaphoreExW(arg1, arg2, arg3, !x, arg5, arg6);
 }
 
-void test__EnterCriticalSection__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  EnterCriticalSection(x);
+void test__CreateSemaphoreExW__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreExW(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__TryEnterCriticalSection__noreturn() {
-  int x = 1;
-  if (cond) { x=100; TryEnterCriticalSection(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__CreateSemaphoreExW__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreExW(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__TryEnterCriticalSection__leakignore() {
-  char *p = malloc(10); *p=0;
-  TryEnterCriticalSection(p);
-  // cppcheck-suppress memleak
+void test__CreateSemaphoreExW__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateSemaphoreExW(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__TryEnterCriticalSection__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  TryEnterCriticalSection(!x);
+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__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  TryEnterCriticalSection(p);
+void test__OpenSemaphore__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenSemaphore(x, arg2, arg3);
 }
 
-void test__TryEnterCriticalSection__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  TryEnterCriticalSection(x);
+void test__OpenSemaphore__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenSemaphore(arg1, x, arg3);
 }
 
-void test__LeaveCriticalSection__noreturn() {
-  int x = 1;
-  if (cond) { x=100; LeaveCriticalSection(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__OpenSemaphore__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    OpenSemaphore(arg1, arg2, !x);
 }
 
-void test__LeaveCriticalSection__leakignore() {
-  char *p = malloc(10); *p=0;
-  LeaveCriticalSection(p);
-  // cppcheck-suppress memleak
+void test__OpenSemaphore__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    OpenSemaphore(arg1, arg2, NULL);
 }
 
-void test__LeaveCriticalSection__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  LeaveCriticalSection(!x);
+void test__OpenSemaphore__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    OpenSemaphore(arg1, arg2, x);
 }
 
-void test__LeaveCriticalSection__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  LeaveCriticalSection(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  LeaveCriticalSection(x);
+void test__OpenSemaphoreA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenSemaphoreA(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__OpenSemaphoreA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenSemaphoreA(arg1, x, arg3);
 }
 
-void test__lstrcat__leakignore() {
-  char *p = malloc(10); *p=0;
-  lstrcat(p, arg2);
-  // cppcheck-suppress memleak
+void test__OpenSemaphoreA__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    OpenSemaphoreA(arg1, arg2, !x);
 }
 
-void test__lstrcat__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  lstrcat(p, arg2);
+void test__OpenSemaphoreA__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    OpenSemaphoreA(arg1, arg2, NULL);
 }
 
-void test__lstrcat__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  lstrcat(x, arg2);
+void test__OpenSemaphoreA__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    OpenSemaphoreA(arg1, arg2, x);
 }
 
-void test__lstrcat__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  lstrcat(arg1, p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  lstrcat(arg1, x);
+void test__OpenSemaphoreW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenSemaphoreW(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenSemaphoreW(arg1, x, arg3);
 }
 
-void test__CreateSemaphore__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphore(x, arg2, arg3, arg4);
+void test__OpenSemaphoreW__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    OpenSemaphoreW(arg1, arg2, !x);
 }
 
-void test__CreateSemaphore__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphore(arg1, x, arg3, arg4);
+void test__OpenSemaphoreW__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    OpenSemaphoreW(arg1, arg2, NULL);
 }
 
-void test__CreateSemaphore__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphore(arg1, arg2, x, arg4);
+void test__OpenSemaphoreW__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    OpenSemaphoreW(arg1, arg2, x);
 }
 
-void test__CreateSemaphore__arg4__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateSemaphore(arg1, arg2, arg3, !x);
+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__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphore(arg1, arg2, arg3, x);
+void test__ReleaseSemaphore__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ReleaseSemaphore(x, arg2, arg3);
 }
 
-void test__CreateSemaphoreA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreA(x, arg2, arg3, arg4);
+void test__ReleaseSemaphore__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    ReleaseSemaphore(arg1, !x, arg3);
 }
 
-void test__CreateSemaphoreA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreA(arg1, x, arg3, arg4);
+void test__ReleaseSemaphore__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ReleaseSemaphore(arg1, x, arg3);
 }
 
-void test__CreateSemaphoreA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreA(arg1, arg2, x, arg4);
+void test__ReleaseSemaphore__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    ReleaseSemaphore(arg1, arg2, !x);
 }
 
-void test__CreateSemaphoreA__arg4__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateSemaphoreA(arg1, arg2, arg3, !x);
+void test__ReleaseSemaphore__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ReleaseSemaphore(arg1, arg2, x);
 }
 
-void test__CreateSemaphoreA__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__CreateSemaphoreW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; CreateSemaphoreW(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__CreateMutex__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateMutex(!x, arg2, arg3);
 }
 
-void test__CreateSemaphoreW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreW(x, arg2, arg3, arg4);
+void test__CreateMutex__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutex(x, arg2, arg3);
 }
 
-void test__CreateSemaphoreW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreW(arg1, x, arg3, arg4);
+void test__CreateMutex__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutex(arg1, x, arg3);
 }
 
-void test__CreateSemaphoreW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreW(arg1, arg2, x, arg4);
+void test__CreateMutex__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateMutex(arg1, arg2, !x);
 }
 
-void test__CreateSemaphoreW__arg4__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateSemaphoreW(arg1, arg2, arg3, !x);
+void test__CreateMutex__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutex(arg1, arg2, x);
 }
 
-void test__CreateSemaphoreW__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__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__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateMutexA(!x, arg2, arg3);
 }
 
-void test__CreateSemaphoreEx__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreEx(x, arg2, arg3, arg4, arg5, arg6);
+void test__CreateMutexA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexA(x, arg2, arg3);
 }
 
-void test__CreateSemaphoreEx__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreEx(arg1, x, arg3, arg4, arg5, arg6);
+void test__CreateMutexA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexA(arg1, x, arg3);
 }
 
-void test__CreateSemaphoreEx__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreEx(arg1, arg2, x, arg4, arg5, arg6);
+void test__CreateMutexA__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateMutexA(arg1, arg2, !x);
 }
 
-void test__CreateSemaphoreEx__arg4__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateSemaphoreEx(arg1, arg2, arg3, !x, arg5, arg6);
+void test__CreateMutexA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexA(arg1, arg2, x);
 }
 
-void test__CreateSemaphoreEx__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreEx(arg1, arg2, arg3, arg4, x, arg6);
+void test__CreateMutexW__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateMutexW(!x, arg2, arg3);
 }
 
-void test__CreateSemaphoreEx__arg6__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreEx(arg1, arg2, arg3, arg4, arg5, x);
+void test__CreateMutexW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexW(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexW(arg1, x, arg3);
 }
 
-void test__CreateSemaphoreExA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreExA(x, arg2, arg3, arg4, arg5, arg6);
+void test__CreateMutexW__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateMutexW(arg1, arg2, !x);
 }
 
-void test__CreateSemaphoreExA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreExA(arg1, x, arg3, arg4, arg5, arg6);
+void test__CreateMutexW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexW(arg1, arg2, x);
 }
 
-void test__CreateSemaphoreExA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreExA(arg1, arg2, x, 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__arg4__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateSemaphoreExA(arg1, arg2, arg3, !x, arg5, arg6);
+void test__CreateMutexEx__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexEx(x, arg2, arg3, arg4);
 }
 
-void test__CreateSemaphoreExA__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreExA(arg1, arg2, arg3, arg4, x, arg6);
+void test__CreateMutexEx__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexEx(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexEx(arg1, arg2, x, arg4);
 }
 
-void test__CreateSemaphoreExW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreExW(x, arg2, arg3, arg4, arg5, arg6);
+void test__CreateMutexEx__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexEx(arg1, arg2, arg3, x);
 }
 
-void test__CreateSemaphoreExW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreExW(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreExW(arg1, arg2, x, arg4, arg5, arg6);
+void test__CreateMutexExA__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateMutexExA(!x, arg2, arg3, arg4);
 }
 
-void test__CreateSemaphoreExW__arg4__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateSemaphoreExW(arg1, arg2, arg3, !x, arg5, arg6);
+void test__CreateMutexExA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexExA(x, arg2, arg3, arg4);
 }
 
-void test__CreateSemaphoreExW__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreExW(arg1, arg2, arg3, x, arg5, arg6);
+void test__CreateMutexExA__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexExA(arg1, x, arg3, arg4);
 }
 
-void test__CreateSemaphoreExW__arg6__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateSemaphoreExW(arg1, arg2, arg3, arg4, arg5, x);
+void test__CreateMutexExA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexExA(arg1, arg2, x, arg4);
 }
 
-void test__OpenSemaphore__noreturn() {
-  int x = 1;
-  if (cond) { x=100; OpenSemaphore(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__CreateMutexExA__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexExA(arg1, arg2, arg3, x);
 }
 
-void test__OpenSemaphore__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenSemaphore(x, arg2, 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__OpenSemaphore__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenSemaphore(arg1, x, arg3);
+void test__CreateMutexExW__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateMutexExW(!x, arg2, arg3, arg4);
 }
 
-void test__OpenSemaphore__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  OpenSemaphore(arg1, arg2, !x);
+void test__CreateMutexExW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexExW(x, arg2, arg3, arg4);
 }
 
-void test__OpenSemaphore__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  OpenSemaphore(arg1, arg2, p);
+void test__CreateMutexExW__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    CreateMutexExW(arg1, !x, arg3, arg4);
 }
 
-void test__OpenSemaphore__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  OpenSemaphore(arg1, arg2, x);
+void test__CreateMutexExW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexExW(arg1, x, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexExW(arg1, arg2, x, arg4);
 }
 
-void test__OpenSemaphoreA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenSemaphoreA(x, arg2, arg3);
+void test__CreateMutexExW__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    CreateMutexExW(arg1, arg2, arg3, x);
 }
 
-void test__OpenSemaphoreA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenSemaphoreA(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__OpenSemaphoreA__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  OpenSemaphoreA(arg1, arg2, !x);
+void test__OpenMutex__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenMutex(x, arg2, arg3);
 }
 
-void test__OpenSemaphoreA__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  OpenSemaphoreA(arg1, arg2, p);
+void test__OpenMutex__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenMutex(arg1, x, arg3);
 }
 
-void test__OpenSemaphoreA__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  OpenSemaphoreA(arg1, arg2, x);
+void test__OpenMutex__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    OpenMutex(arg1, arg2, !x);
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    OpenMutex(arg1, arg2, NULL);
 }
 
-void test__OpenSemaphoreW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenSemaphoreW(x, arg2, arg3);
+void test__OpenMutex__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    OpenMutex(arg1, arg2, x);
 }
 
-void test__OpenSemaphoreW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenSemaphoreW(arg1, x, 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__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  OpenSemaphoreW(arg1, arg2, !x);
+void test__OpenMutexA__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenMutexA(x, arg2, arg3);
 }
 
-void test__OpenSemaphoreW__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  OpenSemaphoreW(arg1, arg2, p);
+void test__OpenMutexA__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenMutexA(arg1, x, arg3);
 }
 
-void test__OpenSemaphoreW__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  OpenSemaphoreW(arg1, arg2, x);
+void test__OpenMutexA__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    OpenMutexA(arg1, arg2, !x);
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    OpenMutexA(arg1, arg2, NULL);
 }
 
-void test__ReleaseSemaphore__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  ReleaseSemaphore(!x, arg2, arg3);
+void test__OpenMutexA__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    OpenMutexA(arg1, arg2, x);
 }
 
-void test__ReleaseSemaphore__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  ReleaseSemaphore(arg1, !x, arg3);
+void test__OpenMutexW__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenMutexW(x, arg2, arg3);
 }
 
-void test__ReleaseSemaphore__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ReleaseSemaphore(arg1, x, arg3);
+void test__OpenMutexW__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    OpenMutexW(arg1, x, arg3);
 }
 
-void test__ReleaseSemaphore__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  ReleaseSemaphore(arg1, arg2, !x);
+void test__OpenMutexW__arg3__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    OpenMutexW(arg1, arg2, !x);
 }
 
-void test__ReleaseSemaphore__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ReleaseSemaphore(arg1, arg2, x);
+void test__OpenMutexW__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    OpenMutexW(arg1, arg2, NULL);
 }
 
-void test__CreateMutex__noreturn() {
-  int x = 1;
-  if (cond) { x=100; CreateMutex(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__OpenMutexW__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    OpenMutexW(arg1, arg2, x);
 }
 
-void test__CreateMutex__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateMutex(!x, arg2, arg3);
+void test__ReleaseMutex__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        ReleaseMutex(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__CreateMutex__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutex(x, arg2, arg3);
+void test__ReleaseMutex__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    ReleaseMutex(p);
+    // cppcheck-suppress memleak
 }
 
-void test__CreateMutex__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutex(arg1, x, arg3);
+void test__ReleaseMutex__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    ReleaseMutex(!x);
 }
 
-void test__CreateMutex__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateMutex(arg1, arg2, !x);
+void test__ReleaseMutex__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ReleaseMutex(x);
 }
 
-void test__CreateMutex__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__CreateMutexA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; CreateMutexA(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateMutexA(!x, arg2, arg3);
+void test___alloca__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _alloca(arg1);
 }
 
-void test__CreateMutexA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutexA(x, arg2, arg3);
+void test___alloca__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _alloca(x);
 }
-
-void test__CreateMutexA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutexA(arg1, x, arg3);
+
+void test___freea__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        _freea(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__CreateMutexA__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateMutexA(arg1, arg2, !x);
+void test___freea__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    _freea(x);
 }
 
-void test__CreateMutexA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__CreateMutexW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; CreateMutexW(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateMutexW(!x, arg2, arg3);
+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__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutexW(x, arg2, arg3);
+void test__GetLastError__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    GetLastError();
 }
 
-void test__CreateMutexW__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutexW(arg1, x, 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__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateMutexW(arg1, arg2, !x);
+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__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__AllocateAndInitializeSid__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    AllocateAndInitializeSid(NULL);
 }
 
-void test__CreateMutexEx__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateMutexEx(!x, arg2, arg3, arg4);
+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__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  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__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateMutexEx(arg1, !x, arg3, arg4);
+void test__HeapAlloc__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    HeapAlloc(x, arg2, arg3);
 }
 
-void test__CreateMutexEx__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutexEx(arg1, x, arg3, arg4);
+void test__HeapAlloc__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    HeapAlloc(arg1, x, arg3);
 }
 
-void test__CreateMutexEx__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutexEx(arg1, arg2, x, arg4);
+void test__HeapAlloc__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    HeapAlloc(arg1, arg2, x);
 }
 
-void test__CreateMutexEx__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutexEx(arg1, arg2, arg3, x);
+void test__HeapReAlloc__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        HeapReAlloc(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    HeapReAlloc(x, arg2, arg3, arg4);
 }
 
-void test__CreateMutexExA__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateMutexExA(!x, arg2, arg3, arg4);
+void test__HeapReAlloc__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    HeapReAlloc(arg1, x, arg3, arg4);
 }
 
-void test__CreateMutexExA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutexExA(x, arg2, arg3, arg4);
+void test__HeapReAlloc__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    HeapReAlloc(arg1, arg2, NULL, arg4);
 }
 
-void test__CreateMutexExA__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateMutexExA(arg1, !x, arg3, arg4);
+void test__HeapReAlloc__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    HeapReAlloc(arg1, arg2, x, arg4);
 }
 
-void test__CreateMutexExA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutexExA(arg1, x, arg3, arg4);
+void test__HeapReAlloc__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    HeapReAlloc(arg1, arg2, arg3, x);
 }
 
-void test__CreateMutexExA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutexExA(arg1, arg2, x, 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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutexExA(arg1, arg2, arg3, x);
+void test__HeapFree__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    HeapFree(x, arg2, 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__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    HeapFree(arg1, x, arg3);
 }
 
-void test__CreateMutexExW__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateMutexExW(!x, arg2, arg3, arg4);
+void test__HeapFree__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    HeapFree(arg1, arg2, NULL);
 }
 
-void test__CreateMutexExW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutexExW(x, arg2, arg3, arg4);
+void test__HeapFree__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    HeapFree(arg1, arg2, x);
 }
 
-void test__CreateMutexExW__arg2__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  CreateMutexExW(arg1, !x, 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__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutexExW(arg1, x, arg3, arg4);
+void test__HeapSize__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    HeapSize(arg1, arg2, arg3);
 }
 
-void test__CreateMutexExW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutexExW(arg1, arg2, x, arg4);
+void test__HeapSize__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = HeapSize(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__CreateMutexExW__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  CreateMutexExW(arg1, arg2, arg3, x);
+void test__HeapSize__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = HeapSize(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__HeapSize__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = HeapSize(arg1, x, arg3);
 }
 
-void test__OpenMutex__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenMutex(x, arg2, arg3);
+void test__HeapSize__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = HeapSize(arg1, arg2, x);
 }
 
-void test__OpenMutex__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenMutex(arg1, x, 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__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  OpenMutex(arg1, arg2, !x);
+void test__HeapValidate__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    HeapValidate(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__OpenMutex__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  OpenMutex(arg1, arg2, p);
+void test__HeapValidate__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    HeapValidate(x, arg2, arg3);
 }
 
-void test__OpenMutex__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  OpenMutex(arg1, arg2, x);
+void test__HeapValidate__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    HeapValidate(arg1, x, arg3);
 }
 
-void test__OpenMutexA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; OpenMutexA(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__HeapValidate__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    HeapValidate(arg1, arg2, x);
 }
 
-void test__OpenMutexA__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenMutexA(x, arg2, arg3);
+void test__GetProcessHeap__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = GetProcessHeap();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__OpenMutexA__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenMutexA(arg1, x, arg3);
+void test__GetProcessHeap__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    GetProcessHeap();
 }
 
-void test__OpenMutexA__arg3__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  OpenMutexA(arg1, arg2, !x);
+void test__GetUserName__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        GetUserName(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__OpenMutexA__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  OpenMutexA(arg1, arg2, p);
+void test__GetUserName__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetUserName(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__OpenMutexA__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  OpenMutexA(arg1, arg2, x);
+void test__GetUserName__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetUserName(arg1, NULL);
 }
 
-void test__OpenMutexW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; OpenMutexW(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetUserName__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetUserName(arg1, x);
 }
 
-void test__OpenMutexW__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  OpenMutexW(x, arg2, arg3);
+void test__GetUserNameA__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        GetUserNameA(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
-
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetUserNameA(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__OpenMutexW__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  OpenMutexW(arg1, arg2, p);
+void test__GetUserNameA__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetUserNameA(arg1, NULL);
 }
 
-void test__OpenMutexW__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  OpenMutexW(arg1, arg2, x);
+void test__GetUserNameA__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetUserNameA(arg1, x);
 }
 
-void test__ReleaseMutex__noreturn() {
-  int x = 1;
-  if (cond) { x=100; ReleaseMutex(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetUserNameW__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        GetUserNameW(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__ReleaseMutex__leakignore() {
-  char *p = malloc(10); *p=0;
-  ReleaseMutex(p);
-  // cppcheck-suppress memleak
+void test__GetUserNameW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetUserNameW(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__ReleaseMutex__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  ReleaseMutex(!x);
+void test__GetUserNameW__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetUserNameW(arg1, NULL);
 }
 
-void test__ReleaseMutex__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  ReleaseMutex(x);
+void test__GetUserNameW__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    GetUserNameW(arg1, x);
 }
 
-void test___malloca__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _malloca(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___malloca__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _malloca(x);
+void test__GetWindowText__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetWindowText(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test___alloca__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = _alloca(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetWindowText__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetWindowText(NULL, arg2, arg3);
 }
 
-void test___alloca__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _alloca(arg1);
+void test__GetWindowText__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetWindowText(arg1, NULL, arg3);
 }
 
-void test___alloca__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _alloca(x);
+void test__GetWindowText__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetWindowText(arg1, arg2, x);
 }
 
-void test___freea__noreturn() {
-  int x = 1;
-  if (cond) { x=100; _freea(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  _freea(x);
+void test__GetWindowTextA__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetWindowTextA(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__strlwr__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strlwr(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetWindowTextA__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetWindowTextA(NULL, arg2, arg3);
 }
 
-void test__strlwr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strlwr(p);
+void test__GetWindowTextA__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetWindowTextA(arg1, NULL, arg3);
 }
 
-void test__strlwr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strlwr(x);
+void test__GetWindowTextA__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetWindowTextA(arg1, arg2, x);
 }
 
-void test__strupr__noreturn() {
-  int x = 1;
-  if (cond) { x=100; strupr(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  strupr(p);
+void test__GetWindowTextW__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    GetWindowTextW(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__strupr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  strupr(x);
+void test__GetWindowTextW__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetWindowTextW(NULL, arg2, arg3);
 }
 
-void test__GetLocalTime__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GetLocalTime(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__GetWindowTextW__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    GetWindowTextW(arg1, NULL, arg3);
 }
 
-void test__GetLocalTime__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetLocalTime(p);
-  // cppcheck-suppress memleak
+void test__GetWindowTextW__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    GetWindowTextW(arg1, arg2, x);
 }
 
-void test__GetLocalTime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetLocalTime(p);
+void test__socket__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        socket(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__GetSystemTime__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GetSystemTime(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__socket__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    socket(x, arg2, arg3);
 }
 
-void test__GetSystemTime__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetSystemTime(p);
-  // cppcheck-suppress memleak
+void test__socket__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    socket(arg1, x, arg3);
 }
 
-void test__GetSystemTime__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetSystemTime(p);
+void test__socket__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    socket(arg1, arg2, x);
 }
 
-void test__GetLastError__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = GetLastError(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__closesocket__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        closesocket(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__GetLastError__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  GetLastError();
+void test__closesocket__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    closesocket(x);
 }
 
-void test__SetLastError__noreturn() {
-  int x = 1;
-  if (cond) { x=100; SetLastError(arg1); }
-  // 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__SetLastError__leakignore() {
-  char *p = malloc(10); *p=0;
-  SetLastError(p);
-  // cppcheck-suppress memleak
+void test__accept__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    accept(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__SetLastError__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  SetLastError(x);
+void test__accept__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    accept(x, arg2, arg3);
 }
 
-void test__AllocateAndInitializeSid__noreturn() {
-  int x = 1;
-  if (cond) { x=100; AllocateAndInitializeSid(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__accept__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    accept(arg1, x, arg3);
 }
 
-void test__AllocateAndInitializeSid__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  AllocateAndInitializeSid(p);
+void test__accept__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    accept(arg1, arg2, x);
 }
 
-void test__AllocateAndInitializeSid__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  AllocateAndInitializeSid(p);
+void test__bind__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        bind(arg1, arg2, arg3);
+    }
+    // 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__bind__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    bind(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__FreeSid__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  FreeSid(x);
+void test__bind__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    bind(x, arg2, 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__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    bind(arg1, NULL, arg3);
 }
 
-void test__HeapAlloc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  HeapAlloc(x, arg2, arg3);
+void test__bind__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    bind(arg1, arg2, x);
 }
 
-void test__HeapAlloc__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  HeapAlloc(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  HeapAlloc(arg1, arg2, x);
+void test__connect__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    connect(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    connect(x, arg2, arg3);
 }
 
-void test__HeapReAlloc__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  HeapReAlloc(x, arg2, arg3, arg4);
+void test__connect__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    connect(arg1, NULL, arg3);
 }
 
-void test__HeapReAlloc__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  HeapReAlloc(arg1, x, arg3, arg4);
+void test__connect__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    connect(arg1, arg2, x);
 }
 
-void test__HeapReAlloc__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  HeapReAlloc(arg1, arg2, p, 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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  HeapReAlloc(arg1, arg2, x, arg4);
+void test__getpeername__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    getpeername(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-void test__HeapReAlloc__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  HeapReAlloc(arg1, arg2, arg3, x);
+void test__getpeername__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    getpeername(x, arg2, 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__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getpeername(arg1, NULL, arg3);
 }
 
-void test__HeapFree__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  HeapFree(x, arg2, arg3);
+void test__getpeername__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getpeername(arg1, arg2, NULL);
 }
 
-void test__HeapFree__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  HeapFree(arg1, x, arg3);
+void test__getpeername__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    getpeername(arg1, arg2, x);
 }
 
-void test__HeapFree__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  HeapFree(arg1, arg2, p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  HeapFree(arg1, arg2, x);
+void test__getsockname__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    getsockname(p, arg2, arg3);
+    // cppcheck-suppress memleak
 }
 
-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__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    getsockname(x, arg2, arg3);
 }
 
-void test__HeapSize__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  HeapSize(arg1, arg2, arg3);
+void test__getsockname__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getsockname(arg1, NULL, arg3);
 }
 
-void test__HeapSize__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = HeapSize(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__getsockname__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getsockname(arg1, arg2, NULL);
 }
 
-void test__HeapSize__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = HeapSize(x, arg2, arg3);
+void test__getsockname__arg3__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    getsockname(arg1, arg2, x);
 }
 
-void test__HeapSize__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = HeapSize(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = HeapSize(arg1, arg2, x);
+void test__getsockopt__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    getsockopt(p, arg2, arg3, arg4, arg5);
+    // cppcheck-suppress memleak
 }
 
-void test__HeapValidate__noreturn() {
-  int x = 1;
-  if (cond) { x=100; HeapValidate(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getsockopt__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    getsockopt(x, arg2, arg3, arg4, arg5);
 }
 
-void test__HeapValidate__leakignore() {
-  char *p = malloc(10); *p=0;
-  HeapValidate(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__getsockopt__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    getsockopt(arg1, x, arg3, arg4, arg5);
 }
 
-void test__HeapValidate__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  HeapValidate(x, arg2, arg3);
+void test__getsockopt__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    getsockopt(arg1, arg2, x, arg4, arg5);
 }
 
-void test__HeapValidate__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  HeapValidate(arg1, x, arg3);
+void test__getsockopt__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getsockopt(arg1, arg2, arg3, NULL, arg5);
 }
 
-void test__HeapValidate__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  HeapValidate(arg1, arg2, x);
+void test__getsockopt__arg5__notnull()
+{
+    // cppcheck-suppress nullPointer
+    getsockopt(arg1, arg2, arg3, arg4, NULL);
 }
 
-void test__GetProcessHeap__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = GetProcessHeap(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__getsockopt__arg5__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    getsockopt(arg1, arg2, arg3, arg4, x);
 }
 
-void test__GetProcessHeap__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  GetProcessHeap();
+void test__htonl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = htonl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__GetUserName__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GetUserName(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__htonl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    htonl(arg1);
 }
 
-void test__GetUserName__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetUserName(p, arg2);
-  // cppcheck-suppress memleak
+void test__htonl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = htonl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__GetUserName__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetUserName(arg1, p);
+void test__htonl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = htonl(x);
 }
 
-void test__GetUserName__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetUserName(arg1, x);
+void test__htons__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = htons(arg1);
+    }
+    // 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__htons__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    htons(arg1);
 }
 
-void test__GetUserNameA__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetUserNameA(p, arg2);
-  // cppcheck-suppress memleak
+void test__htons__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = htons(p);
+    // cppcheck-suppress memleak
 }
 
-void test__GetUserNameA__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetUserNameA(arg1, p);
+void test__htons__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = htons(x);
 }
 
-void test__GetUserNameA__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetUserNameA(arg1, 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__GetUserNameW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GetUserNameW(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__inet_addr__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    inet_addr(arg1);
 }
 
-void test__GetUserNameW__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetUserNameW(p, arg2);
-  // cppcheck-suppress memleak
+void test__inet_addr__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = inet_addr(p);
+    // cppcheck-suppress memleak
 }
 
-void test__GetUserNameW__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetUserNameW(arg1, p);
+void test__inet_addr__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = inet_addr(NULL);
 }
 
-void test__GetUserNameW__arg2__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  GetUserNameW(arg1, x);
+void test__inet_addr__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = inet_addr(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = inet_ntoa(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__inet_ntoa__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    inet_ntoa(arg1);
 }
 
-void test__GetWindowText__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetWindowText(p, arg2, arg3);
+void test__inet_ntoa__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = inet_ntoa(p);
+    // cppcheck-suppress memleak
 }
 
-void test__GetWindowText__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetWindowText(arg1, p, arg3);
+void test__inet_ntoa__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = inet_ntoa(x);
 }
 
-void test__GetWindowText__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetWindowText(arg1, arg2, x);
+void test__ioctlsocket__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        ioctlsocket(arg1, arg2, arg3);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__GetWindowTextA__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GetWindowTextA(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__GetWindowTextA__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetWindowTextA(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__ioctlsocket__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ioctlsocket(x, arg2, arg3);
 }
 
-void test__GetWindowTextA__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetWindowTextA(p, arg2, arg3);
+void test__ioctlsocket__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    ioctlsocket(arg1, x, arg3);
 }
 
-void test__GetWindowTextA__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetWindowTextA(arg1, p, arg3);
+void test__ioctlsocket__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    ioctlsocket(arg1, arg2, NULL);
 }
 
-void test__GetWindowTextA__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetWindowTextA(arg1, arg2, x);
+void test__listen__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        listen(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__GetWindowTextW__noreturn() {
-  int x = 1;
-  if (cond) { x=100; GetWindowTextW(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__listen__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    listen(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__GetWindowTextW__leakignore() {
-  char *p = malloc(10); *p=0;
-  GetWindowTextW(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__listen__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    listen(x, arg2);
 }
 
-void test__GetWindowTextW__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetWindowTextW(p, arg2, arg3);
+void test__listen__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    listen(arg1, x);
 }
 
-void test__GetWindowTextW__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  GetWindowTextW(arg1, p, arg3);
+void test__ntohl__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ntohl(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__GetWindowTextW__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  GetWindowTextW(arg1, arg2, x);
+void test__ntohl__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ntohl(arg1);
 }
 
-void test__socket__noreturn() {
-  int x = 1;
-  if (cond) { x=100; socket(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ntohl__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ntohl(p);
+    // cppcheck-suppress memleak
 }
 
-void test__socket__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  socket(x, arg2, arg3);
+void test__ntohl__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ntohl(x);
 }
 
-void test__socket__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  socket(arg1, x, arg3);
+void test__ntohs__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = ntohs(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__socket__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  socket(arg1, arg2, x);
+void test__ntohs__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    ntohs(arg1);
 }
 
-void test__closesocket__noreturn() {
-  int x = 1;
-  if (cond) { x=100; closesocket(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__ntohs__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = ntohs(p);
+    // cppcheck-suppress memleak
 }
 
-void test__closesocket__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  closesocket(x);
+void test__ntohs__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = ntohs(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        recv(arg1, arg2, arg3, arg4);
+    }
+    // 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__recv__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    recv(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__accept__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  accept(x, arg2, arg3);
+void test__recv__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    recv(x, arg2, arg3, arg4);
 }
 
-void test__accept__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  accept(arg1, x, arg3);
+void test__recv__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    recv(arg1, NULL, arg3, arg4);
 }
 
-void test__accept__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  accept(arg1, arg2, x);
+void test__recv__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    recv(arg1, arg2, x, arg4);
 }
 
-void test__bind__noreturn() {
-  int x = 1;
-  if (cond) { x=100; bind(arg1, arg2, arg3); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__recv__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    recv(arg1, arg2, arg3, x);
 }
 
-void test__bind__leakignore() {
-  char *p = malloc(10); *p=0;
-  bind(p, arg2, arg3);
-  // cppcheck-suppress memleak
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  bind(x, arg2, arg3);
+void test__recvfrom__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    recvfrom(p, arg2, arg3, arg4, arg5, arg6);
+    // cppcheck-suppress memleak
 }
 
-void test__bind__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  bind(arg1, p, arg3);
+void test__recvfrom__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    recvfrom(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__bind__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  bind(arg1, arg2, x);
+void test__recvfrom__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    recvfrom(arg1, NULL, arg3, 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__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    recvfrom(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__connect__leakignore() {
-  char *p = malloc(10); *p=0;
-  connect(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__recvfrom__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    recvfrom(arg1, arg2, arg3, x, arg5, arg6);
 }
 
-void test__connect__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  connect(x, arg2, arg3);
+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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  connect(arg1, p, arg3);
+void test__select__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    select(p, arg2, arg3, arg4, arg5);
+    // cppcheck-suppress memleak
 }
 
-void test__connect__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  connect(arg1, arg2, x);
+void test__select__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    select(arg1, arg2, arg3, arg4, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        send(arg1, arg2, arg3, arg4);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getpeername__leakignore() {
-  char *p = malloc(10); *p=0;
-  getpeername(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__send__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    send(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__getpeername__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  getpeername(x, arg2, arg3);
+void test__send__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    send(x, arg2, arg3, arg4);
 }
 
-void test__getpeername__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getpeername(arg1, p, arg3);
+void test__send__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    send(arg1, NULL, arg3, arg4);
 }
 
-void test__getpeername__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getpeername(arg1, arg2, p);
+void test__send__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    send(arg1, arg2, x, arg4);
 }
 
-void test__getpeername__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  getpeername(arg1, arg2, x);
+void test__send__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    send(arg1, arg2, arg3, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        sendto(arg1, arg2, arg3, arg4, arg5, arg6);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__getsockname__leakignore() {
-  char *p = malloc(10); *p=0;
-  getsockname(p, arg2, arg3);
-  // cppcheck-suppress memleak
+void test__sendto__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    sendto(p, arg2, arg3, arg4, arg5, arg6);
+    // cppcheck-suppress memleak
 }
 
-void test__getsockname__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  getsockname(x, arg2, arg3);
+void test__sendto__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sendto(x, arg2, arg3, arg4, arg5, arg6);
 }
 
-void test__getsockname__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getsockname(arg1, p, arg3);
+void test__sendto__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    sendto(arg1, NULL, arg3, arg4, arg5, arg6);
 }
 
-void test__getsockname__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getsockname(arg1, arg2, p);
+void test__sendto__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sendto(arg1, arg2, x, arg4, arg5, arg6);
 }
 
-void test__getsockname__arg3__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  getsockname(arg1, arg2, x);
+void test__sendto__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sendto(arg1, arg2, arg3, x, arg5, 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__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sendto(arg1, arg2, arg3, arg4, x, arg6);
 }
 
-void test__getsockopt__leakignore() {
-  char *p = malloc(10); *p=0;
-  getsockopt(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
+void test__sendto__arg6__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    sendto(arg1, arg2, arg3, arg4, arg5, x);
 }
 
-void test__getsockopt__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  getsockopt(x, arg2, arg3, arg4, arg5);
+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__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  getsockopt(arg1, x, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  getsockopt(arg1, arg2, x, arg4, arg5);
+void test__setsockopt__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    setsockopt(x, arg2, arg3, arg4, arg5);
 }
 
-void test__getsockopt__arg4__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getsockopt(arg1, arg2, arg3, p, arg5);
+void test__setsockopt__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    setsockopt(arg1, x, arg3, arg4, arg5);
 }
 
-void test__getsockopt__arg5__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  getsockopt(arg1, arg2, arg3, arg4, p);
+void test__setsockopt__arg3__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    setsockopt(arg1, arg2, x, arg4, arg5);
 }
 
-void test__getsockopt__arg5__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  getsockopt(arg1, arg2, arg3, arg4, x);
+void test__setsockopt__arg4__notnull()
+{
+    // cppcheck-suppress nullPointer
+    setsockopt(arg1, arg2, arg3, NULL, arg5);
 }
 
-void test__htonl__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = htonl(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__setsockopt__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    setsockopt(arg1, arg2, arg3, arg4, x);
 }
 
-void test__htonl__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  htonl(arg1);
+void test__shutdown__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        shutdown(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__shutdown__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    shutdown(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__htonl__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = htonl(x);
+void test__shutdown__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    shutdown(x, arg2);
 }
-
-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__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__inet_addr__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  inet_addr(arg1);
+void test__WSAStartup__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    WSAStartup(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__inet_addr__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = inet_addr(p);
-  // cppcheck-suppress memleak
+void test__WSAStartup__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    WSAStartup(x, arg2);
 }
 
-void test__inet_addr__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = inet_addr(p);
+void test__WSAStartup__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    WSAStartup(arg1, NULL);
 }
 
-void test__inet_addr__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  result = inet_addr(x);
+void test__WSACleanup__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        WSACleanup();
+    }
+    // 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = WSAGetLastError();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__inet_ntoa__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  inet_ntoa(arg1);
+void test__WSAGetLastError__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    WSAGetLastError();
 }
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  ioctlsocket(arg1, arg2, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  recv(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  recvfrom(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  send(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  sendto(arg1, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  setsockopt(arg1, arg2, arg3, p, 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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  WSAStartup(arg1, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  result = _fileno(p);
-}
-
-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__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___tolower__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _tolower(x);
+void test__WSASetLastError__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    WSASetLastError(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _fileno(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___tolower_l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _tolower_l(arg1, arg2);
+void test___fileno__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _fileno(arg1);
 }
 
-void test___tolower_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _tolower_l(p, arg2);
-  // cppcheck-suppress memleak
+void test___fileno__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _fileno(p);
+    // cppcheck-suppress memleak
 }
 
-void test___tolower_l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _tolower_l(x, arg2);
+void test___fileno__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    result = _fileno(!x);
 }
 
-void test___tolower_l__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _tolower_l(arg1, x);
+void test___fileno__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    result = _fileno(NULL);
 }
 
-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___fileno__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    result = _fileno(x);
 }
 
-void test___towlower_l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _towlower_l(arg1, arg2);
+void test___tolower__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _tolower(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___towlower_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _towlower_l(p, arg2);
-  // cppcheck-suppress memleak
+void test___tolower__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _tolower(arg1);
 }
 
-void test___towlower_l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _towlower_l(x, arg2);
+void test___tolower__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _tolower(p);
+    // cppcheck-suppress memleak
 }
 
-void test___towlower_l__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _towlower_l(arg1, x);
+void test___tolower__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _tolower(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _tolower_l(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___toupper__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _toupper(arg1);
+void test___tolower_l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _tolower_l(arg1, arg2);
 }
 
-void test___toupper__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _toupper(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___toupper__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _toupper(x);
+void test___tolower_l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _tolower_l(x, arg2);
 }
 
-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___tolower_l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _tolower_l(arg1, x);
 }
 
-void test___toupper_l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _toupper_l(arg1, arg2);
+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__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _toupper_l(p, arg2);
-  // cppcheck-suppress memleak
+void test___towlower_l__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _towlower_l(arg1, arg2);
 }
 
-void test___toupper_l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _toupper_l(x, arg2);
+void test___towlower_l__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _towlower_l(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test___toupper_l__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _toupper_l(arg1, x);
+void test___towlower_l__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _towlower_l(x, arg2);
 }
 
-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___towlower_l__arg2__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _towlower_l(arg1, x);
 }
 
-void test___towupper_l__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  _towupper_l(arg1, arg2);
+void test___toupper__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = _toupper(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test___towupper_l__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = _towupper_l(p, arg2);
-  // cppcheck-suppress memleak
+void test___toupper__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    _toupper(arg1);
 }
 
-void test___towupper_l__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _towupper_l(x, arg2);
+void test___toupper__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = _toupper(p);
+    // cppcheck-suppress memleak
 }
 
-void test___towupper_l__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = _towupper_l(arg1, x);
+void test___toupper__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = _toupper(x);
 }
 
-void test____noop__noreturn() {
-  int x = 1;
-  if (cond) { x=100; __noop(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__leakignore() {
-  char *p = malloc(10); *p=0;
-  __noop();
-  // cppcheck-suppress memleak
+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____nop__noreturn() {
-  int x = 1;
-  if (cond) { x=100; __nop(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+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;
 }
 
diff --git a/test/cfg/generated-cfg-tests-wxwidgets.cpp b/test/cfg/generated-cfg-tests-wxwidgets.cpp
index 1c4545877..78abb97c8 100644
--- a/test/cfg/generated-cfg-tests-wxwidgets.cpp
+++ b/test/cfg/generated-cfg-tests-wxwidgets.cpp
@@ -8,2260 +8,3056 @@
 // => '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__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wxString::Format(!x);
+}
+
+void test__wxString__Format__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wxString::Format(NULL);
 }
 
-void test__wxString__Format__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxString::Format(p);
+void test__wxString__Format__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wxString::Format(x);
 }
 
-void test__wxString__Format__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wxString::Format(x);
+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__Printf__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxString::Printf(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__arg1__notbool() {
-  // cppcheck-suppress invalidFunctionArgBool
-  wxString::Printf(!x);
-}
-
-void test__wxString__Printf__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxString::Printf(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxLogMessage(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxLogVerbose(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxLogWarning(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxLogFatalError(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxLogError(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxLogTrace(arg1, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxLogDebug(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxLogSysError(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxLogGeneric(arg1, p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxLogInfo(p);
-}
-
-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() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxTimer::SetOwner(p, 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__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__wxTextFile__GetLine__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wxTextFile::GetLine(arg1);
+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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wxTextFile::GetLine(x);
+void test__wxLogMessage__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wxLogMessage(p);
+    // cppcheck-suppress memleak
 }
 
-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__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wxLogMessage(!x);
 }
 
-void test__wxSizer__AddSpacer__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxSizer::AddSpacer(x);
+void test__wxLogMessage__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wxLogMessage(NULL);
 }
-
-void test__wxBoxSizer__AddSpacer__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxBoxSizer::AddSpacer(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+
+void test__wxLogMessage__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wxLogMessage(x);
 }
 
-void test__wxBoxSizer__AddSpacer__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxBoxSizer::AddSpacer(x);
+void test__wxLogVerbose__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wxLogVerbose(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wxBoxSizer__CalcMin__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxBoxSizer::CalcMin(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxLogVerbose__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wxLogVerbose(p);
+    // cppcheck-suppress memleak
 }
 
-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__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wxLogVerbose(!x);
 }
 
-void test__wxBoxSizer__GetOrientation__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wxBoxSizer::GetOrientation();
+void test__wxLogVerbose__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wxLogVerbose(NULL);
 }
 
-void test__wxBoxSizer__RecalcSizes__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxBoxSizer::RecalcSizes(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxLogVerbose__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wxLogVerbose(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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wxLogWarning(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wxBoxSizer__SetOrientation__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxBoxSizer::SetOrientation(x);
+void test__wxLogWarning__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wxLogWarning(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wxStaticBoxSizer__CalcMin__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxStaticBoxSizer::CalcMin(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxLogWarning__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wxLogWarning(!x);
 }
 
-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__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wxLogWarning(NULL);
 }
 
-void test__wxStaticBoxSizer__GetStaticBox__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wxStaticBoxSizer::GetStaticBox();
+void test__wxLogWarning__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wxLogWarning(x);
 }
 
-void test__wxStaticBoxSizer__RecalcSizes__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxStaticBoxSizer::RecalcSizes(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxLogFatalError__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wxLogFatalError(arg1);
+    }
+    // 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__wxLogFatalError__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wxLogFatalError(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wxMenu__Append__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxMenu::Append(x, arg2, arg3, arg4);
+void test__wxLogFatalError__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wxLogFatalError(!x);
 }
 
-void test__wxMenu__Append__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxMenu::Append(arg1, arg2, arg3, x);
+void test__wxLogFatalError__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wxLogFatalError(NULL);
 }
 
-void test__wxLaunchDefaultBrowser__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxLaunchDefaultBrowser(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxLogFatalError__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wxLogFatalError(x);
 }
 
-void test__wxLaunchDefaultBrowser__leakignore() {
-  char *p = malloc(10); *p=0;
-  wxLaunchDefaultBrowser(p, arg2);
-  // cppcheck-suppress memleak
+void test__wxLogError__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wxLogError(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wxLaunchDefaultBrowser__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxLaunchDefaultBrowser(x, arg2);
+void test__wxLogError__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wxLogError(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wxLaunchDefaultBrowser__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxLaunchDefaultBrowser(arg1, x);
+void test__wxLogError__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wxLogError(!x);
 }
 
-void test__wxDirExists__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wxDirExists(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxLogError__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wxLogError(NULL);
 }
 
-void test__wxDirExists__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wxDirExists(arg1);
+void test__wxLogError__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wxLogError(x);
 }
 
-void test__wxDirExists__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wxDirExists(p);
-  // cppcheck-suppress memleak
+void test__wxLogTrace__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wxLogTrace(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wxDirExists__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wxDirExists(x);
+void test__wxLogTrace__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wxLogTrace(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__wxFileExists__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wxFileExists(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxLogTrace__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wxLogTrace(arg1, !x);
 }
 
-void test__wxFileExists__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wxFileExists(arg1);
+void test__wxLogTrace__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wxLogTrace(arg1, NULL);
 }
 
-void test__wxFileExists__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wxFileExists(p);
-  // cppcheck-suppress memleak
+void test__wxLogTrace__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wxLogTrace(arg1, x);
 }
 
-void test__wxFileExists__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wxFileExists(x);
+void test__wxLogDebug__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wxLogDebug(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wxGetWorkingDirectory__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxGetWorkingDirectory(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxLogDebug__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wxLogDebug(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wxGetWorkingDirectory__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxGetWorkingDirectory(arg1, x);
+void test__wxLogDebug__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wxLogDebug(!x);
 }
 
-void test__wxGetCwd__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wxGetCwd(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxLogDebug__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wxLogDebug(NULL);
 }
 
-void test__wxGetCwd__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wxGetCwd();
+void test__wxLogDebug__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wxLogDebug(x);
 }
 
-void test__wxSetWorkingDirectory__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxSetWorkingDirectory(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxLogSysError__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wxLogSysError(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wxSetWorkingDirectory__leakignore() {
-  char *p = malloc(10); *p=0;
-  wxSetWorkingDirectory(p);
-  // cppcheck-suppress memleak
+void test__wxLogSysError__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wxLogSysError(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wxSetWorkingDirectory__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxSetWorkingDirectory(x);
+void test__wxLogSysError__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wxLogSysError(!x);
 }
 
-void test__wxMkdir__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxMkdir(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxLogSysError__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wxLogSysError(NULL);
 }
 
-void test__wxMkdir__leakignore() {
-  char *p = malloc(10); *p=0;
-  wxMkdir(p, arg2);
-  // cppcheck-suppress memleak
+void test__wxLogSysError__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wxLogSysError(x);
 }
 
-void test__wxMkdir__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxMkdir(x, arg2);
+void test__wxLogGeneric__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wxLogGeneric(arg1, arg2);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wxMkdir__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxMkdir(arg1, x);
+void test__wxLogGeneric__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wxLogGeneric(p, arg2);
+    // cppcheck-suppress memleak
 }
 
-void test__wxRmdir__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxRmdir(arg1, arg2); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxLogGeneric__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wxLogGeneric(x, arg2);
 }
 
-void test__wxRmdir__leakignore() {
-  char *p = malloc(10); *p=0;
-  wxRmdir(p, arg2);
-  // cppcheck-suppress memleak
+void test__wxLogGeneric__arg2__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wxLogGeneric(arg1, !x);
 }
 
-void test__wxRmdir__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxRmdir(x, arg2);
+void test__wxLogGeneric__arg2__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wxLogGeneric(arg1, NULL);
 }
 
-void test__wxRmdir__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxRmdir(arg1, x);
+void test__wxLogGeneric__arg2__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wxLogGeneric(arg1, 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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wxLogInfo(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wxGetTranslation__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wxGetTranslation(arg1, arg2, arg3, arg4);
+void test__wxLogInfo__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wxLogInfo(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wxGetTranslation__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wxGetTranslation(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
+void test__wxLogInfo__arg1__notbool()
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    wxLogInfo(!x);
 }
 
-void test__wxGetTranslation__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wxGetTranslation(x, arg2, arg3, arg4);
+void test__wxLogInfo__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wxLogInfo(NULL);
 }
 
-void test__wxGetTranslation__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wxGetTranslation(arg1, x, arg3, arg4);
+void test__wxLogInfo__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wxLogInfo(x);
 }
 
-void test__wxGetTranslation__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wxGetTranslation(arg1, arg2, x, 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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wxGetTranslation(arg1, arg2, arg3, x);
+void test__wxSpinCtrl__GetMax__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wxSpinCtrl::GetMax();
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wxSpinCtrl::GetMin();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wxApp__MacOpenFile__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxApp::MacOpenFile(x);
+void test__wxSpinCtrl__GetMin__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wxSpinCtrl::GetMin();
 }
 
-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__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wxSpinCtrl::GetBase();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wxArtProvider__Insert__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxArtProvider::Insert(p);
+void test__wxSpinCtrl__GetBase__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wxSpinCtrl::GetBase();
 }
 
-void test__wxArtProvider__Insert__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wxArtProvider::Insert(x);
+void test__wxSpinCtrl__GetValue__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wxSpinCtrl::GetValue();
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
-
-void test__wxCalendarCtrl__EnableYearChange__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxCalendarCtrl::EnableYearChange(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+
+void test__wxSpinCtrl__GetValue__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wxSpinCtrl::GetValue();
 }
 
-void test__wxCalendarCtrl__EnableYearChange__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxCalendarCtrl::EnableYearChange(x);
+void test__wxSpinCtrl__SetBase__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wxSpinCtrl::SetBase(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-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__pure(int arg1)
+{
+    // cppcheck-suppress incorrectLogicOperator
+    if ((wxSpinCtrl::SetBase(arg1) > 10) || (wxSpinCtrl::SetBase(arg1) < 100)) {}
 }
 
-void test__wxComboCtrl__GetTextIndent__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wxComboCtrl::GetTextIndent();
+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__HidePopup__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxComboCtrl::HidePopup(arg1); }
-  // 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__wxComboCtrl__HidePopup__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxComboCtrl::HidePopup(x);
+
+void test__wxRadioBox__IsItemEnabled__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wxRadioBox::IsItemEnabled(arg1);
 }
-
-void test__wxComboCtrl__ShowPopup__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxComboCtrl::ShowPopup(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__SetTextIndent__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxComboCtrl::SetTextIndent(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__wxComboCtrl__SetTextIndent__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxComboCtrl::SetTextIndent(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__wxDataViewCustomRenderer__Activate__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxDataViewCustomRenderer::Activate(arg1, arg2, arg3, arg4); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << 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__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxDataViewCustomRenderer::Activate(x, arg2, arg3, arg4);
+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__arg2__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxDataViewCustomRenderer::Activate(arg1, p, 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__arg3__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxDataViewCustomRenderer::Activate(arg1, arg2, x, 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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxDataViewCustomRenderer::Activate(arg1, arg2, arg3, 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__wxGetTranslation__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wxGetTranslation(arg1, arg2, arg3, arg4);
 }
 
-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__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wxGetTranslation(p, arg2, arg3, arg4);
+    // cppcheck-suppress memleak
 }
 
-void test__wxDataViewCustomRenderer__LeftClick__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxDataViewCustomRenderer::LeftClick(x, arg2, arg3, arg4, arg5);
+void test__wxGetTranslation__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = wxGetTranslation(x, arg2, arg3, arg4);
 }
 
-void test__wxDataViewCustomRenderer__LeftClick__arg2__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxDataViewCustomRenderer::LeftClick(arg1, x, 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__arg3__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxDataViewCustomRenderer::LeftClick(arg1, arg2, p, 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__arg4__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, x, arg5);
+void test__wxDataViewCustomRenderer__LeftClick__arg3__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wxDataViewCustomRenderer::LeftClick(arg1, arg2, NULL, arg4, arg5);
 }
 
-void test__wxDataViewCustomRenderer__LeftClick__arg5__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, arg4, x);
+void test__wxDataViewCustomRenderer__LeftClick__arg4__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, x, arg5);
 }
 
-void test__wxDebugContext__GetLevel__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wxDebugContext::GetLevel(); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxDataViewCustomRenderer__LeftClick__arg5__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, arg4, x);
 }
 
-void test__wxDebugContext__GetLevel__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wxDebugContext::GetLevel();
+void test__wxDebugContext__GetLevel__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wxDebugContext::GetLevel();
+    }
+    // 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__GetLevel__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wxDebugContext::GetLevel();
 }
 
-void test__wxDebugContext__SetLevel__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  wxDebugContext::SetLevel(x);
+void test__wxDebugContext__SetLevel__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wxDebugContext::SetLevel(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__wxDebugContext__SetLevel__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    wxDebugContext::SetLevel(x);
 }
 
-void test__wxDos2UnixFilename__leakignore() {
-  char *p = malloc(10); *p=0;
-  wxDos2UnixFilename(p);
-  // cppcheck-suppress memleak
+void test__wxDos2UnixFilename__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        wxDos2UnixFilename(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wxDos2UnixFilename__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxDos2UnixFilename(p);
+void test__wxDos2UnixFilename__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    wxDos2UnixFilename(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wxDos2UnixFilename__arg1__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wxDos2UnixFilename(x);
+void test__wxDos2UnixFilename__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wxDos2UnixFilename(NULL);
 }
 
-void test__wxFileNameFromPath__noreturn() {
-  int x = 1;
-  if (cond) { x=100; result = wxFileNameFromPath(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxDos2UnixFilename__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wxDos2UnixFilename(x);
 }
 
-void test__wxFileNameFromPath__useretval() {
-  // cppcheck-suppress ignoredReturnValue
-  wxFileNameFromPath(arg1);
+void test__wxFileNameFromPath__noreturn()
+{
+    int x = 1;
+    if (cond) {
+        x=100;
+        result = wxFileNameFromPath(arg1);
+    }
+    // cppcheck-suppress shiftTooManyBits
+    x = 1 << x;
 }
 
-void test__wxFileNameFromPath__leakignore() {
-  char *p = malloc(10); *p=0;
-  result = wxFileNameFromPath(p);
-  // cppcheck-suppress memleak
+void test__wxFileNameFromPath__useretval()
+{
+    // cppcheck-suppress ignoredReturnValue
+    wxFileNameFromPath(arg1);
 }
 
-void test__wxFileNameFromPath__arg1__notuninit() {
-  int x;
-  // cppcheck-suppress uninitvar
-  result = wxFileNameFromPath(x);
+void test__wxFileNameFromPath__leakignore()
+{
+    char *p = malloc(10);
+    *p=0;
+    result = wxFileNameFromPath(p);
+    // cppcheck-suppress memleak
 }
 
-void test__wxSizerItem__SetWindow__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxSizerItem::SetWindow(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxFileNameFromPath__arg1__notuninit()
+{
+    int x;
+    // cppcheck-suppress uninitvar
+    result = wxFileNameFromPath(x);
 }
 
-void test__wxSizerItem__SetWindow__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxSizerItem::SetWindow(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wxSizerItem::SetWindow(x);
+void test__wxSizerItem__SetWindow__arg1__notnull()
+{
+    // cppcheck-suppress nullPointer
+    wxSizerItem::SetWindow(NULL);
 }
 
-void test__wxSizerItem__SetSizer__noreturn() {
-  int x = 1;
-  if (cond) { x=100; wxSizerItem::SetSizer(arg1); }
-  // cppcheck-suppress shiftTooManyBits
-  x = 1 << x;
+void test__wxSizerItem__SetWindow__arg1__notuninit()
+{
+    int x[10];
+    // cppcheck-suppress uninitvar
+    wxSizerItem::SetWindow(x);
 }
 
-void test__wxSizerItem__SetSizer__arg1__notnull() {
-  const char *p = NULL;
-  // cppcheck-suppress nullPointer
-  wxSizerItem::SetSizer(p);
+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__notuninit() {
-  int x[10];
-  // cppcheck-suppress uninitvar
-  wxSizerItem::SetSizer(x);
+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__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);
 }
 
diff --git a/tools/generate_cfg_tests.cpp b/tools/generate_cfg_tests.cpp
index ab5a0bb1e..8a7989007 100644
--- a/tools/generate_cfg_tests.cpp
+++ b/tools/generate_cfg_tests.cpp
@@ -43,10 +43,10 @@ int main(int argc, char **argv)
         return 1;
     }
 
-	std::string testfile(cfgfile);
-	if (testfile.find('/') != std::string::npos)
-		testfile = testfile.substr(testfile.rfind('/')+1);
-	testfile = "generated-cfg-tests-" + testfile.substr(0,testfile.find('.')) + ".cpp";
+    std::string testfile(cfgfile);
+    if (testfile.find('/') != std::string::npos)
+        testfile = testfile.substr(testfile.rfind('/')+1);
+    testfile = "generated-cfg-tests-" + testfile.substr(0,testfile.find('.')) + ".cpp";
 
     std::cout << "// auto generated tests from " << cfgfile << std::endl;
     std::cout << "//" << std::endl;
@@ -192,7 +192,7 @@ static void testfunction(const tinyxml2::XMLElement *node, const std::string &fu
             }
 
             if (notnull) {
-                std::cout << testFunctionArg(functionName, useretval, "notnull", argNr, numberOfArgs, "const char *p = NULL;", "nullPointer", "p") << std::endl << std::endl;
+                std::cout << testFunctionArg(functionName, useretval, "notnull", argNr, numberOfArgs, "", "nullPointer", "NULL") << std::endl << std::endl;
             }
 
             if (notuninit) {