diff --git a/test/cfg/generate-cfg-tests.sh b/test/cfg/generate-cfg-tests.sh
new file mode 100755
index 000000000..3162f1c5b
--- /dev/null
+++ b/test/cfg/generate-cfg-tests.sh
@@ -0,0 +1,14 @@
+#!/bin/bash
+cd ~/cppcheck
+make generate_cfg_tests
+./generate_cfg_tests cfg/avr.cfg > test/cfg/generated-cfg-tests-avr.cpp
+./generate_cfg_tests cfg/bsd.cfg > test/cfg/generated-cfg-tests-bsd.cpp
+./generate_cfg_tests cfg/gnu.cfg > test/cfg/generated-cfg-tests-gnu.cpp
+./generate_cfg_tests cfg/motif.cfg > test/cfg/generated-cfg-tests-motif.cpp
+./generate_cfg_tests cfg/posix.cfg > test/cfg/generated-cfg-tests-posix.cpp
+./generate_cfg_tests cfg/qt.cfg > test/cfg/generated-cfg-tests-qt.cpp
+./generate_cfg_tests cfg/sdl.cfg > test/cfg/generated-cfg-tests-sdl.cpp
+./generate_cfg_tests cfg/sfml.cfg > test/cfg/generated-cfg-tests-sfml.cpp
+./generate_cfg_tests cfg/std.cfg > test/cfg/generated-cfg-tests-std.cpp
+./generate_cfg_tests cfg/windows.cfg > test/cfg/generated-cfg-tests-windows.cpp
+./generate_cfg_tests cfg/wxwidgets.cfg > test/cfg/generated-cfg-tests-wxwidgets.cpp
diff --git a/test/cfg/generated-cfg-tests-avr.cpp b/test/cfg/generated-cfg-tests-avr.cpp
new file mode 100644
index 000000000..89d918714
--- /dev/null
+++ b/test/cfg/generated-cfg-tests-avr.cpp
@@ -0,0 +1,606 @@
+// auto generated tests from cfg/avr.cfg
+//
+// Generated by command:
+// ./generate_cfg_tests cfg/avr.cfg > generated-cfg-tests-avr.cpp
+//
+// Recommended cppcheck command line:
+// $ cppcheck --enable=warning,information --inline-suppr generated-cfg-tests-avr.cpp
+// => 'unmatched suppression' warnings are false negatives.
+//
+
+void test__toascii__noreturn() {
+  int x = 100;
+  if (cond) x=1; else toascii(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__toascii__leakignore() {
+  char *p = strdup(str);
+  toascii(p);
+  // cppcheck-suppress memleak
+}
+
+void test__vfprintf_P__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vfprintf_P(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vfprintf_P__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else printf_P(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__printf_P__leakignore() {
+  char *p = strdup(str);
+  printf_P(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sprintf_P__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sprintf_P(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sprintf_P__leakignore() {
+  char *p = strdup(str);
+  sprintf_P(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__snprintf_P__noreturn() {
+  int x = 100;
+  if (cond) x=1; else snprintf_P(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__snprintf_P__leakignore() {
+  char *p = strdup(str);
+  snprintf_P(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__vsprintf_P__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vsprintf_P(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vsprintf_P__leakignore() {
+  char *p = strdup(str);
+  vsprintf_P(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__vsnprintf_P__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vsnprintf_P(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vsnprintf_P__leakignore() {
+  char *p = strdup(str);
+  vsnprintf_P(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__fprintf_P__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fprintf_P(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fprintf_P__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else fputs_P(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fputs_P__leakignore() {
+  char *p = strdup(str);
+  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__fputs_P__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fputs_P(arg1, x);
+}
+
+void test__puts_P__noreturn() {
+  int x = 100;
+  if (cond) x=1; else puts_P(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__puts_P__leakignore() {
+  char *p = strdup(str);
+  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__puts_P__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  puts_P(x);
+}
+
+void test__scanf_P__noreturn() {
+  int x = 100;
+  if (cond) x=1; else scanf_P(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__scanf_P__leakignore() {
+  char *p = strdup(str);
+  scanf_P(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__scanf_P__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  scanf_P(x, arg2);
+}
+
+void test__fscanf_P__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fscanf_P(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fscanf_P__leakignore() {
+  char *p = strdup(str);
+  fscanf_P(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fscanf_P__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fscanf_P(x, arg2);
+}
+
+void test__sscanf_P__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sscanf_P(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sscanf_P__leakignore() {
+  char *p = strdup(str);
+  sscanf_P(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fdevopen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fdevopen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fdevopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fdevopen(NULL, arg2);
+}
+
+void test__fdevopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fdevopen(x, arg2);
+}
+
+void test__fdevopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fdevopen(arg1, NULL);
+}
+
+void test__fdevopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fdevopen(arg1, x);
+}
+
+void test__ltoa__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ltoa(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ltoa__leakignore() {
+  char *p = strdup(str);
+  ltoa(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__ltoa__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ltoa(x, arg2, arg3);
+}
+
+void test__ltoa__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  ltoa(arg1, NULL, arg3);
+}
+
+void test__ltoa__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ltoa(arg1, x, arg3);
+}
+
+void test__ltoa__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  ltoa(arg1, arg2, NULL);
+}
+
+void test__ltoa__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ltoa(arg1, arg2, x);
+}
+
+void test__utoa__noreturn() {
+  int x = 100;
+  if (cond) x=1; else utoa(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__utoa__leakignore() {
+  char *p = strdup(str);
+  utoa(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__utoa__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  utoa(x, arg2, arg3);
+}
+
+void test__utoa__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  utoa(arg1, NULL, arg3);
+}
+
+void test__utoa__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  utoa(arg1, x, arg3);
+}
+
+void test__utoa__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  utoa(arg1, arg2, NULL);
+}
+
+void test__utoa__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  utoa(arg1, arg2, x);
+}
+
+void test__ultoa__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ultoa(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ultoa__leakignore() {
+  char *p = strdup(str);
+  ultoa(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__ultoa__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ultoa(x, arg2, arg3);
+}
+
+void test__ultoa__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  ultoa(arg1, NULL, arg3);
+}
+
+void test__ultoa__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ultoa(arg1, x, arg3);
+}
+
+void test__ultoa__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  ultoa(arg1, arg2, NULL);
+}
+
+void test__ultoa__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ultoa(arg1, arg2, x);
+}
+
+void test__random__noreturn() {
+  int x = 100;
+  if (cond) x=1; else random();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__random__leakignore() {
+  char *p = strdup(str);
+  random();
+  // cppcheck-suppress memleak
+}
+
+void test__random_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else random_r(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__random_r__leakignore() {
+  char *p = strdup(str);
+  random_r(p);
+  // cppcheck-suppress memleak
+}
+
+void test__random_r__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  random_r(NULL);
+}
+
+void test__srandom__noreturn() {
+  int x = 100;
+  if (cond) x=1; else srandom(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__srandom__leakignore() {
+  char *p = strdup(str);
+  srandom(p);
+  // cppcheck-suppress memleak
+}
+
+void test__srandom__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  srandom(x);
+}
+
+void test__dtostre__noreturn() {
+  int x = 100;
+  if (cond) x=1; else dtostre(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__dtostre__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else dtostrf(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__dtostrf__leakignore() {
+  char *p = strdup(str);
+  dtostrf(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__dtostrf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dtostrf(x, arg2, arg3, arg4);
+}
+
+void test__dtostrf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dtostrf(arg1, x, arg3, arg4);
+}
+
+void test__dtostrf__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dtostrf(arg1, arg2, x, arg4);
+}
+
+void test__dtostrf__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  dtostrf(arg1, arg2, arg3, NULL);
+}
+
+void test__ffs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ffs(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ffs__leakignore() {
+  char *p = strdup(str);
+  ffs(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ffs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ffs(x);
+}
+
+void test__ffsl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ffsl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ffsl__leakignore() {
+  char *p = strdup(str);
+  ffsl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ffsl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ffsl(x);
+}
+
+void test__ffsll__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ffsll(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ffsll__leakignore() {
+  char *p = strdup(str);
+  ffsll(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ffsll__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ffsll(x);
+}
+
+void test__memccpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else memccpy(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__memccpy__leakignore() {
+  char *p = strdup(str);
+  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__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
new file mode 100644
index 000000000..053055e50
--- /dev/null
+++ b/test/cfg/generated-cfg-tests-bsd.cpp
@@ -0,0 +1,256 @@
+// auto generated tests from cfg/bsd.cfg
+//
+// Generated by command:
+// ./generate_cfg_tests cfg/bsd.cfg > generated-cfg-tests-bsd.cpp
+//
+// Recommended cppcheck command line:
+// $ cppcheck --enable=warning,information --inline-suppr generated-cfg-tests-bsd.cpp
+// => 'unmatched suppression' warnings are false negatives.
+//
+
+void test__fts_open__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fts_open(arg1, x, arg3);
+}
+
+void test__fts_open__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  fts_open(arg1, arg2, NULL);
+}
+
+void test__fts_open__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fts_open(arg1, arg2, x);
+}
+
+void test__fts_read__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fts_read(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fts_read__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fts_read(NULL);
+}
+
+void test__fts_read__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fts_read(x);
+}
+
+void test__readpassphrase__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  readpassphrase(arg1, x);
+}
+
+void test__fts_set__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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_clientptr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fts_set_clientptr(arg1, x);
+}
+
+void test__fts_get_clientptr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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_stream__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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_close__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__readpassphrase__noreturn() {
+  int x = 100;
+  if (cond) x=1; else readpassphrase(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__readpassphrase__leakignore() {
+  char *p = strdup(str);
+  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__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  readpassphrase(arg1, NULL, arg3, arg4);
+}
+
+void test__readpassphrase__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  readpassphrase(arg1, arg2, NULL, arg4);
+}
+
+void test__readpassphrase__arg3__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__setfib__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setfib(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setfib__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setfib(x);
+}
+
+void test__strtonum__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strtonum(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strtonum__leakignore() {
+  char *p = strdup(str);
+  strtonum(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__strtonum__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtonum(NULL, arg2, arg3, arg4);
+}
+
+void test__strtonum__arg1__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__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);
+}
+
diff --git a/test/cfg/generated-cfg-tests-gnu.cpp b/test/cfg/generated-cfg-tests-gnu.cpp
new file mode 100644
index 000000000..510ce52ff
--- /dev/null
+++ b/test/cfg/generated-cfg-tests-gnu.cpp
@@ -0,0 +1,1501 @@
+// auto generated tests from cfg/gnu.cfg
+//
+// Generated by command:
+// ./generate_cfg_tests cfg/gnu.cfg > generated-cfg-tests-gnu.cpp
+//
+// Recommended cppcheck command line:
+// $ cppcheck --enable=warning,information --inline-suppr generated-cfg-tests-gnu.cpp
+// => 'unmatched suppression' warnings are false negatives.
+//
+
+void test__accept__noreturn() {
+  int x = 100;
+  if (cond) x=1; else accept(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__accept__leakignore() {
+  char *p = strdup(str);
+  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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  accept(arg1, x, arg3, arg4);
+}
+
+void test__accept__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  accept(arg1, arg2, NULL, arg4);
+}
+
+void test__accept__arg3__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__atoq__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = atoq(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__atoq__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  atoq(arg1);
+}
+
+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__strndupa__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strndupa(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strndupa__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strndupa(arg1, arg2);
+}
+
+void test__strndupa__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strndupa(NULL, arg2);
+}
+
+void test__strndupa__arg1__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__strsep__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strsep(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__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__strdupa__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strdupa(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strdupa__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strdupa(arg1);
+}
+
+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__backtrace__noreturn() {
+  int x = 100;
+  if (cond) x=1; else backtrace(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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_symbols__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = backtrace_symbols(arg1, x);
+}
+
+void test__backtrace_symbols_fd__noreturn() {
+  int x = 100;
+  if (cond) x=1; else backtrace_symbols_fd(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__backtrace_symbols_fd__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  backtrace_symbols_fd(NULL, arg2, arg3);
+}
+
+void test__backtrace_symbols_fd__arg1__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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  backtrace_symbols_fd(arg1, arg2, x);
+}
+
+void test__ecvt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ecvt(arg1, x, arg3, arg4);
+}
+
+void test__ecvt__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  ecvt(arg1, arg2, NULL, arg4);
+}
+
+void test__ecvt__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  ecvt(arg1, arg2, arg3, NULL);
+}
+
+void test__qfcvt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qfcvt(arg1, x, arg3, arg4);
+}
+
+void test__qfcvt__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  qfcvt(arg1, arg2, NULL, arg4);
+}
+
+void test__qfcvt__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  qfcvt(arg1, arg2, arg3, NULL);
+}
+
+void test__qgcvt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qgcvt(arg1, x, arg3);
+}
+
+void test__qgcvt__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  qgcvt(arg1, arg2, NULL);
+}
+
+void test__ecvt_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  ecvt_r(arg1, arg2, NULL, arg4, arg5, arg6);
+}
+
+void test__ecvt_r__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  ecvt_r(arg1, arg2, arg3, NULL, arg5, arg6);
+}
+
+void test__ecvt_r__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__fcvt_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  fcvt_r(arg1, arg2, NULL, arg4, arg5, arg6);
+}
+
+void test__fcvt_r__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  fcvt_r(arg1, arg2, arg3, NULL, arg5, arg6);
+}
+
+void test__fcvt_r__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__qecvt_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  qecvt_r(arg1, arg2, NULL, arg4, arg5, arg6);
+}
+
+void test__qecvt_r__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  qecvt_r(arg1, arg2, arg3, NULL, arg5, arg6);
+}
+
+void test__qecvt_r__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__qfcvt_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  qfcvt_r(arg1, arg2, NULL, arg4, arg5, arg6);
+}
+
+void test__qfcvt_r__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  qfcvt_r(arg1, arg2, arg3, NULL, arg5, arg6);
+}
+
+void test__qfcvt_r__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__strcasestr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strcasestr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = strcasestr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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__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__getresuid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  getresuid(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__getresuid__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getresuid(NULL, arg2, arg3);
+}
+
+void test__getresuid__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getresuid(arg1, NULL, arg3);
+}
+
+void test__getresuid__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  getresuid(arg1, arg2, NULL);
+}
+
+void test__getresgid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  getresgid(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__getresgid__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getresgid(NULL, arg2, arg3);
+}
+
+void test__getresgid__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getresgid(arg1, NULL, arg3);
+}
+
+void test__getresgid__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  getresgid(arg1, arg2, NULL);
+}
+
+void test__setresuid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setresuid(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setresuid__leakignore() {
+  char *p = strdup(str);
+  setresuid(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setresuid(arg1, arg2, x);
+}
+
+void test__setresgid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setresgid(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setresgid__leakignore() {
+  char *p = strdup(str);
+  setresgid(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setresgid(arg1, arg2, x);
+}
+
+void test__inet_aton__noreturn() {
+  int x = 100;
+  if (cond) x=1; else inet_aton(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__inet_aton__leakignore() {
+  char *p = strdup(str);
+  inet_aton(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__inet_aton__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  inet_aton(NULL, arg2);
+}
+
+void test__inet_aton__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  inet_aton(x, arg2);
+}
+
+void test__inet_aton__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  inet_aton(arg1, NULL);
+}
+
+void test__inet_addr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else inet_addr(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__inet_addr__leakignore() {
+  char *p = strdup(str);
+  inet_addr(p);
+  // cppcheck-suppress memleak
+}
+
+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_network__noreturn() {
+  int x = 100;
+  if (cond) x=1; else inet_network(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__inet_network__leakignore() {
+  char *p = strdup(str);
+  inet_network(p);
+  // cppcheck-suppress memleak
+}
+
+void test__inet_network__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  inet_network(NULL);
+}
+
+void test__inet_network__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  inet_network(x);
+}
+
+void test__inet_ntoa__noreturn() {
+  int x = 100;
+  if (cond) x=1; else inet_ntoa(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__inet_ntoa__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else inet_makeaddr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__inet_makeaddr__leakignore() {
+  char *p = strdup(str);
+  inet_makeaddr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__inet_makeaddr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  inet_makeaddr(x, arg2);
+}
+
+void test__inet_makeaddr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  inet_makeaddr(arg1, x);
+}
+
+void test__inet_lnaof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else inet_lnaof(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__inet_lnaof__leakignore() {
+  char *p = strdup(str);
+  inet_lnaof(p);
+  // cppcheck-suppress memleak
+}
+
+void test__inet_lnaof__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  inet_lnaof(x);
+}
+
+void test__inet_netof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else inet_netof(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__inet_netof__leakignore() {
+  char *p = strdup(str);
+  inet_netof(p);
+  // cppcheck-suppress memleak
+}
+
+void test__inet_netof__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  inet_netof(x);
+}
+
+void test__inet_pton__noreturn() {
+  int x = 100;
+  if (cond) x=1; else inet_pton(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__inet_pton__leakignore() {
+  char *p = strdup(str);
+  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__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__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  inet_pton(arg1, arg2, NULL);
+}
+
+void test__inet_ntop__noreturn() {
+  int x = 100;
+  if (cond) x=1; else inet_ntop(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__inet_ntop__leakignore() {
+  char *p = strdup(str);
+  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__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__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__canonicalize_file_name__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = canonicalize_file_name(p);
+  // cppcheck-suppress memleak
+}
+
+void test__canonicalize_file_name__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = canonicalize_file_name(NULL);
+}
+
+void test__execvpe__noreturn() {
+  int x = 100;
+  if (cond) x=1; else execvpe(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__execvpe__leakignore() {
+  char *p = strdup(str);
+  execvpe(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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__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__mkostemp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mkostemp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mkostemp__leakignore() {
+  char *p = strdup(str);
+  mkostemp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mkostemp(arg1, x);
+}
+
+void test__mkstemps__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mkstemps(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mkstemps__leakignore() {
+  char *p = strdup(str);
+  mkstemps(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mkstemps(arg1, x);
+}
+
+void test__mkostemps__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mkostemps(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mkostemps__leakignore() {
+  char *p = strdup(str);
+  mkostemps(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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__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__memmem__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = memmem(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__memmem__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = memmem(NULL, arg2, arg3, arg4);
+}
+
+void test__memmem__arg1__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__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__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = memmem(arg1, arg2, arg3, x);
+}
+
+void test__memrchr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else memrchr(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__memrchr__leakignore() {
+  char *p = strdup(str);
+  memrchr(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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__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__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  memrchr(arg1, arg2, !x);
+}
+
+void test__rawmemchr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else rawmemchr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__rawmemchr__leakignore() {
+  char *p = strdup(str);
+  rawmemchr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  rawmemchr(arg1, !x);
+}
+
+void test__rawmemchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  rawmemchr(arg1, x);
+}
+
+void test__ffsl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ffsl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ffsl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ffsl(arg1);
+}
+
+void test__ffsl__leakignore() {
+  char *p = strdup(str);
+  result = ffsl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ffsl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ffsl(x);
+}
+
+void test__ffsll__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ffsll(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ffsll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ffsll(arg1);
+}
+
+void test__ffsll__leakignore() {
+  char *p = strdup(str);
+  result = ffsll(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ffsll__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ffsll(x);
+}
+
+void test__strchrnul__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strchrnul(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strchrnul__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strchrnul(arg1, arg2);
+}
+
+void test__strchrnul__leakignore() {
+  char *p = strdup(str);
+  result = strchrnul(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strchrnul(arg1, x);
+}
+
+void test__prlimit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else prlimit(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__prlimit__leakignore() {
+  char *p = strdup(str);
+  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__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__epoll_create__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  epoll_create(x);
+}
+
+void test__epoll_create1__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  epoll_create1(x);
+}
+
+void test__epoll_ctl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__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__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__notnull() {
+  // cppcheck-suppress nullPointer
+  epoll_ctl(arg1, arg2, arg3, NULL);
+}
+
+void test__epoll_wait__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__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__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__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  epoll_wait(arg1, arg2, arg3, x);
+}
+
+void test__epoll_pwait__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__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__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__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__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);
+}
+
diff --git a/test/cfg/generated-cfg-tests-motif.cpp b/test/cfg/generated-cfg-tests-motif.cpp
new file mode 100644
index 000000000..9e4497008
--- /dev/null
+++ b/test/cfg/generated-cfg-tests-motif.cpp
@@ -0,0 +1,460 @@
+// auto generated tests from cfg/motif.cfg
+//
+// Generated by command:
+// ./generate_cfg_tests cfg/motif.cfg > generated-cfg-tests-motif.cpp
+//
+// Recommended cppcheck command line:
+// $ cppcheck --enable=warning,information --inline-suppr generated-cfg-tests-motif.cpp
+// => 'unmatched suppression' warnings are false negatives.
+//
+
+void test__MrmCloseHierarchy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else result = XmStringCreateLocalized(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XmStringCreateLocalized__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  XmStringCreateLocalized(arg1);
+}
+
+void test__XmStringCreateLocalized__leakignore() {
+  char *p = strdup(str);
+  result = XmStringCreateLocalized(p);
+  // cppcheck-suppress memleak
+}
+
+void test__XmStringCreateLocalized__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = XmStringCreateLocalized(NULL);
+}
+
+void test__XmStringCreateLocalized__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = XmStringCreateLocalized(x);
+}
+
+void test__XmStringCreateSimple__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = XmStringCreateSimple(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XmStringCreateSimple__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  XmStringCreateSimple(arg1);
+}
+
+void test__XmStringCreateSimple__leakignore() {
+  char *p = strdup(str);
+  result = XmStringCreateSimple(p);
+  // cppcheck-suppress memleak
+}
+
+void test__XmStringCreateSimple__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = XmStringCreateSimple(NULL);
+}
+
+void test__XmStringCreateSimple__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = XmStringCreateSimple(x);
+}
+
+void test__XmStringFree__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else XmStringGenerate(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XmStringGenerate__leakignore() {
+  char *p = strdup(str);
+  XmStringGenerate(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__XmTextGetString__noreturn() {
+  int x = 100;
+  if (cond) x=1; else XmTextGetString(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XmTextGetString__leakignore() {
+  char *p = strdup(str);
+  XmTextGetString(p);
+  // cppcheck-suppress memleak
+}
+
+void test__XmTextGetString__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  XmTextGetString(x);
+}
+
+void test__XmTextGetStringWcs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else XmTextGetStringWcs(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XmTextGetStringWcs__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else XtSetValues(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XtSetValues__leakignore() {
+  char *p = strdup(str);
+  XtSetValues(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__XtGetValues__noreturn() {
+  int x = 100;
+  if (cond) x=1; else XtGetValues(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XtGetValues__leakignore() {
+  char *p = strdup(str);
+  XtGetValues(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__XtSetSubvalues__noreturn() {
+  int x = 100;
+  if (cond) x=1; else XtSetSubvalues(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XtSetSubvalues__leakignore() {
+  char *p = strdup(str);
+  XtSetSubvalues(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__XtGetSubvalues__noreturn() {
+  int x = 100;
+  if (cond) x=1; else XtGetSubvalues(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XtGetSubvalues__leakignore() {
+  char *p = strdup(str);
+  XtGetSubvalues(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__XtMalloc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else XOpenDisplay(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XOpenDisplay__leakignore() {
+  char *p = strdup(str);
+  XOpenDisplay(p);
+  // cppcheck-suppress memleak
+}
+
+void test__XOpenDisplay__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  XOpenDisplay(x);
+}
+
+void test__XCloseDisplay__noreturn() {
+  int x = 100;
+  if (cond) x=1; else XCloseDisplay(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XCloseDisplay__leakignore() {
+  char *p = strdup(str);
+  XCloseDisplay(p);
+  // cppcheck-suppress memleak
+}
+
+void test__XCloseDisplay__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  XCloseDisplay(x);
+}
+
+void test__XtDatabase__noreturn() {
+  int x = 100;
+  if (cond) x=1; else XtDatabase(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XtDatabase__leakignore() {
+  char *p = strdup(str);
+  XtDatabase(p);
+  // cppcheck-suppress memleak
+}
+
+void test__XtDatabase__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  XtDatabase(x);
+}
+
+void test__XtScreenDatabase__noreturn() {
+  int x = 100;
+  if (cond) x=1; else XtScreenDatabase(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__XtScreenDatabase__leakignore() {
+  char *p = strdup(str);
+  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
new file mode 100644
index 000000000..29d52875c
--- /dev/null
+++ b/test/cfg/generated-cfg-tests-posix.cpp
@@ -0,0 +1,7346 @@
+// auto generated tests from cfg/posix.cfg
+//
+// Generated by command:
+// ./generate_cfg_tests cfg/posix.cfg > generated-cfg-tests-posix.cpp
+//
+// Recommended cppcheck command line:
+// $ cppcheck --enable=warning,information --inline-suppr generated-cfg-tests-posix.cpp
+// => 'unmatched suppression' warnings are false negatives.
+//
+
+void test__a64l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = a64l(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__a64l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  a64l(arg1);
+}
+
+void test__a64l__leakignore() {
+  char *p = strdup(str);
+  result = a64l(p);
+  // cppcheck-suppress memleak
+}
+
+void test__a64l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = a64l(NULL);
+}
+
+void test__a64l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = a64l(x);
+}
+
+void test__l64a__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = l64a(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__l64a__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  l64a(arg1);
+}
+
+void test__l64a__leakignore() {
+  char *p = strdup(str);
+  result = l64a(p);
+  // cppcheck-suppress memleak
+}
+
+void test__l64a__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = l64a(x);
+}
+
+void test__accept__noreturn() {
+  int x = 100;
+  if (cond) x=1; else accept(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__accept__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  result = access(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__access__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = access(NULL, arg2);
+}
+
+void test__access__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = access(x, arg2);
+}
+
+void test__access__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = access(arg1, x);
+}
+
+void test__adjtime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else adjtime(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__adjtime__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else gettimeofday(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__gettimeofday__leakignore() {
+  char *p = strdup(str);
+  gettimeofday(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__settimeofday__noreturn() {
+  int x = 100;
+  if (cond) x=1; else settimeofday(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__settimeofday__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else FD_CLR(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FD_CLR__leakignore() {
+  char *p = strdup(str);
+  FD_CLR(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__FD_CLR__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  FD_CLR(x, arg2);
+}
+
+void test__FD_CLR__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  FD_CLR(arg1, NULL);
+}
+
+void test__FD_ISSET__noreturn() {
+  int x = 100;
+  if (cond) x=1; else FD_ISSET(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FD_ISSET__leakignore() {
+  char *p = strdup(str);
+  FD_ISSET(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__FD_ISSET__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  FD_ISSET(x, arg2);
+}
+
+void test__FD_ISSET__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  FD_ISSET(arg1, NULL);
+}
+
+void test__FD_SET__noreturn() {
+  int x = 100;
+  if (cond) x=1; else FD_SET(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FD_SET__leakignore() {
+  char *p = strdup(str);
+  FD_SET(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__FD_SET__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  FD_SET(x, arg2);
+}
+
+void test__FD_SET__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  FD_SET(arg1, NULL);
+}
+
+void test__FD_ZERO__noreturn() {
+  int x = 100;
+  if (cond) x=1; else FD_ZERO(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FD_ZERO__leakignore() {
+  char *p = strdup(str);
+  FD_ZERO(p);
+  // cppcheck-suppress memleak
+}
+
+void test__FD_ZERO__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  FD_ZERO(NULL);
+}
+
+void test__fdatasync__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fdatasync(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fdatasync__leakignore() {
+  char *p = strdup(str);
+  fdatasync(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fdatasync__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fdatasync(x);
+}
+
+void test__fnmatch__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  result = fnmatch(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__fnmatch__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fnmatch(NULL, arg2, arg3);
+}
+
+void test__fnmatch__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fnmatch(x, arg2, arg3);
+}
+
+void test__fnmatch__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fnmatch(arg1, NULL, arg3);
+}
+
+void test__fnmatch__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fnmatch(arg1, x, arg3);
+}
+
+void test__fnmatch__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fnmatch(arg1, arg2, x);
+}
+
+void test__fsync__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fsync(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fsync__leakignore() {
+  char *p = strdup(str);
+  fsync(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fsync__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fsync(x);
+}
+
+void test__truncate__noreturn() {
+  int x = 100;
+  if (cond) x=1; else truncate(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__truncate__leakignore() {
+  char *p = strdup(str);
+  truncate(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__truncate__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  truncate(NULL, arg2);
+}
+
+void test__truncate__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  truncate(x, arg2);
+}
+
+void test__truncate__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  truncate(arg1, x);
+}
+
+void test__ftruncate__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ftruncate(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ftruncate__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else flock(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__flock__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else symlink(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__symlink__leakignore() {
+  char *p = strdup(str);
+  symlink(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__symlink__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  symlink(NULL, arg2);
+}
+
+void test__symlink__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  symlink(x, arg2);
+}
+
+void test__symlink__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  symlink(arg1, NULL);
+}
+
+void test__symlink__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  symlink(arg1, x);
+}
+
+void test__open__noreturn() {
+  int x = 100;
+  if (cond) x=1; else open(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__open__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  open(NULL, arg2, arg3);
+}
+
+void test__open__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  open(x, arg2, arg3);
+}
+
+void test__open__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  open(arg1, x, arg3);
+}
+
+void test__open__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  open(arg1, arg2, x);
+}
+
+void test__creat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = creat(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__creat__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  creat(arg1, arg2);
+}
+
+void test__creat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = creat(NULL, arg2);
+}
+
+void test__creat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = creat(x, arg2);
+}
+
+void test__creat__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = creat(arg1, x);
+}
+
+void test__sleep__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sleep(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sleep__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else usleep(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__usleep__leakignore() {
+  char *p = strdup(str);
+  usleep(p);
+  // cppcheck-suppress memleak
+}
+
+void test__usleep__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  usleep(!x);
+}
+
+void test___exit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _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 = 100;
+  if (cond) x=1; else faccessat(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__faccessat__leakignore() {
+  char *p = strdup(str);
+  faccessat(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__faccessat__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  faccessat(x, arg2, arg3, arg4);
+}
+
+void test__faccessat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  faccessat(arg1, NULL, arg3, arg4);
+}
+
+void test__faccessat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  faccessat(arg1, x, arg3, arg4);
+}
+
+void test__faccessat__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  faccessat(arg1, arg2, x, arg4);
+}
+
+void test__faccessat__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  faccessat(arg1, arg2, arg3, x);
+}
+
+void test__acct__noreturn() {
+  int x = 100;
+  if (cond) x=1; else acct(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__acct__leakignore() {
+  char *p = strdup(str);
+  acct(p);
+  // cppcheck-suppress memleak
+}
+
+void test__acct__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  acct(x);
+}
+
+void test__alarm__noreturn() {
+  int x = 100;
+  if (cond) x=1; else alarm(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__alarm__leakignore() {
+  char *p = strdup(str);
+  alarm(p);
+  // cppcheck-suppress memleak
+}
+
+void test__alarm__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  alarm(x);
+}
+
+void test__getrpcent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getrpcent();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getrpcent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getrpcent();
+}
+
+void test__getrpcent__leakignore() {
+  char *p = strdup(str);
+  result = getrpcent();
+  // cppcheck-suppress memleak
+}
+
+void test__getrpcbyname__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getrpcbyname(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getrpcbyname__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getrpcbyname(arg1);
+}
+
+void test__getrpcbyname__leakignore() {
+  char *p = strdup(str);
+  result = getrpcbyname(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getrpcbyname__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = getrpcbyname(NULL);
+}
+
+void test__getrpcbyname__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = getrpcbyname(x);
+}
+
+void test__getrpcbynumber__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getrpcbynumber(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getrpcbynumber__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getrpcbynumber(arg1);
+}
+
+void test__getrpcbynumber__leakignore() {
+  char *p = strdup(str);
+  result = getrpcbynumber(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getrpcbynumber__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getrpcbynumber(x);
+}
+
+void test__getprotoent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getprotoent();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getprotoent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getprotoent();
+}
+
+void test__getprotoent__leakignore() {
+  char *p = strdup(str);
+  result = getprotoent();
+  // cppcheck-suppress memleak
+}
+
+void test__getprotobyname__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getprotobyname(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getprotobyname__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getprotobyname(arg1);
+}
+
+void test__getprotobyname__leakignore() {
+  char *p = strdup(str);
+  result = getprotobyname(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getprotobyname__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = getprotobyname(NULL);
+}
+
+void test__getprotobyname__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = getprotobyname(x);
+}
+
+void test__getprotobynumber__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getprotobynumber(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getprotobynumber__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getprotobynumber(arg1);
+}
+
+void test__getprotobynumber__leakignore() {
+  char *p = strdup(str);
+  result = getprotobynumber(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getprotobynumber__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getprotobynumber(x);
+}
+
+void test__getservent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getservent();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getservent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getservent();
+}
+
+void test__getservent__leakignore() {
+  char *p = strdup(str);
+  result = getservent();
+  // cppcheck-suppress memleak
+}
+
+void test__getservbyname__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getservbyname(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getservbyname__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getservbyname(arg1, arg2);
+}
+
+void test__getservbyname__leakignore() {
+  char *p = strdup(str);
+  result = getservbyname(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__getservbyname__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = getservbyname(NULL, arg2);
+}
+
+void test__getservbyname__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = getservbyname(x, arg2);
+}
+
+void test__getservbyname__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getservbyname(arg1, x);
+}
+
+void test__getservbyport__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getservbyport(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getservbyport__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getservbyport(arg1, arg2);
+}
+
+void test__getservbyport__leakignore() {
+  char *p = strdup(str);
+  result = getservbyport(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__getservbyport__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getservbyport(x, arg2);
+}
+
+void test__getservbyport__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getservbyport(arg1, x);
+}
+
+void test__getnetent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getnetent();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getnetent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getnetent();
+}
+
+void test__getnetent__leakignore() {
+  char *p = strdup(str);
+  result = getnetent();
+  // cppcheck-suppress memleak
+}
+
+void test__getnetbyname__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getnetbyname(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getnetbyname__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getnetbyname(arg1);
+}
+
+void test__getnetbyname__leakignore() {
+  char *p = strdup(str);
+  result = getnetbyname(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getnetbyname__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = getnetbyname(NULL);
+}
+
+void test__getnetbyname__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = getnetbyname(x);
+}
+
+void test__getnetbyaddr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getnetbyaddr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getnetbyaddr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getnetbyaddr(arg1, arg2);
+}
+
+void test__getnetbyaddr__leakignore() {
+  char *p = strdup(str);
+  result = getnetbyaddr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__getnetbyaddr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getnetbyaddr(x, arg2);
+}
+
+void test__getnetbyaddr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getnetbyaddr(arg1, x);
+}
+
+void test__gethostent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = gethostent();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__gethostent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  gethostent();
+}
+
+void test__gethostent__leakignore() {
+  char *p = strdup(str);
+  result = gethostent();
+  // cppcheck-suppress memleak
+}
+
+void test__gethostbyname__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = gethostbyname(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__gethostbyname__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  gethostbyname(arg1);
+}
+
+void test__gethostbyname__leakignore() {
+  char *p = strdup(str);
+  result = gethostbyname(p);
+  // cppcheck-suppress memleak
+}
+
+void test__gethostbyname__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = gethostbyname(NULL);
+}
+
+void test__gethostbyname__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = gethostbyname(x);
+}
+
+void test__gethostbyname2__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = gethostbyname2(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__gethostbyname2__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  gethostbyname2(arg1, arg2);
+}
+
+void test__gethostbyname2__leakignore() {
+  char *p = strdup(str);
+  result = gethostbyname2(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__gethostbyname2__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = gethostbyname2(NULL, arg2);
+}
+
+void test__gethostbyname2__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = gethostbyname2(x, arg2);
+}
+
+void test__gethostbyname2__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = gethostbyname2(arg1, x);
+}
+
+void test__gethostbyaddr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = gethostbyaddr(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__gethostbyaddr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  gethostbyaddr(arg1, arg2, arg3);
+}
+
+void test__gethostbyaddr__leakignore() {
+  char *p = strdup(str);
+  result = gethostbyaddr(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__gethostbyaddr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = gethostbyaddr(NULL, arg2, arg3);
+}
+
+void test__gethostbyaddr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = gethostbyaddr(x, arg2, arg3);
+}
+
+void test__gethostbyaddr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = gethostbyaddr(arg1, x, arg3);
+}
+
+void test__gethostbyaddr__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = gethostbyaddr(arg1, arg2, x);
+}
+
+void test__brk__noreturn() {
+  int x = 100;
+  if (cond) x=1; else brk(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__brk__leakignore() {
+  char *p = strdup(str);
+  brk(p);
+  // cppcheck-suppress memleak
+}
+
+void test__brk__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  brk(NULL);
+}
+
+void test__sbrk__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sbrk(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sbrk__leakignore() {
+  char *p = strdup(str);
+  sbrk(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sbrk__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sbrk(x);
+}
+
+void test__closedir__noreturn() {
+  int x = 100;
+  if (cond) x=1; else closedir(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__closedir__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  closedir(!x);
+}
+
+void test__closedir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  closedir(NULL);
+}
+
+void test__closedir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  closedir(x);
+}
+
+void test__strfry__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strfry(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strfry__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strfry(NULL);
+}
+
+void test__strsep__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strsep(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strsep__leakignore() {
+  char *p = strdup(str);
+  strsep(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strsep__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strsep(NULL, arg2);
+}
+
+void test__strsep__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strsep(x, arg2);
+}
+
+void test__strsep__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strsep(arg1, NULL);
+}
+
+void test__strsep__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strsep(arg1, x);
+}
+
+void test__strdup__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strdup(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strdup__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strdup(NULL);
+}
+
+void test__strdup__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strdup(x);
+}
+
+void test__strndup__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strndup(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strndup__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strndup(NULL, arg2);
+}
+
+void test__strndup__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strndup(x, arg2);
+}
+
+void test__strndup__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strndup(arg1, x);
+}
+
+void test__wcsdup__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcsdup(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcsdup__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsdup(NULL);
+}
+
+void test__wcsdup__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsdup(x);
+}
+
+void test__mkstemp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mkstemp(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mkstemp__leakignore() {
+  char *p = strdup(str);
+  mkstemp(p);
+  // cppcheck-suppress memleak
+}
+
+void test__mkstemp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mkstemp(NULL);
+}
+
+void test__mkstemp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mkstemp(x);
+}
+
+void test__mkdtemp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mkdtemp(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mkdtemp__leakignore() {
+  char *p = strdup(str);
+  mkdtemp(p);
+  // cppcheck-suppress memleak
+}
+
+void test__mkdtemp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mkdtemp(NULL);
+}
+
+void test__mkdtemp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mkdtemp(x);
+}
+
+void test__mktemp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = mktemp(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mktemp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  mktemp(arg1);
+}
+
+void test__mktemp__leakignore() {
+  char *p = strdup(str);
+  result = mktemp(p);
+  // cppcheck-suppress memleak
+}
+
+void test__mktemp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = mktemp(NULL);
+}
+
+void test__mktemp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = mktemp(x);
+}
+
+void test__getcwd__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getcwd(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getcwd__leakignore() {
+  char *p = strdup(str);
+  getcwd(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__getcwd__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getcwd(x, arg2);
+}
+
+void test__getcwd__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getcwd(arg1, x);
+}
+
+void test__mkdir__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mkdir(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mkdir__leakignore() {
+  char *p = strdup(str);
+  mkdir(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__mkdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mkdir(NULL, arg2);
+}
+
+void test__mkdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mkdir(x, arg2);
+}
+
+void test__mkdir__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mkdir(arg1, x);
+}
+
+void test__rmdir__noreturn() {
+  int x = 100;
+  if (cond) x=1; else rmdir(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__rmdir__leakignore() {
+  char *p = strdup(str);
+  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__chdir__noreturn() {
+  int x = 100;
+  if (cond) x=1; else chdir(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__chdir__leakignore() {
+  char *p = strdup(str);
+  chdir(p);
+  // cppcheck-suppress memleak
+}
+
+void test__chdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  chdir(NULL);
+}
+
+void test__chdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  chdir(x);
+}
+
+void test__chroot__noreturn() {
+  int x = 100;
+  if (cond) x=1; else chroot(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__chroot__leakignore() {
+  char *p = strdup(str);
+  chroot(p);
+  // cppcheck-suppress memleak
+}
+
+void test__chroot__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  chroot(NULL);
+}
+
+void test__chroot__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  chroot(x);
+}
+
+void test__link__noreturn() {
+  int x = 100;
+  if (cond) x=1; else link(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__link__leakignore() {
+  char *p = strdup(str);
+  link(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__link__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  link(NULL, arg2);
+}
+
+void test__link__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  link(x, arg2);
+}
+
+void test__link__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  link(arg1, NULL);
+}
+
+void test__link__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  link(arg1, x);
+}
+
+void test__unlink__noreturn() {
+  int x = 100;
+  if (cond) x=1; else unlink(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__unlink__leakignore() {
+  char *p = strdup(str);
+  unlink(p);
+  // cppcheck-suppress memleak
+}
+
+void test__unlink__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  unlink(NULL);
+}
+
+void test__unlink__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  unlink(x);
+}
+
+void test__rename__noreturn() {
+  int x = 100;
+  if (cond) x=1; else rename(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__rename__leakignore() {
+  char *p = strdup(str);
+  rename(p);
+  // cppcheck-suppress memleak
+}
+
+void test__rename__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  rename(NULL);
+}
+
+void test__rename__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  rename(x);
+}
+
+void test__stat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else stat(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__stat__leakignore() {
+  char *p = strdup(str);
+  stat(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__stat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  stat(NULL, arg2);
+}
+
+void test__stat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  stat(x, arg2);
+}
+
+void test__stat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  stat(arg1, NULL);
+}
+
+void test__lstat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else lstat(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__lstat__leakignore() {
+  char *p = strdup(str);
+  lstat(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__lstat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  lstat(NULL, arg2);
+}
+
+void test__lstat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  lstat(x, arg2);
+}
+
+void test__lstat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  lstat(arg1, NULL);
+}
+
+void test__fstat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fstat(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fstat__leakignore() {
+  char *p = strdup(str);
+  fstat(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fstat__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fstat(x, arg2);
+}
+
+void test__fstat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fstat(arg1, NULL);
+}
+
+void test__chmod__noreturn() {
+  int x = 100;
+  if (cond) x=1; else chmod(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__chmod__leakignore() {
+  char *p = strdup(str);
+  chmod(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__chmod__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  chmod(NULL, arg2);
+}
+
+void test__chmod__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  chmod(x, arg2);
+}
+
+void test__chmod__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  chmod(arg1, x);
+}
+
+void test__fchmod__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fchmod(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fchmod__leakignore() {
+  char *p = strdup(str);
+  fchmod(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fchmod__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fchmod(x, arg2);
+}
+
+void test__fchmod__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fchmod(arg1, x);
+}
+
+void test__chown__noreturn() {
+  int x = 100;
+  if (cond) x=1; else chown(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__chown__leakignore() {
+  char *p = strdup(str);
+  chown(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__chown__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  chown(NULL, arg2, arg3);
+}
+
+void test__chown__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  chown(x, arg2, arg3);
+}
+
+void test__chown__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  chown(arg1, x, arg3);
+}
+
+void test__chown__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  chown(arg1, arg2, x);
+}
+
+void test__lchown__noreturn() {
+  int x = 100;
+  if (cond) x=1; else lchown(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__lchown__leakignore() {
+  char *p = strdup(str);
+  lchown(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__lchown__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  lchown(NULL, arg2, arg3);
+}
+
+void test__lchown__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  lchown(x, arg2, arg3);
+}
+
+void test__lchown__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  lchown(arg1, x, arg3);
+}
+
+void test__lchown__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  lchown(arg1, arg2, x);
+}
+
+void test__fchown__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fchown(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fchown__leakignore() {
+  char *p = strdup(str);
+  fchown(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__fchown__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fchown(x, arg2, arg3);
+}
+
+void test__fchown__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fchown(arg1, x, arg3);
+}
+
+void test__fchown__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fchown(arg1, arg2, x);
+}
+
+void test__times__noreturn() {
+  int x = 100;
+  if (cond) x=1; else times(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__times__leakignore() {
+  char *p = strdup(str);
+  times(p);
+  // cppcheck-suppress memleak
+}
+
+void test__times__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  times(x);
+}
+
+void test__utime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else utime(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__utime__leakignore() {
+  char *p = strdup(str);
+  utime(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__utime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  utime(NULL, arg2);
+}
+
+void test__utime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  utime(x, arg2);
+}
+
+void test__utime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  utime(arg1, x);
+}
+
+void test__utimes__noreturn() {
+  int x = 100;
+  if (cond) x=1; else utimes(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__utimes__leakignore() {
+  char *p = strdup(str);
+  utimes(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__utimes__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  utimes(NULL, arg2);
+}
+
+void test__utimes__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  utimes(x, arg2);
+}
+
+void test__utimes__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  utimes(arg1, x);
+}
+
+void test__opendir__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = opendir(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__opendir__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  opendir(arg1);
+}
+
+void test__opendir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = opendir(NULL);
+}
+
+void test__opendir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = opendir(x);
+}
+
+void test__fdopendir__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fdopendir(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fdopendir__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fdopendir(arg1);
+}
+
+void test__fdopendir__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdopendir(x);
+}
+
+void test__isatty__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isatty(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isatty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isatty(arg1);
+}
+
+void test__isatty__leakignore() {
+  char *p = strdup(str);
+  result = isatty(p);
+  // cppcheck-suppress memleak
+}
+
+void test__isatty__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isatty(x);
+}
+
+void test__popen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = popen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__popen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  popen(arg1, arg2);
+}
+
+void test__popen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = popen(NULL, arg2);
+}
+
+void test__popen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = popen(x, arg2);
+}
+
+void test__popen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = popen(arg1, NULL);
+}
+
+void test__popen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = popen(arg1, x);
+}
+
+void test__pclose__noreturn() {
+  int x = 100;
+  if (cond) x=1; else pclose(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__pclose__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  pclose(NULL);
+}
+
+void test__pclose__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  pclose(x);
+}
+
+void test__socket__noreturn() {
+  int x = 100;
+  if (cond) x=1; else socket(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__socket__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  socket(x, arg2, arg3);
+}
+
+void test__socket__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  socket(arg1, x, arg3);
+}
+
+void test__socket__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  socket(arg1, arg2, x);
+}
+
+void test__nice__noreturn() {
+  int x = 100;
+  if (cond) x=1; else nice(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__nice__leakignore() {
+  char *p = strdup(str);
+  nice(p);
+  // cppcheck-suppress memleak
+}
+
+void test__nice__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  nice(x);
+}
+
+void test__pause__noreturn() {
+  int x = 100;
+  if (cond) x=1; else pause();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__pause__leakignore() {
+  char *p = strdup(str);
+  pause();
+  // cppcheck-suppress memleak
+}
+
+void test__close__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else confstr(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__confstr__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else fpathconf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fpathconf__leakignore() {
+  char *p = strdup(str);
+  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__pathconf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else pathconf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__pathconf__leakignore() {
+  char *p = strdup(str);
+  pathconf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__pathconf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  pathconf(NULL, arg2);
+}
+
+void test__pathconf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  pathconf(x, arg2);
+}
+
+void test__pathconf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  pathconf(arg1, x);
+}
+
+void test__sysconf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sysconf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sysconf__leakignore() {
+  char *p = strdup(str);
+  sysconf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sysconf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sysconf(x);
+}
+
+void test__fdopen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fdopen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fdopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fdopen(arg1, arg2);
+}
+
+void test__fdopen__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdopen(x, arg2);
+}
+
+void test__fdopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fdopen(arg1, NULL);
+}
+
+void test__fdopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fdopen(arg1, x);
+}
+
+void test__random__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = random();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__random__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  random();
+}
+
+void test__srandom__noreturn() {
+  int x = 100;
+  if (cond) x=1; else srandom(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__rewinddir__noreturn() {
+  int x = 100;
+  if (cond) x=1; else rewinddir(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__rewinddir__leakignore() {
+  char *p = strdup(str);
+  rewinddir(p);
+  // cppcheck-suppress memleak
+}
+
+void test__rewinddir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  rewinddir(NULL);
+}
+
+void test__rewinddir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  rewinddir(x);
+}
+
+void test__seekdir__noreturn() {
+  int x = 100;
+  if (cond) x=1; else seekdir(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__seekdir__leakignore() {
+  char *p = strdup(str);
+  seekdir(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__seekdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  seekdir(NULL, arg2);
+}
+
+void test__seekdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  seekdir(x, arg2);
+}
+
+void test__seekdir__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  seekdir(arg1, x);
+}
+
+void test__rand_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else rand_r(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__rand_r__leakignore() {
+  char *p = strdup(str);
+  rand_r(p);
+  // cppcheck-suppress memleak
+}
+
+void test__rand_r__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  rand_r(NULL);
+}
+
+void test__strcasecmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strcasecmp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strcasecmp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strcasecmp(arg1, arg2) > 10) || (strcasecmp(arg1, arg2) < 100)) {}
+}
+
+void test__strcasecmp__leakignore() {
+  char *p = strdup(str);
+  strcasecmp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strcasecmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strcasecmp(NULL, arg2);
+}
+
+void test__strcasecmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strcasecmp(x, arg2);
+}
+
+void test__strcasecmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strcasecmp(arg1, NULL);
+}
+
+void test__strcasecmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strcasecmp(arg1, x);
+}
+
+void test__strncasecmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strncasecmp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << 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__strncasecmp__leakignore() {
+  char *p = strdup(str);
+  strncasecmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__strncasecmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strncasecmp(NULL, arg2, arg3);
+}
+
+void test__strncasecmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strncasecmp(x, arg2, arg3);
+}
+
+void test__strncasecmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strncasecmp(arg1, NULL, arg3);
+}
+
+void test__strncasecmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strncasecmp(arg1, x, arg3);
+}
+
+void test__strncasecmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  strncasecmp(arg1, arg2, !x);
+}
+
+void test__read__leakignore() {
+  char *p = strdup(str);
+  read(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__read__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  read(x, arg2, arg3);
+}
+
+void test__read__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  read(arg1, arg2, x);
+}
+
+void test__write__noreturn() {
+  int x = 100;
+  if (cond) x=1; else write(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__write__leakignore() {
+  char *p = strdup(str);
+  write(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__write__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  write(x, arg2, arg3);
+}
+
+void test__write__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  write(arg1, x, arg3);
+}
+
+void test__write__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  write(arg1, arg2, x);
+}
+
+void test__recv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recv(x, arg2, 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__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recvfrom(x, arg2, 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__recvmsg__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recvmsg(x, arg2, arg3);
+}
+
+void test__recvmsg__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recvmsg(arg1, arg2, x);
+}
+
+void test__send__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  send(x, arg2, 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__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendto(x, arg2, 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__sendmsg__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendmsg(x, arg2, arg3);
+}
+
+void test__sendmsg__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendmsg(arg1, x, arg3);
+}
+
+void test__sendmsg__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendmsg(arg1, arg2, x);
+}
+
+void test__mmap__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = mmap(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mmap__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  mmap(arg1, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__mmap__leakignore() {
+  char *p = strdup(str);
+  result = mmap(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__mmap__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__mmap__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap(arg1, x, arg3, arg4, arg5, arg6);
+}
+
+void test__mmap__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__mmap__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__mmap__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap(arg1, arg2, arg3, arg4, x, arg6);
+}
+
+void test__mmap__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap(arg1, arg2, arg3, arg4, arg5, x);
+}
+
+void test__mmap64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = mmap64(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mmap64__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  mmap64(arg1, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__mmap64__leakignore() {
+  char *p = strdup(str);
+  result = mmap64(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__mmap64__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap64(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__mmap64__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap64(arg1, x, arg3, arg4, arg5, arg6);
+}
+
+void test__mmap64__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap64(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__mmap64__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap64(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__mmap64__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap64(arg1, arg2, arg3, arg4, x, arg6);
+}
+
+void test__mmap64__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = mmap64(arg1, arg2, arg3, arg4, arg5, x);
+}
+
+void test__munmap__noreturn() {
+  int x = 100;
+  if (cond) x=1; else munmap(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__munmap__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  munmap(NULL, arg2);
+}
+
+void test__munmap__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  munmap(x, arg2);
+}
+
+void test__munmap__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  munmap(arg1, x);
+}
+
+void test__openlog__noreturn() {
+  int x = 100;
+  if (cond) x=1; else openlog(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__openlog__leakignore() {
+  char *p = strdup(str);
+  openlog(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__openlog__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  openlog(x, arg2, arg3);
+}
+
+void test__openlog__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  openlog(arg1, x, arg3);
+}
+
+void test__openlog__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  openlog(arg1, arg2, x);
+}
+
+void test__fcntl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fcntl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fcntl__leakignore() {
+  char *p = strdup(str);
+  fcntl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else ioctl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ioctl__leakignore() {
+  char *p = strdup(str);
+  ioctl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else syslog(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__syslog__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else vsyslog(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vsyslog__leakignore() {
+  char *p = strdup(str);
+  vsyslog(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__vsyslog__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vsyslog(x, arg2);
+}
+
+void test__getgid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getgid();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getgid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getgid();
+}
+
+void test__getegid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getegid();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getegid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getegid();
+}
+
+void test__getuid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getuid();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getuid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getuid();
+}
+
+void test__getuid__leakignore() {
+  char *p = strdup(str);
+  result = getuid();
+  // cppcheck-suppress memleak
+}
+
+void test__getsid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getsid(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getsid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getsid(arg1);
+}
+
+void test__getsid__leakignore() {
+  char *p = strdup(str);
+  result = getsid(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getsid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getsid(x);
+}
+
+void test__geteuid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = geteuid();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__geteuid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  geteuid();
+}
+
+void test__geteuid__leakignore() {
+  char *p = strdup(str);
+  result = geteuid();
+  // cppcheck-suppress memleak
+}
+
+void test__getppid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getppid();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getppid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getppid();
+}
+
+void test__getppid__leakignore() {
+  char *p = strdup(str);
+  result = getppid();
+  // cppcheck-suppress memleak
+}
+
+void test__getpid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getpid();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getpid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getpid();
+}
+
+void test__getpid__leakignore() {
+  char *p = strdup(str);
+  result = getpid();
+  // cppcheck-suppress memleak
+}
+
+void test__getpgrp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getpgrp();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getpgrp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getpgrp();
+}
+
+void test__getpgrp__leakignore() {
+  char *p = strdup(str);
+  result = getpgrp();
+  // cppcheck-suppress memleak
+}
+
+void test__getpgid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getpgid(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getpgid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getpgid(arg1);
+}
+
+void test__getpgid__leakignore() {
+  char *p = strdup(str);
+  result = getpgid(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getpgid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getpgid(x);
+}
+
+void test__setuid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = setuid(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setuid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  setuid(arg1);
+}
+
+void test__setuid__leakignore() {
+  char *p = strdup(str);
+  result = setuid(p);
+  // cppcheck-suppress memleak
+}
+
+void test__setuid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = setuid(x);
+}
+
+void test__seteuid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = seteuid(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__seteuid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  seteuid(arg1);
+}
+
+void test__seteuid__leakignore() {
+  char *p = strdup(str);
+  result = seteuid(p);
+  // cppcheck-suppress memleak
+}
+
+void test__seteuid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = seteuid(x);
+}
+
+void test__setgid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = setgid(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setgid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  setgid(arg1);
+}
+
+void test__setgid__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else result = setegid(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setegid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  setegid(arg1);
+}
+
+void test__setegid__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else pipe();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setpgrp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setpgrp();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setregid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else setfsuid(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setfsuid__leakignore() {
+  char *p = strdup(str);
+  setfsuid(p);
+  // cppcheck-suppress memleak
+}
+
+void test__setfsuid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setfsuid(x);
+}
+
+void test__setfsgid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setfsgid(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setfsgid__leakignore() {
+  char *p = strdup(str);
+  setfsgid(p);
+  // cppcheck-suppress memleak
+}
+
+void test__setfsgid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setfsgid(x);
+}
+
+void test__setsid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setsid();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getwd__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getwd(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getwd__leakignore() {
+  char *p = strdup(str);
+  getwd(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getwd__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getwd(NULL);
+}
+
+void test__htonl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else mq_open();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mq_receive__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else dbm_clearerr(arg1);
+  // 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 = 100;
+  if (cond) x=1; else dbm_close(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__dbm_close__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  dbm_close(NULL);
+}
+
+void test__dbm_close__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  dbm_close(x);
+}
+
+void test__dbm_delete__noreturn() {
+  int x = 100;
+  if (cond) x=1; else dbm_delete(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__dbm_delete__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  dbm_delete(NULL, arg2);
+}
+
+void test__dbm_delete__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  dbm_delete(x, arg2);
+}
+
+void test__dbm_delete__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dbm_delete(arg1, x);
+}
+
+void test__dbm_error__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = dbm_error(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__dbm_error__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  dbm_error(arg1);
+}
+
+void test__dbm_error__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = dbm_error(NULL);
+}
+
+void test__dbm_error__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = dbm_error(x);
+}
+
+void test__dbm_fetch__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = dbm_fetch(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__dbm_fetch__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  dbm_fetch(arg1, arg2);
+}
+
+void test__dbm_fetch__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = dbm_fetch(NULL, arg2);
+}
+
+void test__dbm_fetch__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = dbm_fetch(x, arg2);
+}
+
+void test__dbm_fetch__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = dbm_fetch(arg1, x);
+}
+
+void test__dbm_firstkey__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = dbm_firstkey(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__dbm_firstkey__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  dbm_firstkey(arg1);
+}
+
+void test__dbm_firstkey__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = dbm_firstkey(NULL);
+}
+
+void test__dbm_firstkey__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = dbm_firstkey(x);
+}
+
+void test__dbm_nextkey__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = dbm_nextkey(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__dbm_nextkey__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  dbm_nextkey(arg1);
+}
+
+void test__dbm_nextkey__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = dbm_nextkey(NULL);
+}
+
+void test__dbm_nextkey__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = dbm_nextkey(x);
+}
+
+void test__dbm_open__noreturn() {
+  int x = 100;
+  if (cond) x=1; else dbm_open(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__dbm_open__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  dbm_open(NULL, arg2, arg3);
+}
+
+void test__dbm_open__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  dbm_open(x, arg2, arg3);
+}
+
+void test__dbm_open__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dbm_open(arg1, x, arg3);
+}
+
+void test__dbm_open__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dbm_open(arg1, arg2, x);
+}
+
+void test__dbm_store__noreturn() {
+  int x = 100;
+  if (cond) x=1; else dbm_store(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__dbm_store__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  dbm_store(NULL, arg2, arg3, arg4);
+}
+
+void test__dbm_store__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  dbm_store(x, arg2, arg3, arg4);
+}
+
+void test__dbm_store__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dbm_store(arg1, x, arg3, arg4);
+}
+
+void test__dbm_store__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dbm_store(arg1, arg2, x, arg4);
+}
+
+void test__dbm_store__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  dbm_store(arg1, arg2, arg3, x);
+}
+
+void test__freeaddrinfo__noreturn() {
+  int x = 100;
+  if (cond) x=1; else freeaddrinfo(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__freeaddrinfo__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  freeaddrinfo(NULL);
+}
+
+void test__freeaddrinfo__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  freeaddrinfo(x);
+}
+
+void test__getaddrinfo__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__endhostent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else endhostent();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sethostent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else uname(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__uname__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  uname(NULL);
+}
+
+void test__endpwent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else endpwent();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getpwent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getpwent();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getpwent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getpwent();
+}
+
+void test__getpwnam__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getpwnam(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getpwnam__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getpwnam(arg1);
+}
+
+void test__getpwnam__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getpwnam(x);
+}
+
+void test__strtok_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strtok_r(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strtok_r__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strtok_r(arg1, arg2, arg3) > 10) || (strtok_r(arg1, arg2, arg3) < 100)) {}
+}
+
+void test__strtok_r__leakignore() {
+  char *p = strdup(str);
+  strtok_r(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__strtok_r__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtok_r(x, arg2, arg3);
+}
+
+void test__strtok_r__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strtok_r(arg1, NULL, arg3);
+}
+
+void test__strtok_r__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtok_r(arg1, x, arg3);
+}
+
+void test__strtok_r__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  strtok_r(arg1, arg2, NULL);
+}
+
+void test__getpwnam_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getpwnam_r(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getpwnam_r__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getpwnam_r(arg1, arg2, arg3, arg4, arg5);
+}
+
+void test__getpwnam_r__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getpwnam_r(x, arg2, arg3, arg4, arg5);
+}
+
+void test__getpwnam_r__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getpwnam_r(arg1, arg2, arg3, x, arg5);
+}
+
+void test__getpwuid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getpwuid(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getpwuid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getpwuid(arg1);
+}
+
+void test__getpwuid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getpwuid(x);
+}
+
+void test__getpwuid_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getpwuid_r(arg1, arg2, arg3, arg4, arg5);
+  // 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__getpwuid_r__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getpwuid_r(arg1, arg2, arg3, x, arg5);
+}
+
+void test__setpwent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setpwent();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__catclose__noreturn() {
+  int x = 100;
+  if (cond) x=1; else catclose(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__catclose__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  catclose(x);
+}
+
+void test__catgets__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = catgets(arg1, arg2, arg3, arg4);
+  // 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__catgets__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = catgets(arg1, arg2, x, arg4);
+}
+
+void test__catgets__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = catgets(arg1, arg2, arg3, x);
+}
+
+void test__catopen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else catopen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__catopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  catopen(NULL, arg2);
+}
+
+void test__catopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  catopen(x, arg2);
+}
+
+void test__catopen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  catopen(arg1, x);
+}
+
+void test__poll__noreturn() {
+  int x = 100;
+  if (cond) x=1; else poll(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__poll__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  poll(arg1, x, arg3);
+}
+
+void test__poll__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  poll(arg1, arg2, x);
+}
+
+void test__regcomp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else regcomp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__regcomp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  regcomp(NULL, arg2, arg3);
+}
+
+void test__regcomp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regcomp(arg1, x, arg3);
+}
+
+void test__regcomp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regcomp(arg1, arg2, x);
+}
+
+void test__regerror__noreturn() {
+  int x = 100;
+  if (cond) x=1; else regerror(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__regerror__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regerror(x, arg2, arg3, arg4);
+}
+
+void test__regerror__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regerror(arg1, x, arg3, arg4);
+}
+
+void test__regerror__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regerror(arg1, arg2, arg3, x);
+}
+
+void test__regexec__noreturn() {
+  int x = 100;
+  if (cond) x=1; else regexec(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__regexec__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  regexec(x, arg2, arg3, arg4, arg5);
+}
+
+void test__regexec__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  regexec(arg1, NULL, arg3, arg4, arg5);
+}
+
+void test__regexec__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  regexec(arg1, x, arg3, arg4, arg5);
+}
+
+void test__regexec__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regexec(arg1, arg2, x, arg4, arg5);
+}
+
+void test__regexec__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regexec(arg1, arg2, arg3, x, arg5);
+}
+
+void test__regexec__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  regexec(arg1, arg2, arg3, arg4, x);
+}
+
+void test__regfree__noreturn() {
+  int x = 100;
+  if (cond) x=1; else regfree(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__regfree__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  regfree(NULL);
+}
+
+void test__regfree__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  regfree(x);
+}
+
+void test__sched_get_priority_max__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sched_get_priority_max(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sched_get_priority_max__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sched_get_priority_max(x);
+}
+
+void test__sched_get_priority_min__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sched_get_priority_min(arg1);
+  // 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 = 100;
+  if (cond) x=1; else sched_getparam(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sched_getparam__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sched_getparam(x, arg2);
+}
+
+void test__sched_getparam__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  sched_getparam(arg1, NULL);
+}
+
+void test__sched_getscheduler__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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__sched_setscheduler__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sched_setscheduler(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sched_setscheduler__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sched_setscheduler(x, arg2, arg3);
+}
+
+void test__sched_setscheduler__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sched_setscheduler(arg1, x, arg3);
+}
+
+void test__sched_setscheduler__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sched_setscheduler(arg1, arg2, x);
+}
+
+void test__sched_yield__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sched_yield();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ecvt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ecvt(arg1, x, arg3, arg4);
+}
+
+void test__ecvt__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  ecvt(arg1, arg2, NULL, arg4);
+}
+
+void test__ecvt__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  ecvt(arg1, arg2, arg3, NULL);
+}
+
+void test__fcvt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fcvt(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fcvt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fcvt(x, arg2, arg3, arg4);
+}
+
+void test__fcvt__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fcvt(arg1, x, arg3, arg4);
+}
+
+void test__fcvt__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  fcvt(arg1, arg2, NULL, arg4);
+}
+
+void test__fcvt__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  fcvt(arg1, arg2, arg3, NULL);
+}
+
+void test__gcvt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else gcvt(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__gcvt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  gcvt(x, arg2, arg3);
+}
+
+void test__gcvt__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  gcvt(arg1, x, arg3);
+}
+
+void test__gcvt__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  gcvt(arg1, arg2, NULL);
+}
+
+void test__lseek__noreturn() {
+  int x = 100;
+  if (cond) x=1; else lseek(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__lseek__leakignore() {
+  char *p = strdup(str);
+  lseek(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__lseek__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  lseek(x, arg2, arg3);
+}
+
+void test__lseek__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  lseek(arg1, x, arg3);
+}
+
+void test__lseek__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  lseek(arg1, arg2, x);
+}
+
+void test__nanosleep__noreturn() {
+  int x = 100;
+  if (cond) x=1; else nanosleep(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__nanosleep__leakignore() {
+  char *p = strdup(str);
+  nanosleep(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__nanosleep__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  nanosleep(NULL, arg2);
+}
+
+void test__setkey__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setkey(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setkey__leakignore() {
+  char *p = strdup(str);
+  setkey(p);
+  // cppcheck-suppress memleak
+}
+
+void test__setkey__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  setkey(NULL);
+}
+
+void test__setkey__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  setkey(x);
+}
+
+void test__getpass__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getpass(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getpass__leakignore() {
+  char *p = strdup(str);
+  getpass(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getpass__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getpass(NULL);
+}
+
+void test__drand48__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = drand48();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__drand48__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  drand48();
+}
+
+void test__putenv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else putenv(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__putenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  putenv(NULL);
+}
+
+void test__putenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  putenv(x);
+}
+
+void test__setenv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setenv(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  setenv(NULL, arg2, arg3);
+}
+
+void test__setenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  setenv(x, arg2, arg3);
+}
+
+void test__setenv__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  setenv(arg1, NULL, arg3);
+}
+
+void test__setenv__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  setenv(arg1, x, arg3);
+}
+
+void test__setenv__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setenv(arg1, arg2, x);
+}
+
+void test__unsetenv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else unsetenv(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__unsetenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  unsetenv(NULL);
+}
+
+void test__unsetenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  unsetenv(x);
+}
+
+void test__localtime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else localtime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__localtime__leakignore() {
+  char *p = strdup(str);
+  localtime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__localtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  localtime(NULL);
+}
+
+void test__localtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  localtime(x);
+}
+
+void test__std__localtime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::localtime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__localtime__leakignore() {
+  char *p = strdup(str);
+  std::localtime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__localtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::localtime(NULL);
+}
+
+void test__std__localtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::localtime(x);
+}
+
+void test__localtime_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else localtime_r(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__localtime_r__leakignore() {
+  char *p = strdup(str);
+  localtime_r(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__localtime_r__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  localtime_r(NULL, arg2);
+}
+
+void test__localtime_r__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  localtime_r(x, arg2);
+}
+
+void test__localtime_r__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  localtime_r(arg1, NULL);
+}
+
+void test__readdir__noreturn() {
+  int x = 100;
+  if (cond) x=1; else readdir(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__readdir__leakignore() {
+  char *p = strdup(str);
+  readdir(p);
+  // cppcheck-suppress memleak
+}
+
+void test__readdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  readdir(NULL);
+}
+
+void test__readdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  readdir(x);
+}
+
+void test__readdir_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else readdir_r(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__readdir_r__leakignore() {
+  char *p = strdup(str);
+  readdir_r(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__readdir_r__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  readdir_r(NULL, arg2, arg3);
+}
+
+void test__readdir_r__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  readdir_r(x, arg2, arg3);
+}
+
+void test__readdir_r__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  readdir_r(arg1, NULL, arg3);
+}
+
+void test__readdir_r__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  readdir_r(arg1, arg2, NULL);
+}
+
+void test__readlink__noreturn() {
+  int x = 100;
+  if (cond) x=1; else readlink(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__readlink__leakignore() {
+  char *p = strdup(str);
+  readlink(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__readlink__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  readlink(NULL, arg2, arg3);
+}
+
+void test__readlink__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  readlink(x, arg2, arg3);
+}
+
+void test__readlink__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  readlink(arg1, NULL, arg3);
+}
+
+void test__readlink__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  readlink(arg1, arg2, x);
+}
+
+void test__readlinkat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else readlinkat(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__readlinkat__leakignore() {
+  char *p = strdup(str);
+  readlinkat(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__readlinkat__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  readlinkat(x, arg2, arg3, arg4);
+}
+
+void test__readlinkat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  readlinkat(arg1, NULL, arg3, arg4);
+}
+
+void test__readlinkat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  readlinkat(arg1, x, arg3, arg4);
+}
+
+void test__readlinkat__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  readlinkat(arg1, arg2, NULL, arg4);
+}
+
+void test__readlinkat__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  readlinkat(arg1, arg2, arg3, x);
+}
+
+void test__asctime_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else asctime_r(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__asctime_r__leakignore() {
+  char *p = strdup(str);
+  asctime_r(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__asctime_r__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  asctime_r(NULL, arg2);
+}
+
+void test__asctime_r__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  asctime_r(x, arg2);
+}
+
+void test__asctime_r__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  asctime_r(arg1, NULL);
+}
+
+void test__ctime_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ctime_r(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ctime_r__leakignore() {
+  char *p = strdup(str);
+  ctime_r(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__ctime_r__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  ctime_r(NULL, arg2);
+}
+
+void test__ctime_r__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ctime_r(x, arg2);
+}
+
+void test__ctime_r__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  ctime_r(arg1, NULL);
+}
+
+void test__gmtime_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else gmtime_r(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__gmtime_r__leakignore() {
+  char *p = strdup(str);
+  gmtime_r(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__gmtime_r__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  gmtime_r(NULL, arg2);
+}
+
+void test__gmtime_r__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  gmtime_r(x, arg2);
+}
+
+void test__gmtime_r__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  gmtime_r(arg1, NULL);
+}
+
+void test__gmtime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = gmtime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__gmtime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  gmtime(arg1);
+}
+
+void test__gmtime__leakignore() {
+  char *p = strdup(str);
+  result = gmtime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__gmtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = gmtime(NULL);
+}
+
+void test__gmtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = gmtime(x);
+}
+
+void test__clock_settime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else clock_settime(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__clock_settime__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  clock_settime(x, arg2);
+}
+
+void test__clock_settime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  clock_settime(arg1, x);
+}
+
+void test__killpg__noreturn() {
+  int x = 100;
+  if (cond) x=1; else killpg(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__killpg__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  killpg(x, arg2);
+}
+
+void test__killpg__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  killpg(arg1, x);
+}
+
+void test__kill__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else clock_getres(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__clock_getres__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  clock_getres(x, arg2);
+}
+
+void test__tmpnam__noreturn() {
+  int x = 100;
+  if (cond) x=1; else tmpnam(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tmpnam__leakignore() {
+  char *p = strdup(str);
+  tmpnam(p);
+  // cppcheck-suppress memleak
+}
+
+void test__tmpnam__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tmpnam(x);
+}
+
+void test__tmpnam_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else tmpnam_r(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tmpnam_r__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else makecontext(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__makecontext__leakignore() {
+  char *p = strdup(str);
+  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__makecontext__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  makecontext(arg1, arg2, x);
+}
+
+void test__swapcontext__noreturn() {
+  int x = 100;
+  if (cond) x=1; else swapcontext(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__swapcontext__leakignore() {
+  char *p = strdup(str);
+  swapcontext(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__swapcontext__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  swapcontext(NULL, arg2);
+}
+
+void test__swapcontext__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  swapcontext(arg1, NULL);
+}
+
+void test__getcontext__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getcontext(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getcontext__leakignore() {
+  char *p = strdup(str);
+  getcontext(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getcontext__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getcontext(NULL);
+}
+
+void test__ualarm__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ualarm(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ualarm__leakignore() {
+  char *p = strdup(str);
+  ualarm(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__ualarm__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ualarm(x, arg2);
+}
+
+void test__ualarm__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ualarm(arg1, x);
+}
+
+void test__scalb__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = scalb(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__scalb__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  scalb(arg1, arg2);
+}
+
+void test__scalb__leakignore() {
+  char *p = strdup(str);
+  result = scalb(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__scalb__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalb(x, arg2);
+}
+
+void test__scalb__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalb(arg1, x);
+}
+
+void test__bcopy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else bcopy(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__bcopy__leakignore() {
+  char *p = strdup(str);
+  bcopy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__bcopy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  bcopy(NULL, arg2, arg3);
+}
+
+void test__bcopy__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  bcopy(x, arg2, arg3);
+}
+
+void test__bcopy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  bcopy(arg1, NULL, arg3);
+}
+
+void test__bcopy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  bcopy(arg1, arg2, x);
+}
+
+void test__bcmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = bcmp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__bcmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  bcmp(arg1, arg2, arg3);
+}
+
+void test__bcmp__leakignore() {
+  char *p = strdup(str);
+  result = bcmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__bcmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = bcmp(NULL, arg2, arg3);
+}
+
+void test__bcmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = bcmp(x, arg2, arg3);
+}
+
+void test__bcmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = bcmp(arg1, NULL, arg3);
+}
+
+void test__bcmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = bcmp(arg1, x, arg3);
+}
+
+void test__bcmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = bcmp(arg1, arg2, x);
+}
+
+void test__bzero__noreturn() {
+  int x = 100;
+  if (cond) x=1; else bzero(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__bzero__leakignore() {
+  char *p = strdup(str);
+  bzero(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__bzero__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  bzero(NULL, arg2);
+}
+
+void test__bzero__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  bzero(arg1, x);
+}
+
+void test__ftime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ftime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ftime__leakignore() {
+  char *p = strdup(str);
+  ftime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ftime__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ftime(x);
+}
+
+void test__wcswcs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcswcs(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcswcs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcswcs(arg1, arg2);
+}
+
+void test__wcswcs__leakignore() {
+  char *p = strdup(str);
+  result = wcswcs(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcswcs__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcswcs(NULL, arg2);
+}
+
+void test__wcswcs__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcswcs(x, arg2);
+}
+
+void test__wcswcs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcswcs(arg1, NULL);
+}
+
+void test__wcswcs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcswcs(arg1, x);
+}
+
+void test__stpcpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else stpcpy(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__stpcpy__leakignore() {
+  char *p = strdup(str);
+  stpcpy(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__stpcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  stpcpy(NULL, arg2);
+}
+
+void test__stpcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  stpcpy(arg1, NULL);
+}
+
+void test__stpcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  stpcpy(arg1, x);
+}
+
+void test__index__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = index(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__index__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  index(arg1, arg2);
+}
+
+void test__index__leakignore() {
+  char *p = strdup(str);
+  result = index(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__index__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = index(NULL, arg2);
+}
+
+void test__index__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = index(x, arg2);
+}
+
+void test__index__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = index(arg1, x);
+}
+
+void test__rindex__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = rindex(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__rindex__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  rindex(arg1, arg2);
+}
+
+void test__rindex__leakignore() {
+  char *p = strdup(str);
+  result = rindex(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__rindex__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = rindex(NULL, arg2);
+}
+
+void test__rindex__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = rindex(x, arg2);
+}
+
+void test__rindex__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = rindex(arg1, x);
+}
+
+void test__bsd_signal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else bsd_signal(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__bsd_signal__leakignore() {
+  char *p = strdup(str);
+  bsd_signal(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__bsd_signal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  bsd_signal(x, arg2);
+}
+
+void test__bsd_signal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  bsd_signal(arg1, x);
+}
+
+void test__fork__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fork();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fork__leakignore() {
+  char *p = strdup(str);
+  fork();
+  // cppcheck-suppress memleak
+}
+
+void test__vfork__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vfork();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vfork__leakignore() {
+  char *p = strdup(str);
+  vfork();
+  // cppcheck-suppress memleak
+}
+
+void test__pthread_atfork__noreturn() {
+  int x = 100;
+  if (cond) x=1; else pthread_atfork(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__pthread_atfork__leakignore() {
+  char *p = strdup(str);
+  pthread_atfork(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__pthread_create__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else pthread_exit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__pthread_join__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else pthread_attr_destroy(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__pthread_attr_destroy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  pthread_attr_destroy(NULL);
+}
+
+void test__pthread_attr_init__noreturn() {
+  int x = 100;
+  if (cond) x=1; else pthread_attr_init(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__pthread_attr_init__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  pthread_attr_init(NULL);
+}
+
+void test__pthread_attr_setstackaddr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else pthread_attr_setstackaddr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__pthread_attr_setstackaddr__leakignore() {
+  char *p = strdup(str);
+  pthread_attr_setstackaddr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__pthread_attr_setstackaddr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  pthread_attr_setstackaddr(NULL, arg2);
+}
+
+void test__pthread_attr_setstackaddr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  pthread_attr_setstackaddr(x, arg2);
+}
+
+void test__pthread_attr_setstackaddr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  pthread_attr_setstackaddr(arg1, NULL);
+}
+
+void test__pthread_attr_setstackaddr__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  pthread_attr_setstackaddr(arg1, x);
+}
+
+void test__pthread_attr_getstackaddr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else pthread_attr_getstackaddr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__pthread_attr_getstackaddr__leakignore() {
+  char *p = strdup(str);
+  pthread_attr_getstackaddr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__pthread_attr_getstackaddr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  pthread_attr_getstackaddr(NULL, arg2);
+}
+
+void test__pthread_attr_getstackaddr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  pthread_attr_getstackaddr(x, arg2);
+}
+
+void test__pthread_attr_getstackaddr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  pthread_attr_getstackaddr(arg1, NULL);
+}
+
+void test__tempnam__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = tempnam(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tempnam__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tempnam(arg1, arg2);
+}
+
+void test__tempnam__leakignore() {
+  char *p = strdup(str);
+  result = tempnam(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__tempnam__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tempnam(x, arg2);
+}
+
+void test__tempnam__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tempnam(arg1, x);
+}
+
+void test__crypt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = crypt(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__crypt__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  crypt(arg1, arg2);
+}
+
+void test__crypt__leakignore() {
+  char *p = strdup(str);
+  result = crypt(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__crypt__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = crypt(NULL, arg2);
+}
+
+void test__crypt__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = crypt(x, arg2);
+}
+
+void test__crypt__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = crypt(arg1, NULL);
+}
+
+void test__crypt__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = crypt(arg1, x);
+}
+
+void test__ttyname__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ttyname(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ttyname__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ttyname(arg1);
+}
+
+void test__ttyname__leakignore() {
+  char *p = strdup(str);
+  result = ttyname(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ttyname__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ttyname(x);
+}
+
+void test__getspnam__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getspnam(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getspnam__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getspnam(arg1);
+}
+
+void test__getspnam__leakignore() {
+  char *p = strdup(str);
+  result = getspnam(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getspnam__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = getspnam(NULL);
+}
+
+void test__getspnam__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = getspnam(x);
+}
+
+void test__getspent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getspent();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getspent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getspent();
+}
+
+void test__getspent__leakignore() {
+  char *p = strdup(str);
+  result = getspent();
+  // cppcheck-suppress memleak
+}
+
+void test__fgetspent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fgetspent(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fgetspent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fgetspent(arg1);
+}
+
+void test__fgetspent__leakignore() {
+  char *p = strdup(str);
+  result = fgetspent(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fgetspent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fgetspent(NULL);
+}
+
+void test__fgetspent__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fgetspent(x);
+}
+
+void test__sgetspent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = sgetspent(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sgetspent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sgetspent(arg1);
+}
+
+void test__sgetspent__leakignore() {
+  char *p = strdup(str);
+  result = sgetspent(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sgetspent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = sgetspent(NULL);
+}
+
+void test__sgetspent__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = sgetspent(x);
+}
+
+void test__fgetpwent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fgetpwent(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fgetpwent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fgetpwent(arg1);
+}
+
+void test__fgetpwent__leakignore() {
+  char *p = strdup(str);
+  result = fgetpwent(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fgetpwent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fgetpwent(NULL);
+}
+
+void test__fgetpwent__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fgetpwent(x);
+}
+
+void test__getgrent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getgrent();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getgrent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getgrent();
+}
+
+void test__getgrent__leakignore() {
+  char *p = strdup(str);
+  result = getgrent();
+  // cppcheck-suppress memleak
+}
+
+void test__getgrent_r__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getgrent_r(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getgrent_r__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getgrent_r(arg1, arg2, arg3, arg4);
+}
+
+void test__getgrent_r__leakignore() {
+  char *p = strdup(str);
+  result = getgrent_r(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__getgrent_r__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getgrent_r(arg1, x, arg3, arg4);
+}
+
+void test__getgrent_r__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getgrent_r(arg1, arg2, x, arg4);
+}
+
+void test__fgetgrent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fgetgrent(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fgetgrent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fgetgrent(arg1);
+}
+
+void test__fgetgrent__leakignore() {
+  char *p = strdup(str);
+  result = fgetgrent(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fgetgrent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fgetgrent(NULL);
+}
+
+void test__fgetgrent__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fgetgrent(x);
+}
+
+void test__getnetgrent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getnetgrent(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getnetgrent__leakignore() {
+  char *p = strdup(str);
+  getnetgrent(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__getnetgrent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getnetgrent(NULL, arg2, arg3);
+}
+
+void test__getnetgrent__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getnetgrent(arg1, NULL, arg3);
+}
+
+void test__getnetgrent__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  getnetgrent(arg1, arg2, NULL);
+}
+
+void test__getgrnam__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getgrnam(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getgrnam__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getgrnam(arg1);
+}
+
+void test__getgrnam__leakignore() {
+  char *p = strdup(str);
+  result = getgrnam(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getgrnam__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = getgrnam(NULL);
+}
+
+void test__getgrnam__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = getgrnam(x);
+}
+
+void test__getgrgid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getgrgid(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getgrgid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getgrgid(arg1);
+}
+
+void test__getgrgid__leakignore() {
+  char *p = strdup(str);
+  result = getgrgid(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getgrgid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = getgrgid(x);
+}
+
+void test__getlogin__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getlogin();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getlogin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getlogin();
+}
+
+void test__getlogin__leakignore() {
+  char *p = strdup(str);
+  result = getlogin();
+  // cppcheck-suppress memleak
+}
+
+void test__ctermid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ctermid(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ctermid__leakignore() {
+  char *p = strdup(str);
+  ctermid(p);
+  // cppcheck-suppress memleak
+}
+
+void test__realpath__noreturn() {
+  int x = 100;
+  if (cond) x=1; else realpath(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__realpath__leakignore() {
+  char *p = strdup(str);
+  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__remove__noreturn() {
+  int x = 100;
+  if (cond) x=1; else remove(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__remove__leakignore() {
+  char *p = strdup(str);
+  remove(p);
+  // cppcheck-suppress memleak
+}
+
+void test__remove__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  remove(NULL);
+}
+
+void test__remove__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  remove(x);
+}
+
+void test__fileno__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fileno(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fileno__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fileno(arg1);
+}
+
+void test__fileno__leakignore() {
+  char *p = strdup(str);
+  result = fileno(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fileno__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fileno(NULL);
+}
+
+void test__fileno__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fileno(x);
+}
+
+void test__fseeko__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fseeko(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fseeko__leakignore() {
+  char *p = strdup(str);
+  fseeko(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__fseeko__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fseeko(NULL, arg2, arg3);
+}
+
+void test__fseeko__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fseeko(x, arg2, arg3);
+}
+
+void test__fseeko__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fseeko(arg1, x, arg3);
+}
+
+void test__fseeko__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fseeko(arg1, arg2, x);
+}
+
+void test__ftello__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ftello(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ftello__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ftello(arg1);
+}
+
+void test__ftello__leakignore() {
+  char *p = strdup(str);
+  result = ftello(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ftello__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = ftello(NULL);
+}
+
+void test__ftello__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = ftello(x);
+}
+
+void test__execv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else execv(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__execv__leakignore() {
+  char *p = strdup(str);
+  execv(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__execv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  execv(NULL, arg2);
+}
+
+void test__execv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  execv(x, arg2);
+}
+
+void test__execv__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  execv(arg1, x);
+}
+
+void test__execvp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else execvp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__execvp__leakignore() {
+  char *p = strdup(str);
+  execvp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__execvp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  execvp(NULL, arg2);
+}
+
+void test__execvp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  execvp(x, arg2);
+}
+
+void test__execvp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  execvp(arg1, x);
+}
+
+void test__wait__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wait(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wait__leakignore() {
+  char *p = strdup(str);
+  wait(p);
+  // cppcheck-suppress memleak
+}
+
+void test__waitpid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else waitpid(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__waitpid__leakignore() {
+  char *p = strdup(str);
+  waitpid(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__waitpid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  waitpid(x, arg2, arg3);
+}
+
+void test__waitpid__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  waitpid(arg1, arg2, x);
+}
+
+void test__strnlen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strnlen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strnlen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strnlen(arg1, arg2);
+}
+
+void test__strnlen__leakignore() {
+  char *p = strdup(str);
+  result = strnlen(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strnlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strnlen(NULL, arg2);
+}
+
+void test__strnlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strnlen(x, arg2);
+}
+
+void test__strnlen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strnlen(arg1, x);
+}
+
+void test__wcsnlen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcsnlen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcsnlen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcsnlen(arg1, arg2);
+}
+
+void test__wcsnlen__leakignore() {
+  char *p = strdup(str);
+  result = wcsnlen(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcsnlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsnlen(NULL, arg2);
+}
+
+void test__wcsnlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsnlen(x, arg2);
+}
+
+void test__wcsnlen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcsnlen(arg1, x);
+}
+
+void test__ffs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ffs(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ffs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ffs(arg1);
+}
+
+void test__ffs__leakignore() {
+  char *p = strdup(str);
+  result = ffs(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ffs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ffs(x);
+}
+
+void test__shmctl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else shmctl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__shmctl__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else shmget(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__shmget__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else shmat(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__shmat__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else shmdt(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__shmdt__leakignore() {
+  char *p = strdup(str);
+  shmdt(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getrlimit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getrlimit(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getrlimit__leakignore() {
+  char *p = strdup(str);
+  getrlimit(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__getrlimit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getrlimit(x, arg2);
+}
+
+void test__getrlimit__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getrlimit(arg1, NULL);
+}
+
+void test__setrlimit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setrlimit(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setrlimit__leakignore() {
+  char *p = strdup(str);
+  setrlimit(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__setrlimit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setrlimit(x, arg2);
+}
+
+void test__setrlimit__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  setrlimit(arg1, NULL);
+}
+
+void test__setrlimit__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  setrlimit(arg1, x);
+}
+
+void test__glob__noreturn() {
+  int x = 100;
+  if (cond) x=1; else glob(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__glob__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  glob(NULL, arg2, arg3, arg4);
+}
+
+void test__glob__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  glob(x, arg2, arg3, arg4);
+}
+
+void test__glob__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  glob(arg1, x, arg3, arg4);
+}
+
+void test__glob__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  glob(arg1, arg2, x, arg4);
+}
+
+void test__glob__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  glob(arg1, arg2, arg3, NULL);
+}
+
+void test__globfree__noreturn() {
+  int x = 100;
+  if (cond) x=1; else globfree(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__globfree__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  globfree(NULL);
+}
+
+void test__globfree__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  globfree(x);
+}
+
+void test__wcpncpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcpncpy(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcpncpy__leakignore() {
+  char *p = strdup(str);
+  wcpncpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcpncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcpncpy(NULL, arg2, arg3);
+}
+
+void test__wcpncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcpncpy(arg1, NULL, arg3);
+}
+
+void test__wcpncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcpncpy(arg1, x, arg3);
+}
+
+void test__wcpncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wcpncpy(arg1, arg2, !x);
+}
+
+void test__wcpncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcpncpy(arg1, arg2, x);
+}
+
+void test__stpncpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else stpncpy(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__stpncpy__leakignore() {
+  char *p = strdup(str);
+  stpncpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__stpncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  stpncpy(NULL, arg2, arg3);
+}
+
+void test__stpncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  stpncpy(arg1, NULL, arg3);
+}
+
+void test__stpncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  stpncpy(arg1, x, arg3);
+}
+
+void test__stpncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  stpncpy(arg1, arg2, !x);
+}
+
+void test__stpncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  stpncpy(arg1, arg2, x);
+}
+
+void test__memccpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else memccpy(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__memccpy__leakignore() {
+  char *p = strdup(str);
+  memccpy(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__memccpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  memccpy(NULL, arg2, arg3, arg4);
+}
+
+void test__memccpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  memccpy(arg1, NULL, arg3, arg4);
+}
+
+void test__memccpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  memccpy(arg1, x, arg3, arg4);
+}
+
+void test__memccpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memccpy(arg1, arg2, x, arg4);
+}
+
+void test__memccpy__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memccpy(arg1, arg2, arg3, x);
+}
+
+void test__getopt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getopt(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getopt__leakignore() {
+  char *p = strdup(str);
+  getopt(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__getopt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getopt(x, arg2, arg3);
+}
+
+void test__getopt__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getopt(arg1, NULL, arg3);
+}
+
+void test__getopt__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getopt(arg1, x, arg3);
+}
+
+void test__getopt__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  getopt(arg1, arg2, NULL);
+}
+
+void test__getopt__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getopt(arg1, arg2, x);
+}
+
+void test__getitimer__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getitimer(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getitimer__leakignore() {
+  char *p = strdup(str);
+  getitimer(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__getitimer__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getitimer(x, arg2);
+}
+
+void test__getitimer__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getitimer(arg1, NULL);
+}
+
+void test__getitimer__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getitimer(arg1, x);
+}
+
+void test__setitimer__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setitimer(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setitimer__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else sigaction(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigaction__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else sigaltstack(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigaltstack__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else _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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else _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 = 100;
+  if (cond) x=1; else sigsuspend(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigsuspend__leakignore() {
+  char *p = strdup(str);
+  sigsuspend(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sigsuspend__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  sigsuspend(NULL);
+}
+
+void test__pthread_sigmask__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else getrusage(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getrusage__leakignore() {
+  char *p = strdup(str);
+  getrusage(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__getrusage__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getrusage(x, arg2);
+}
+
+void test__getrusage__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getrusage(arg1, NULL);
+}
+
+void test__sigemptyset__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sigemptyset(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigemptyset__leakignore() {
+  char *p = strdup(str);
+  sigemptyset(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sigemptyset__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  sigemptyset(NULL);
+}
+
+void test__sigfillset__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sigfillset(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigfillset__leakignore() {
+  char *p = strdup(str);
+  sigfillset(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sigfillset__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  sigfillset(NULL);
+}
+
+void test__sigaddset__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sigaddset(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigaddset__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else sigdelset(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigdelset__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else sigismember(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sigismember__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else posix_spawn(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__posix_spawn__leakignore() {
+  char *p = strdup(str);
+  posix_spawn(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__posix_spawnp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else posix_spawnp(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__posix_spawnp__leakignore() {
+  char *p = strdup(str);
+  posix_spawnp(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__msgctl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else msgctl(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__msgctl__leakignore() {
+  char *p = strdup(str);
+  msgctl(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__msgctl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  msgctl(x, arg2, arg3);
+}
+
+void test__msgctl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  msgctl(arg1, x, arg3);
+}
+
+void test__msgctl__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  msgctl(arg1, arg2, x);
+}
+
+void test__msgget__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = msgget(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = msgget(arg1, x);
+}
+
+void test__msgrcv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else msgrcv(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__msgrcv__leakignore() {
+  char *p = strdup(str);
+  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__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__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__msgsnd__noreturn() {
+  int x = 100;
+  if (cond) x=1; else msgsnd(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__msgsnd__leakignore() {
+  char *p = strdup(str);
+  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__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__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  msgsnd(arg1, arg2, arg3, x);
+}
+
+void test__tcflow__noreturn() {
+  int x = 100;
+  if (cond) x=1; else tcflow(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tcflow__leakignore() {
+  char *p = strdup(str);
+  tcflow(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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__tcflush__noreturn() {
+  int x = 100;
+  if (cond) x=1; else tcflush(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tcflush__leakignore() {
+  char *p = strdup(str);
+  tcflush(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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__tcsendbreak__noreturn() {
+  int x = 100;
+  if (cond) x=1; else tcsendbreak(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tcsendbreak__leakignore() {
+  char *p = strdup(str);
+  tcsendbreak(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__tcsendbreak__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tcsendbreak(x, arg2);
+}
+
+void test__tcsendbreak__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  tcsendbreak(arg1, NULL);
+}
+
+void test__tcgetattr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else tcgetattr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tcgetattr__leakignore() {
+  char *p = strdup(str);
+  tcgetattr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__tcgetattr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tcgetattr(x, arg2);
+}
+
+void test__tcgetattr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  tcgetattr(arg1, NULL);
+}
+
+void test__tcsetattr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else tcsetattr(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tcsetattr__leakignore() {
+  char *p = strdup(str);
+  tcsetattr(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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__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__cfsetospeed__noreturn() {
+  int x = 100;
+  if (cond) x=1; else cfsetospeed(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cfsetospeed__leakignore() {
+  char *p = strdup(str);
+  cfsetospeed(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  cfsetospeed(arg1, x);
+}
+
+void test__cfsetispeed__noreturn() {
+  int x = 100;
+  if (cond) x=1; else cfsetispeed(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cfsetispeed__leakignore() {
+  char *p = strdup(str);
+  cfsetispeed(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  cfsetispeed(arg1, x);
+}
+
+void test__tcdrain__noreturn() {
+  int x = 100;
+  if (cond) x=1; else tcdrain(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tcdrain__leakignore() {
+  char *p = strdup(str);
+  tcdrain(p);
+  // cppcheck-suppress memleak
+}
+
+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
new file mode 100644
index 000000000..ef293e5cb
--- /dev/null
+++ b/test/cfg/generated-cfg-tests-qt.cpp
@@ -0,0 +1,1626 @@
+// auto generated tests from cfg/qt.cfg
+//
+// Generated by command:
+// ./generate_cfg_tests cfg/qt.cfg > generated-cfg-tests-qt.cpp
+//
+// Recommended cppcheck command line:
+// $ cppcheck --enable=warning,information --inline-suppr generated-cfg-tests-qt.cpp
+// => 'unmatched suppression' warnings are false negatives.
+//
+
+void test__connect__noreturn() {
+  int x = 100;
+  if (cond) x=1; else connect(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__connect__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  connect(NULL, arg2, arg3, arg4);
+}
+
+void test__connect__arg1__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__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__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  connect(arg1, arg2, arg3, x);
+}
+
+void test__disconnect__noreturn() {
+  int x = 100;
+  if (cond) x=1; else disconnect(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__disconnect__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  disconnect(NULL, arg2, arg3, arg4);
+}
+
+void test__disconnect__arg1__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__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__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  disconnect(arg1, arg2, arg3, x);
+}
+
+void test__tr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = tr(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__tr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = tr(NULL, arg2, arg3);
+}
+
+void test__tr__arg1__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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tr(arg1, arg2, x);
+}
+
+void test__QObject__tr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = QObject::tr(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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__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__QSettings__setValue__noreturn() {
+  int x = 100;
+  if (cond) x=1; else QSettings::setValue(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QSettings__setValue__leakignore() {
+  char *p = strdup(str);
+  QSettings::setValue(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  QSettings::setValue(arg1, x);
+}
+
+void test__QSettings__value__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QSettings::value(arg1, x);
+}
+
+void test__QString__sprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else QString::sprintf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__sprintf__leakignore() {
+  char *p = strdup(str);
+  QString::sprintf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__QString__sprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  QString::sprintf(x);
+}
+
+void test__QString__asprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else QString::asprintf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__asprintf__leakignore() {
+  char *p = strdup(str);
+  QString::asprintf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__QString__asprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  QString::asprintf(x);
+}
+
+void test__QList__at__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else QList::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else QString::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__compare__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = QString::compare(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else result = QList::endsWith(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__endsWith__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::endsWith(arg1);
+}
+
+void test__QList__endsWith__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QList::endsWith(x);
+}
+
+void test__QString__contains__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QString::contains(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__contains__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::contains(arg1, arg2);
+}
+
+void test__QString__contains__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::contains(x, arg2);
+}
+
+void test__QString__contains__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::contains(arg1, x);
+}
+
+void test__QString__startsWith__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QString::startsWith(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__startsWith__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::startsWith(arg1, arg2);
+}
+
+void test__QString__startsWith__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::startsWith(x, arg2);
+}
+
+void test__QString__startsWith__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::startsWith(arg1, x);
+}
+
+void test__QString__endsWith__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QString::endsWith(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__endsWith__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::endsWith(arg1, arg2);
+}
+
+void test__QString__endsWith__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::endsWith(x, arg2);
+}
+
+void test__QString__endsWith__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::endsWith(arg1, x);
+}
+
+void test__QStringList__contains__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QStringList::contains(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__contains__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::contains(arg1);
+}
+
+void test__QStringList__contains__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QStringList::contains(x);
+}
+
+void test__QStringList__startsWith__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QStringList::startsWith(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__startsWith__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::startsWith(arg1);
+}
+
+void test__QStringList__startsWith__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QStringList::startsWith(x);
+}
+
+void test__QStringList__endsWith__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QStringList::endsWith(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__endsWith__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::endsWith(arg1);
+}
+
+void test__QStringList__endsWith__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QStringList::endsWith(x);
+}
+
+void test__QList__count__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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__QStringList__indexOf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QStringList::indexOf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__indexOf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::indexOf(arg1);
+}
+
+void test__QStringList__indexOf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QStringList::indexOf(x);
+}
+
+void test__QString__indexOf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QString::indexOf();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__indexOf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::indexOf();
+}
+
+void test__QString__isRightToLeft__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QString::isRightToLeft();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__isRightToLeft__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::isRightToLeft();
+}
+
+void test__QList__lastIndexOf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QList::lastIndexOf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__lastIndexOf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::lastIndexOf(arg1, arg2);
+}
+
+void test__QList__lastIndexOf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QList::lastIndexOf(x, arg2);
+}
+
+void test__QList__lastIndexOf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QList::lastIndexOf(arg1, x);
+}
+
+void test__QStringList__lastIndexOf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QStringList::lastIndexOf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QStringList__lastIndexOf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QStringList::lastIndexOf(arg1, arg2);
+}
+
+void test__QStringList__lastIndexOf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QStringList::lastIndexOf(x, arg2);
+}
+
+void test__QStringList__lastIndexOf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QStringList::lastIndexOf(arg1, x);
+}
+
+void test__QString__lastIndexOf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QString::lastIndexOf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__lastIndexOf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::lastIndexOf(arg1, arg2, arg3);
+}
+
+void test__QString__lastIndexOf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::lastIndexOf(x, arg2, arg3);
+}
+
+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 = 100;
+  if (cond) x=1; else 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__QList__mid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QList::mid(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QList__mid__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QList::mid(arg1, arg2);
+}
+
+void test__QList__mid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QList::mid(x, arg2);
+}
+
+void test__QList__mid__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QList::mid(arg1, x);
+}
+
+void test__QString__mid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QString::mid(arg1, arg2);
+  // 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else result = QString::number();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__number__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::number();
+}
+
+void test__QString__number__leakignore() {
+  char *p = strdup(str);
+  result = QString::number();
+  // cppcheck-suppress memleak
+}
+
+void test__QString__right__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QString::right(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QString__right__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QString::right(arg1);
+}
+
+void test__QString__right__leakignore() {
+  char *p = strdup(str);
+  result = QString::right(p);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = QString::split(p);
+  // cppcheck-suppress memleak
+}
+
+void test__QString__split__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QString::split(x);
+}
+
+void test__QString__toInt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = QString::toInt(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else QMetaObject::connectSlotsByName(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QMetaObject__connectSlotsByName__leakignore() {
+  char *p = strdup(str);
+  QMetaObject::connectSlotsByName(p);
+  // cppcheck-suppress memleak
+}
+
+void test__QMetaObject__connectSlotsByName__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  QMetaObject::connectSlotsByName(NULL);
+}
+
+void test__QDir__fromNativeSeparators__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else QFile::open();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QFile__open__leakignore() {
+  char *p = strdup(str);
+  QFile::open();
+  // cppcheck-suppress memleak
+}
+
+void test__QFile__remove__noreturn() {
+  int x = 100;
+  if (cond) x=1; else QFile::remove();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QFile__remove__leakignore() {
+  char *p = strdup(str);
+  QFile::remove();
+  // cppcheck-suppress memleak
+}
+
+void test__QFile__rename__noreturn() {
+  int x = 100;
+  if (cond) x=1; else QFile::rename();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QFile__rename__leakignore() {
+  char *p = strdup(str);
+  QFile::rename();
+  // cppcheck-suppress memleak
+}
+
+void test__QFile__size__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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
new file mode 100644
index 000000000..e6aadeaf3
--- /dev/null
+++ b/test/cfg/generated-cfg-tests-sdl.cpp
@@ -0,0 +1,122 @@
+// auto generated tests from cfg/sdl.cfg
+//
+// Generated by command:
+// ./generate_cfg_tests cfg/sdl.cfg > generated-cfg-tests-sdl.cpp
+//
+// Recommended cppcheck command line:
+// $ cppcheck --enable=warning,information --inline-suppr generated-cfg-tests-sdl.cpp
+// => 'unmatched suppression' warnings are false negatives.
+//
+
+void test__SDL_mutexP__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__notnull() {
+  // cppcheck-suppress nullPointer
+  SDL_mutexP(NULL);
+}
+
+void test__SDL_mutexV__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__notnull() {
+  // cppcheck-suppress nullPointer
+  SDL_mutexV(NULL);
+}
+
+void test__SDL_RWsize__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__notnull() {
+  // cppcheck-suppress nullPointer
+  SDL_RWsize(NULL);
+}
+
+void test__SDL_RWread__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__notnull() {
+  // cppcheck-suppress nullPointer
+  SDL_RWread(arg1, NULL);
+}
+
+void test__IMG_isPNG__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__notnull() {
+  // cppcheck-suppress nullPointer
+  IMG_isPNG(NULL);
+}
+
+void test__IMG_isJPG__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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
new file mode 100644
index 000000000..572cddc3c
--- /dev/null
+++ b/test/cfg/generated-cfg-tests-sfml.cpp
@@ -0,0 +1,1939 @@
+// auto generated tests from cfg/sfml.cfg
+//
+// Generated by command:
+// ./generate_cfg_tests cfg/sfml.cfg > generated-cfg-tests-sfml.cpp
+//
+// Recommended cppcheck command line:
+// $ cppcheck --enable=warning,information --inline-suppr generated-cfg-tests-sfml.cpp
+// => 'unmatched suppression' warnings are false negatives.
+//
+
+void test__sf__err__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = sf::err();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__err__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::err();
+}
+
+void test__sf__err__leakignore() {
+  char *p = strdup(str);
+  result = sf::err();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__sleep__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::sleep(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__sleep__leakignore() {
+  char *p = strdup(str);
+  sf::sleep(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__sleep__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::sleep(x);
+}
+
+void test__sf__Time__asSeconds__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__asSeconds__leakignore() {
+  char *p = strdup(str);
+  result = sf::Time::asSeconds();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Time__asMilliseconds__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__asMilliseconds__leakignore() {
+  char *p = strdup(str);
+  result = sf::Time::asMilliseconds();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Time__asMicroseconds__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__Time__asMicroseconds__leakignore() {
+  char *p = strdup(str);
+  result = sf::Time::asMicroseconds();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__String__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::String::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__String__clear__leakignore() {
+  char *p = strdup(str);
+  sf::String::clear();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__String__isEmpty__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__isEmpty__leakignore() {
+  char *p = strdup(str);
+  result = sf::String::isEmpty();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__String__getSize__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__getSize__leakignore() {
+  char *p = strdup(str);
+  result = sf::String::getSize();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__String__find__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::String::find(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__String__find__leakignore() {
+  char *p = strdup(str);
+  sf::String::find(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = sf::String::substring(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else sf::String::erase(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__String__erase__leakignore() {
+  char *p = strdup(str);
+  sf::String::erase(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else sf::RenderTarget::clear(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTarget__clear__leakignore() {
+  char *p = strdup(str);
+  sf::RenderTarget::clear(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTarget__clear__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTarget::clear(x);
+}
+
+void test__sf__RenderWindow__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::clear(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__clear__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::clear(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__clear__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::clear(x);
+}
+
+void test__sf__RenderTexture__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderTexture::clear(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__clear__leakignore() {
+  char *p = strdup(str);
+  sf::RenderTexture::clear(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTexture__clear__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTexture::clear(x);
+}
+
+void test__sf__RenderTarget__setView__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderTarget::setView(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTarget__setView__leakignore() {
+  char *p = strdup(str);
+  sf::RenderTarget::setView(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTarget__setView__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTarget::setView(x);
+}
+
+void test__sf__RenderWindow__setView__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::setView(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setView__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::setView(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__setView__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setView(x);
+}
+
+void test__sf__RenderTexture__setView__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderTexture::setView(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__setView__leakignore() {
+  char *p = strdup(str);
+  sf::RenderTexture::setView(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTexture__setView__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTexture::setView(x);
+}
+
+void test__sf__RenderTarget__getView__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__getView__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderTarget::getView();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTarget__getDefaultView__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__RenderTarget__getDefaultView__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderTarget::getDefaultView();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__getView__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__getView__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderWindow::getView();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__getDefaultView__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__RenderWindow__getDefaultView__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderWindow::getDefaultView();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTexture__getView__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__getView__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderTexture::getView();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTexture__getDefaultView__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__RenderTexture__getDefaultView__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderTexture::getDefaultView();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTarget__getViewport__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderTarget::getViewport(p);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderWindow::getViewport(p);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderTexture::getViewport(p);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderTarget::mapPixelToCoords(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderTarget::mapCoordsToPixel(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderWindow::mapPixelToCoords(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderWindow::mapCoordsToPixel(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderTexture::mapPixelToCoords(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderTexture::mapCoordsToPixel(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else sf::RenderTarget::draw(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTarget__draw__leakignore() {
+  char *p = strdup(str);
+  sf::RenderTarget::draw(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else sf::RenderWindow::draw(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__draw__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::draw(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else sf::RenderTexture::draw(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__draw__leakignore() {
+  char *p = strdup(str);
+  sf::RenderTexture::draw(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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__RenderTarget__getSize__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderTarget::getSize();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__getSize__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__RenderWindow__getSize__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderWindow::getSize();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTexture__getSize__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__RenderTexture__getSize__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderTexture::getSize();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTarget__setActive__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderTarget::setActive(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTarget__setActive__leakignore() {
+  char *p = strdup(str);
+  sf::RenderTarget::setActive(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTarget__setActive__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTarget::setActive(x);
+}
+
+void test__sf__RenderWindow__setActive__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::setActive(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setActive__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::setActive(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__setActive__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setActive(x);
+}
+
+void test__sf__RenderTexture__setActive__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderTexture::setActive(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__setActive__leakignore() {
+  char *p = strdup(str);
+  sf::RenderTexture::setActive(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTexture__setActive__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderTexture::setActive(x);
+}
+
+void test__sf__Window__setActive__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::setActive(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setActive__leakignore() {
+  char *p = strdup(str);
+  sf::Window::setActive(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__setActive__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setActive(x);
+}
+
+void test__sf__RenderTarget__pushGLStates__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderTarget::pushGLStates();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTarget__pushGLStates__leakignore() {
+  char *p = strdup(str);
+  sf::RenderTarget::pushGLStates();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTarget__popGLStates__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderTarget::popGLStates();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTarget__popGLStates__leakignore() {
+  char *p = strdup(str);
+  sf::RenderTarget::popGLStates();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTarget__resetGLStates__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderTarget::resetGLStates();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTarget__resetGLStates__leakignore() {
+  char *p = strdup(str);
+  sf::RenderTarget::resetGLStates();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__pushGLStates__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::pushGLStates();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__pushGLStates__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::pushGLStates();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__popGLStates__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::popGLStates();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__popGLStates__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::popGLStates();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__resetGLStates__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::resetGLStates();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__resetGLStates__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::resetGLStates();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTexture__pushGLStates__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderTexture::pushGLStates();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__pushGLStates__leakignore() {
+  char *p = strdup(str);
+  sf::RenderTexture::pushGLStates();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTexture__popGLStates__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderTexture::popGLStates();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__popGLStates__leakignore() {
+  char *p = strdup(str);
+  sf::RenderTexture::popGLStates();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderTexture__resetGLStates__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderTexture::resetGLStates();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderTexture__resetGLStates__leakignore() {
+  char *p = strdup(str);
+  sf::RenderTexture::resetGLStates();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__create__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::create(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__create__leakignore() {
+  char *p = strdup(str);
+  sf::Window::create(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else sf::RenderWindow::create(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__create__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::create(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else sf::Window::close();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__close__leakignore() {
+  char *p = strdup(str);
+  sf::Window::close();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__close__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::close();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__close__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::close();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__isOpen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__Window__isOpen__leakignore() {
+  char *p = strdup(str);
+  result = sf::Window::isOpen();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__isOpen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__RenderWindow__isOpen__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderWindow::isOpen();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__getSettings__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__Window__getSettings__leakignore() {
+  char *p = strdup(str);
+  result = sf::Window::getSettings();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__getSettings__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__RenderWindow__getSettings__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderWindow::getSettings();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__pollEvent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::pollEvent(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__pollEvent__leakignore() {
+  char *p = strdup(str);
+  sf::Window::pollEvent(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__waitEvent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::waitEvent(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__waitEvent__leakignore() {
+  char *p = strdup(str);
+  sf::Window::waitEvent(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__pollEvent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::pollEvent(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__pollEvent__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::pollEvent(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__waitEvent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::waitEvent(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__waitEvent__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::waitEvent(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__getPosition__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__Window__getPosition__leakignore() {
+  char *p = strdup(str);
+  result = sf::Window::getPosition();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__getPosition__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__RenderWindow__getPosition__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderWindow::getPosition();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__setPosition__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::setPosition(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setPosition__leakignore() {
+  char *p = strdup(str);
+  sf::Window::setPosition(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__setPosition__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setPosition(x);
+}
+
+void test__sf__RenderWindow__setPosition__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::setPosition(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setPosition__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::setPosition(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__setPosition__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setPosition(x);
+}
+
+void test__sf__Window__getSize__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__Window__getSize__leakignore() {
+  char *p = strdup(str);
+  result = sf::Window::getSize();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__getSize__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__RenderWindow__getSize__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderWindow::getSize();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__setSize__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::setSize(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setSize__leakignore() {
+  char *p = strdup(str);
+  sf::Window::setSize(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__setSize__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setSize(x);
+}
+
+void test__sf__RenderWindow__setSize__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::setSize(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setSize__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::setSize(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__setSize__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setSize(x);
+}
+
+void test__sf__Window__setTitle__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::setTitle(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setTitle__leakignore() {
+  char *p = strdup(str);
+  sf::Window::setTitle(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__setTitle__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setTitle(x);
+}
+
+void test__sf__RenderWindow__setTitle__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::setTitle(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setTitle__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::setTitle(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__setTitle__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setTitle(x);
+}
+
+void test__sf__Window__setIcon__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::setIcon(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setIcon__leakignore() {
+  char *p = strdup(str);
+  sf::Window::setIcon(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else sf::RenderWindow::setIcon(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setIcon__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::setIcon(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else sf::Window::setVisible(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setVisible__leakignore() {
+  char *p = strdup(str);
+  sf::Window::setVisible(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__setVisible__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setVisible(x);
+}
+
+void test__sf__Window__setVerticalSyncEnabled__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::setVerticalSyncEnabled(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setVerticalSyncEnabled__leakignore() {
+  char *p = strdup(str);
+  sf::Window::setVerticalSyncEnabled(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__setVerticalSyncEnabled__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setVerticalSyncEnabled(x);
+}
+
+void test__sf__Window__setMouseCursorVisible__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::setMouseCursorVisible(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setMouseCursorVisible__leakignore() {
+  char *p = strdup(str);
+  sf::Window::setMouseCursorVisible(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__setMouseCursorVisible__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setMouseCursorVisible(x);
+}
+
+void test__sf__Window__setMouseCursorGrabbed__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::setMouseCursorGrabbed(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setMouseCursorGrabbed__leakignore() {
+  char *p = strdup(str);
+  sf::Window::setMouseCursorGrabbed(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__setMouseCursorGrabbed__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setMouseCursorGrabbed(x);
+}
+
+void test__sf__Window__setKeyRepeatEnabled__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::setKeyRepeatEnabled(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setKeyRepeatEnabled__leakignore() {
+  char *p = strdup(str);
+  sf::Window::setKeyRepeatEnabled(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__setKeyRepeatEnabled__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setKeyRepeatEnabled(x);
+}
+
+void test__sf__RenderWindow__setVisible__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::setVisible(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setVisible__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::setVisible(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__setVisible__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setVisible(x);
+}
+
+void test__sf__RenderWindow__setVerticalSyncEnabled__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::setVerticalSyncEnabled(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setVerticalSyncEnabled__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::setVerticalSyncEnabled(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__setVerticalSyncEnabled__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setVerticalSyncEnabled(x);
+}
+
+void test__sf__RenderWindow__setMouseCursorVisible__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::setMouseCursorVisible(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setMouseCursorVisible__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::setMouseCursorVisible(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__setMouseCursorVisible__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setMouseCursorVisible(x);
+}
+
+void test__sf__RenderWindow__setMouseCursorGrabbed__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::setMouseCursorGrabbed(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setMouseCursorGrabbed__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::setMouseCursorGrabbed(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__setMouseCursorGrabbed__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setMouseCursorGrabbed(x);
+}
+
+void test__sf__RenderWindow__setKeyRepeatEnabled__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::setKeyRepeatEnabled(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setKeyRepeatEnabled__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::setKeyRepeatEnabled(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__setKeyRepeatEnabled__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setKeyRepeatEnabled(x);
+}
+
+void test__sf__Window__setFramerateLimit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::setFramerateLimit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setFramerateLimit__leakignore() {
+  char *p = strdup(str);
+  sf::Window::setFramerateLimit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__setFramerateLimit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setFramerateLimit(x);
+}
+
+void test__sf__RenderWindow__setFramerateLimit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::setFramerateLimit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setFramerateLimit__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::setFramerateLimit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__setFramerateLimit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setFramerateLimit(x);
+}
+
+void test__sf__Window__setJoystickThreshold__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::setJoystickThreshold(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__setJoystickThreshold__leakignore() {
+  char *p = strdup(str);
+  sf::Window::setJoystickThreshold(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__setJoystickThreshold__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::Window::setJoystickThreshold(x);
+}
+
+void test__sf__RenderWindow__setJoystickThreshold__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::setJoystickThreshold(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__setJoystickThreshold__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::setJoystickThreshold(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__setJoystickThreshold__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sf::RenderWindow::setJoystickThreshold(x);
+}
+
+void test__sf__Window__requestFocus__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::requestFocus();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__requestFocus__leakignore() {
+  char *p = strdup(str);
+  sf::Window::requestFocus();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__requestFocus__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::requestFocus();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__requestFocus__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::requestFocus();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__hasFocus__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__Window__hasFocus__leakignore() {
+  char *p = strdup(str);
+  result = sf::Window::hasFocus();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__hasFocus__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__RenderWindow__hasFocus__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderWindow::hasFocus();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__display__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::Window::display();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__Window__display__leakignore() {
+  char *p = strdup(str);
+  sf::Window::display();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__display__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sf::RenderWindow::display();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__display__leakignore() {
+  char *p = strdup(str);
+  sf::RenderWindow::display();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__Window__getSystemHandle__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__Window__getSystemHandle__leakignore() {
+  char *p = strdup(str);
+  result = sf::Window::getSystemHandle();
+  // cppcheck-suppress memleak
+}
+
+void test__sf__RenderWindow__getSystemHandle__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = sf::RenderWindow::getSystemHandle();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sf__RenderWindow__getSystemHandle__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  sf::RenderWindow::getSystemHandle();
+}
+
+void test__sf__RenderWindow__getSystemHandle__leakignore() {
+  char *p = strdup(str);
+  result = sf::RenderWindow::getSystemHandle();
+  // cppcheck-suppress memleak
+}
+
diff --git a/test/cfg/generated-cfg-tests-std.cpp b/test/cfg/generated-cfg-tests-std.cpp
new file mode 100644
index 000000000..834194135
--- /dev/null
+++ b/test/cfg/generated-cfg-tests-std.cpp
@@ -0,0 +1,31762 @@
+// auto generated tests from cfg/std.cfg
+//
+// Generated by command:
+// ./generate_cfg_tests cfg/std.cfg > generated-cfg-tests-std.cpp
+//
+// Recommended cppcheck command line:
+// $ cppcheck --enable=warning,information --inline-suppr generated-cfg-tests-std.cpp
+// => 'unmatched suppression' warnings are false negatives.
+//
+
+void test__abort__noreturn() {
+  int x = 100;
+  if (cond) x=1; else abort();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__abort__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::abort();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__abs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = abs(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = abs(p);
+  // cppcheck-suppress memleak
+}
+
+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__std__abs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::abs(arg1) > 10) || (std::abs(arg1) < 100)) {}
+}
+
+void test__std__abs__leakignore() {
+  char *p = strdup(str);
+  result = std::abs(p);
+  // cppcheck-suppress memleak
+}
+
+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__imaxabs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = imaxabs(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = imaxabs(p);
+  // cppcheck-suppress memleak
+}
+
+void test__imaxabs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = imaxabs(x);
+}
+
+void test__std__imaxabs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::imaxabs(arg1) > 10) || (std::imaxabs(arg1) < 100)) {}
+}
+
+void test__std__imaxabs__leakignore() {
+  char *p = strdup(str);
+  result = std::imaxabs(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__imaxabs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::imaxabs(x);
+}
+
+void test__std__proj__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::proj(arg1) > 10) || (std::proj(arg1) < 100)) {}
+}
+
+void test__std__proj__leakignore() {
+  char *p = strdup(str);
+  result = std::proj(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__proj__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::proj(x);
+}
+
+void test__cproj__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cproj(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = cproj(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cproj__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cproj(x);
+}
+
+void test__cprojf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cprojf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = cprojf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cprojf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cprojf(x);
+}
+
+void test__cprojl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cprojl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = cprojl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cprojl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cprojl(x);
+}
+
+void test__creal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = creal(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = creal(p);
+  // cppcheck-suppress memleak
+}
+
+void test__creal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = creal(x);
+}
+
+void test__crealf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = crealf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = crealf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__crealf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = crealf(x);
+}
+
+void test__creall__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = creall(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = creall(p);
+  // cppcheck-suppress memleak
+}
+
+void test__creall__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = creall(x);
+}
+
+void test__acos__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = acos(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = acos(p);
+  // cppcheck-suppress memleak
+}
+
+void test__acos__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = acos(x);
+}
+
+void test__std__acos__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::acos(arg1) > 10) || (std::acos(arg1) < 100)) {}
+}
+
+void test__std__acos__leakignore() {
+  char *p = strdup(str);
+  result = std::acos(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__acos__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::acos(x);
+}
+
+void test__acosf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = acosf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = acosf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__acosf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = acosf(x);
+}
+
+void test__std__acosf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::acosf(arg1) > 10) || (std::acosf(arg1) < 100)) {}
+}
+
+void test__std__acosf__leakignore() {
+  char *p = strdup(str);
+  result = std::acosf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__acosf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::acosf(x);
+}
+
+void test__acosl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = acosl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = acosl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__acosl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = acosl(x);
+}
+
+void test__std__acosl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::acosl(arg1) > 10) || (std::acosl(arg1) < 100)) {}
+}
+
+void test__std__acosl__leakignore() {
+  char *p = strdup(str);
+  result = std::acosl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__acosl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::acosl(x);
+}
+
+void test__acosh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = acosh(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = acosh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__acosh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = acosh(x);
+}
+
+void test__std__acosh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::acosh(arg1) > 10) || (std::acosh(arg1) < 100)) {}
+}
+
+void test__std__acosh__leakignore() {
+  char *p = strdup(str);
+  result = std::acosh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__acosh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::acosh(x);
+}
+
+void test__acoshf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = acoshf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = acoshf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__acoshf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = acoshf(x);
+}
+
+void test__std__acoshf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::acoshf(arg1) > 10) || (std::acoshf(arg1) < 100)) {}
+}
+
+void test__std__acoshf__leakignore() {
+  char *p = strdup(str);
+  result = std::acoshf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__acoshf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::acoshf(x);
+}
+
+void test__acoshl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = acoshl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = acoshl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__acoshl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = acoshl(x);
+}
+
+void test__std__acoshl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::acoshl(arg1) > 10) || (std::acoshl(arg1) < 100)) {}
+}
+
+void test__std__acoshl__leakignore() {
+  char *p = strdup(str);
+  result = std::acoshl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__acoshl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::acoshl(x);
+}
+
+void test__asctime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = asctime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__asctime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  asctime(arg1);
+}
+
+void test__asctime__leakignore() {
+  char *p = strdup(str);
+  result = asctime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__asctime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = asctime(NULL);
+}
+
+void test__asctime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = asctime(x);
+}
+
+void test__std__asctime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::asctime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__asctime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::asctime(NULL);
+}
+
+void test__std__asctime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::asctime(x);
+}
+
+void test__assert__leakignore() {
+  char *p = strdup(str);
+  assert(p);
+  // cppcheck-suppress memleak
+}
+
+void test__assert__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  assert(x);
+}
+
+void test__sqrt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = sqrt(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = sqrt(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sqrt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sqrt(x);
+}
+
+void test__std__sqrt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sqrt(arg1) > 10) || (std::sqrt(arg1) < 100)) {}
+}
+
+void test__std__sqrt__leakignore() {
+  char *p = strdup(str);
+  result = std::sqrt(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__sqrt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sqrt(x);
+}
+
+void test__sqrtf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = sqrtf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = sqrtf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sqrtf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sqrtf(x);
+}
+
+void test__std__sqrtf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sqrtf(arg1) > 10) || (std::sqrtf(arg1) < 100)) {}
+}
+
+void test__std__sqrtf__leakignore() {
+  char *p = strdup(str);
+  result = std::sqrtf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__sqrtf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sqrtf(x);
+}
+
+void test__sqrtl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = sqrtl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = sqrtl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sqrtl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sqrtl(x);
+}
+
+void test__std__sqrtl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sqrtl(arg1) > 10) || (std::sqrtl(arg1) < 100)) {}
+}
+
+void test__std__sqrtl__leakignore() {
+  char *p = strdup(str);
+  result = std::sqrtl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__sqrtl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sqrtl(x);
+}
+
+void test__csqrt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = csqrt(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = csqrt(p);
+  // cppcheck-suppress memleak
+}
+
+void test__csqrt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csqrt(x);
+}
+
+void test__csqrtf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = csqrtf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = csqrtf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__csqrtf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csqrtf(x);
+}
+
+void test__csqrtl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = csqrtl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = csqrtl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__csqrtl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csqrtl(x);
+}
+
+void test__sinh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = sinh(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = sinh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sinh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sinh(x);
+}
+
+void test__std__sinh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sinh(arg1) > 10) || (std::sinh(arg1) < 100)) {}
+}
+
+void test__std__sinh__leakignore() {
+  char *p = strdup(str);
+  result = std::sinh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__sinh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sinh(x);
+}
+
+void test__sinhf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = sinhf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = sinhf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sinhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sinhf(x);
+}
+
+void test__std__sinhf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sinhf(arg1) > 10) || (std::sinhf(arg1) < 100)) {}
+}
+
+void test__std__sinhf__leakignore() {
+  char *p = strdup(str);
+  result = std::sinhf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__sinhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sinhf(x);
+}
+
+void test__sinhl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = sinhl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = sinhl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sinhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sinhl(x);
+}
+
+void test__std__sinhl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sinhl(arg1) > 10) || (std::sinhl(arg1) < 100)) {}
+}
+
+void test__std__sinhl__leakignore() {
+  char *p = strdup(str);
+  result = std::sinhl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__sinhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sinhl(x);
+}
+
+void test__sin__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = sin(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = sin(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sin(x);
+}
+
+void test__std__sin__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sin(arg1) > 10) || (std::sin(arg1) < 100)) {}
+}
+
+void test__std__sin__leakignore() {
+  char *p = strdup(str);
+  result = std::sin(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__sin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sin(x);
+}
+
+void test__sinf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = sinf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = sinf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sinf(x);
+}
+
+void test__std__sinf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sinf(arg1) > 10) || (std::sinf(arg1) < 100)) {}
+}
+
+void test__std__sinf__leakignore() {
+  char *p = strdup(str);
+  result = std::sinf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__sinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sinf(x);
+}
+
+void test__sinl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = sinl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = sinl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__sinl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = sinl(x);
+}
+
+void test__std__sinl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::sinl(arg1) > 10) || (std::sinl(arg1) < 100)) {}
+}
+
+void test__std__sinl__leakignore() {
+  char *p = strdup(str);
+  result = std::sinl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__sinl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::sinl(x);
+}
+
+void test__csin__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = csin(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = csin(p);
+  // cppcheck-suppress memleak
+}
+
+void test__csin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csin(x);
+}
+
+void test__csinf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = csinf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = csinf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__csinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csinf(x);
+}
+
+void test__csinl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = csinl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = csinl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__csinl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csinl(x);
+}
+
+void test__csinh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = csinh(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = csinh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__csinh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csinh(x);
+}
+
+void test__csinhf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = csinhf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = csinhf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__csinhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csinhf(x);
+}
+
+void test__csinhl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = csinhl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = csinhl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__csinhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = csinhl(x);
+}
+
+void test__asin__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = asin(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = asin(p);
+  // cppcheck-suppress memleak
+}
+
+void test__asin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = asin(x);
+}
+
+void test__std__asin__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::asin(arg1) > 10) || (std::asin(arg1) < 100)) {}
+}
+
+void test__std__asin__leakignore() {
+  char *p = strdup(str);
+  result = std::asin(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__asin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::asin(x);
+}
+
+void test__asinf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = asinf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = asinf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__asinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = asinf(x);
+}
+
+void test__std__asinf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::asinf(arg1) > 10) || (std::asinf(arg1) < 100)) {}
+}
+
+void test__std__asinf__leakignore() {
+  char *p = strdup(str);
+  result = std::asinf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__asinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::asinf(x);
+}
+
+void test__asinl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = asinl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = asinl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__asinl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = asinl(x);
+}
+
+void test__std__asinl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::asinl(arg1) > 10) || (std::asinl(arg1) < 100)) {}
+}
+
+void test__std__asinl__leakignore() {
+  char *p = strdup(str);
+  result = std::asinl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__asinl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::asinl(x);
+}
+
+void test__casin__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = casin(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = casin(p);
+  // cppcheck-suppress memleak
+}
+
+void test__casin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = casin(x);
+}
+
+void test__casinf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = casinf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = casinf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__casinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = casinf(x);
+}
+
+void test__casinl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = casinl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = casinl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__casinl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = casinl(x);
+}
+
+void test__asinh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = asinh(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = asinh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__asinh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = asinh(x);
+}
+
+void test__std__asinh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::asinh(arg1) > 10) || (std::asinh(arg1) < 100)) {}
+}
+
+void test__std__asinh__leakignore() {
+  char *p = strdup(str);
+  result = std::asinh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__asinh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::asinh(x);
+}
+
+void test__asinhf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = asinhf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = asinhf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__asinhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = asinhf(x);
+}
+
+void test__std__asinhf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::asinhf(arg1) > 10) || (std::asinhf(arg1) < 100)) {}
+}
+
+void test__std__asinhf__leakignore() {
+  char *p = strdup(str);
+  result = std::asinhf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__asinhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::asinhf(x);
+}
+
+void test__asinhl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = asinhl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = asinhl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__asinhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = asinhl(x);
+}
+
+void test__std__asinhl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::asinhl(arg1) > 10) || (std::asinhl(arg1) < 100)) {}
+}
+
+void test__std__asinhl__leakignore() {
+  char *p = strdup(str);
+  result = std::asinhl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__asinhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::asinhl(x);
+}
+
+void test__casinh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = casinh(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = casinh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__casinh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = casinh(x);
+}
+
+void test__casinhf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = casinhf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = casinhf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__casinhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = casinhf(x);
+}
+
+void test__casinhl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = casinhl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = casinhl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__casinhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = casinhl(x);
+}
+
+void test__wcsftime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  wcsftime(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__wcsftime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsftime(NULL, arg2, 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__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__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsftime(arg1, arg2, arg3, x);
+}
+
+void test__std__wcsftime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  std::wcsftime(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcsftime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsftime(NULL, arg2, 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__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__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcsftime(arg1, arg2, arg3, x);
+}
+
+void test__tan__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = tan(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = tan(p);
+  // cppcheck-suppress memleak
+}
+
+void test__tan__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tan(x);
+}
+
+void test__std__tan__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::tan(arg1) > 10) || (std::tan(arg1) < 100)) {}
+}
+
+void test__std__tan__leakignore() {
+  char *p = strdup(str);
+  result = std::tan(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__tan__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tan(x);
+}
+
+void test__tanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = tanf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = tanf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__tanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tanf(x);
+}
+
+void test__std__tanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::tanf(arg1) > 10) || (std::tanf(arg1) < 100)) {}
+}
+
+void test__std__tanf__leakignore() {
+  char *p = strdup(str);
+  result = std::tanf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__tanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tanf(x);
+}
+
+void test__tanl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = tanl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = tanl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__tanl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tanl(x);
+}
+
+void test__std__tanl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::tanl(arg1) > 10) || (std::tanl(arg1) < 100)) {}
+}
+
+void test__std__tanl__leakignore() {
+  char *p = strdup(str);
+  result = std::tanl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__tanl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tanl(x);
+}
+
+void test__ctan__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ctan(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = ctan(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ctan__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ctan(x);
+}
+
+void test__ctanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ctanf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = ctanf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ctanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ctanf(x);
+}
+
+void test__ctanl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ctanl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = ctanl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ctanl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ctanl(x);
+}
+
+void test__tanh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = tanh(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = tanh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__tanh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tanh(x);
+}
+
+void test__std__tanh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::tanh(arg1) > 10) || (std::tanh(arg1) < 100)) {}
+}
+
+void test__std__tanh__leakignore() {
+  char *p = strdup(str);
+  result = std::tanh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__tanh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tanh(x);
+}
+
+void test__tanhf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = tanhf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = tanhf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__tanhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tanhf(x);
+}
+
+void test__std__tanhf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::tanhf(arg1) > 10) || (std::tanhf(arg1) < 100)) {}
+}
+
+void test__std__tanhf__leakignore() {
+  char *p = strdup(str);
+  result = std::tanhf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__tanhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tanhf(x);
+}
+
+void test__tanhl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = tanhl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = tanhl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__tanhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tanhl(x);
+}
+
+void test__std__tanhl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::tanhl(arg1) > 10) || (std::tanhl(arg1) < 100)) {}
+}
+
+void test__std__tanhl__leakignore() {
+  char *p = strdup(str);
+  result = std::tanhl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__tanhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tanhl(x);
+}
+
+void test__ctanh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ctanh(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = ctanh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ctanh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ctanh(x);
+}
+
+void test__ctanhf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ctanhf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = ctanhf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ctanhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ctanhf(x);
+}
+
+void test__ctanhl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ctanhl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__leakignore() {
+  char *p = strdup(str);
+  result = ctanhl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ctanhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ctanhl(x);
+}
+
+void test__feclearexcept__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  feclearexcept(p);
+  // cppcheck-suppress memleak
+}
+
+void test__feclearexcept__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  feclearexcept(x);
+}
+
+void test__std__feclearexcept__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  std::feclearexcept(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__feclearexcept__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::feclearexcept(x);
+}
+
+void test__fegetenv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fegetenv(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fegetenv__leakignore() {
+  char *p = strdup(str);
+  fegetenv(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fegetenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fegetenv(NULL);
+}
+
+void test__std__fegetenv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fegetenv(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fegetenv__leakignore() {
+  char *p = strdup(str);
+  std::fegetenv(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fegetenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fegetenv(NULL);
+}
+
+void test__fegetexceptflag__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fegetexceptflag(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fegetexceptflag__leakignore() {
+  char *p = strdup(str);
+  fegetexceptflag(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fegetexceptflag__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fegetexceptflag(NULL, arg2);
+}
+
+void test__fegetexceptflag__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fegetexceptflag(arg1, x);
+}
+
+void test__std__fegetexceptflag__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fegetexceptflag(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fegetexceptflag__leakignore() {
+  char *p = strdup(str);
+  std::fegetexceptflag(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fegetexceptflag__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fegetexceptflag(NULL, arg2);
+}
+
+void test__std__fegetexceptflag__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fegetexceptflag(arg1, x);
+}
+
+void test__fegetround__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  result = fegetround();
+  // cppcheck-suppress memleak
+}
+
+void test__std__fegetround__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__std__fegetround__leakignore() {
+  char *p = strdup(str);
+  result = std::fegetround();
+  // cppcheck-suppress memleak
+}
+
+void test__feholdexcept__noreturn() {
+  int x = 100;
+  if (cond) x=1; else feholdexcept(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__feholdexcept__leakignore() {
+  char *p = strdup(str);
+  feholdexcept(p);
+  // cppcheck-suppress memleak
+}
+
+void test__feholdexcept__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  feholdexcept(NULL);
+}
+
+void test__std__feholdexcept__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::feholdexcept(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__feholdexcept__leakignore() {
+  char *p = strdup(str);
+  std::feholdexcept(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__feholdexcept__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::feholdexcept(NULL);
+}
+
+void test__feraiseexcept__noreturn() {
+  int x = 100;
+  if (cond) x=1; else feraiseexcept(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__feraiseexcept__leakignore() {
+  char *p = strdup(str);
+  feraiseexcept(p);
+  // cppcheck-suppress memleak
+}
+
+void test__feraiseexcept__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  feraiseexcept(x);
+}
+
+void test__std__feraiseexcept__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::feraiseexcept(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__feraiseexcept__leakignore() {
+  char *p = strdup(str);
+  std::feraiseexcept(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__feraiseexcept__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::feraiseexcept(x);
+}
+
+void test__fesetenv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fesetenv(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fesetenv__leakignore() {
+  char *p = strdup(str);
+  fesetenv(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fesetenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fesetenv(NULL);
+}
+
+void test__fesetenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fesetenv(x);
+}
+
+void test__std__fesetenv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fesetenv(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fesetenv__leakignore() {
+  char *p = strdup(str);
+  std::fesetenv(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fesetenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fesetenv(NULL);
+}
+
+void test__std__fesetenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fesetenv(x);
+}
+
+void test__fesetexceptflag__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fesetexceptflag(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fesetexceptflag__leakignore() {
+  char *p = strdup(str);
+  fesetexceptflag(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fesetexceptflag__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fesetexceptflag(NULL, arg2);
+}
+
+void test__fesetexceptflag__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fesetexceptflag(x, arg2);
+}
+
+void test__fesetexceptflag__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fesetexceptflag(arg1, x);
+}
+
+void test__std__fesetexceptflag__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fesetexceptflag(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fesetexceptflag__leakignore() {
+  char *p = strdup(str);
+  std::fesetexceptflag(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else fesetround(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fesetround__leakignore() {
+  char *p = strdup(str);
+  fesetround(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fesetround__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fesetround(x);
+}
+
+void test__std__fesetround__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fesetround(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fesetround__leakignore() {
+  char *p = strdup(str);
+  std::fesetround(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fesetround__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fesetround(x);
+}
+
+void test__fetestexcept__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fetestexcept(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fetestexcept__leakignore() {
+  char *p = strdup(str);
+  fetestexcept(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fetestexcept__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fetestexcept(x);
+}
+
+void test__std__fetestexcept__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fetestexcept(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fetestexcept__leakignore() {
+  char *p = strdup(str);
+  std::fetestexcept(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fetestexcept__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fetestexcept(x);
+}
+
+void test__feupdateenv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else feupdateenv(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__feupdateenv__leakignore() {
+  char *p = strdup(str);
+  feupdateenv(p);
+  // cppcheck-suppress memleak
+}
+
+void test__feupdateenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  feupdateenv(NULL);
+}
+
+void test__feupdateenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  feupdateenv(x);
+}
+
+void test__std__feupdateenv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::feupdateenv(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__feupdateenv__leakignore() {
+  char *p = strdup(str);
+  std::feupdateenv(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__feupdateenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::feupdateenv(NULL);
+}
+
+void test__std__feupdateenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::feupdateenv(x);
+}
+
+void test__atan__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::atan(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__atan__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atan(x);
+}
+
+void test__atanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::atanf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__atanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atanf(x);
+}
+
+void test__atanl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::atanl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__atanl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atanl(x);
+}
+
+void test__catan__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::tgamma(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__tgamma__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tgamma(x);
+}
+
+void test__tgammaf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::tgammaf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__tgammaf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tgammaf(x);
+}
+
+void test__tgammal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::tgammal(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__tgammal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tgammal(x);
+}
+
+void test__trunc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::trunc(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__trunc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::trunc(x);
+}
+
+void test__truncf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::truncf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__truncf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::truncf(x);
+}
+
+void test__truncl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::truncl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__truncl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::truncl(x);
+}
+
+void test__atanh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::atanh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__atanh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atanh(x);
+}
+
+void test__atanhf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::atanhf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__atanhf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atanhf(x);
+}
+
+void test__atanhl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::atanhl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__atanhl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::atanhl(x);
+}
+
+void test__catanh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::atan2(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::atan2f(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::atan2l(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  atexit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atexit__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  atexit(NULL);
+}
+
+void test__std__atexit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  std::atexit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__atexit__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::atexit(NULL);
+}
+
+void test__atoi__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  result = atoi(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atoi__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = atoi(NULL);
+}
+
+void test__atoi__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = atoi(x);
+}
+
+void test__std__atoi__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::atoi(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__atoi__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::atoi(NULL);
+}
+
+void test__std__atoi__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::atoi(x);
+}
+
+void test__atol__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  result = atol(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atol__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = atol(NULL);
+}
+
+void test__atol__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = atol(x);
+}
+
+void test__std__atol__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::atol(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__atol__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::atol(NULL);
+}
+
+void test__std__atol__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::atol(x);
+}
+
+void test__atoll__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  result = atoll(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = atoll(NULL);
+}
+
+void test__atoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = atoll(x);
+}
+
+void test__std__atoll__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::atoll(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__atoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::atoll(NULL);
+}
+
+void test__std__atoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::atoll(x);
+}
+
+void test__atof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  result = atof(p);
+  // cppcheck-suppress memleak
+}
+
+void test__atof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = atof(NULL);
+}
+
+void test__atof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = atof(x);
+}
+
+void test__std__atof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::atof(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__atof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::atof(NULL);
+}
+
+void test__std__atof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::atof(x);
+}
+
+void test__calloc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::ceil(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ceil__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ceil(x);
+}
+
+void test__ceilf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::ceilf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ceilf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ceilf(x);
+}
+
+void test__ceill__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::ceill(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ceill__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ceill(x);
+}
+
+void test__copysign__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::copysign(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::copysignf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::copysignl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else clearerr(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__clearerr__leakignore() {
+  char *p = strdup(str);
+  clearerr(p);
+  // cppcheck-suppress memleak
+}
+
+void test__clearerr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  clearerr(NULL);
+}
+
+void test__clearerr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  clearerr(x);
+}
+
+void test__std__clearerr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::clearerr(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__clearerr__leakignore() {
+  char *p = strdup(str);
+  std::clearerr(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__clearerr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::clearerr(NULL);
+}
+
+void test__std__clearerr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::clearerr(x);
+}
+
+void test__clock__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = clock();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__clock__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  clock();
+}
+
+void test__clock__leakignore() {
+  char *p = strdup(str);
+  result = clock();
+  // cppcheck-suppress memleak
+}
+
+void test__cbrt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::cbrt(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__cbrt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::cbrt(x);
+}
+
+void test__cbrtf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  result = cbrtf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cbrtf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cbrtf(x);
+}
+
+void test__std__cbrtf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::cbrtf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__cbrtf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::cbrtf(arg1);
+}
+
+void test__std__cbrtf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::cbrtf(arg1) > 10) || (std::cbrtf(arg1) < 100)) {}
+}
+
+void test__std__cbrtf__leakignore() {
+  char *p = strdup(str);
+  result = std::cbrtf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__cbrtf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::cbrtf(x);
+}
+
+void test__cbrtl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cbrtl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cbrtl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cbrtl(arg1);
+}
+
+void test__cbrtl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cbrtl(arg1) > 10) || (cbrtl(arg1) < 100)) {}
+}
+
+void test__cbrtl__leakignore() {
+  char *p = strdup(str);
+  result = cbrtl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cbrtl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cbrtl(x);
+}
+
+void test__std__cbrtl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::cbrtl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__cbrtl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::cbrtl(arg1);
+}
+
+void test__std__cbrtl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::cbrtl(arg1) > 10) || (std::cbrtl(arg1) < 100)) {}
+}
+
+void test__std__cbrtl__leakignore() {
+  char *p = strdup(str);
+  result = std::cbrtl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__cbrtl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::cbrtl(x);
+}
+
+void test__cos__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cos(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cos__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cos(arg1);
+}
+
+void test__cos__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cos(arg1) > 10) || (cos(arg1) < 100)) {}
+}
+
+void test__cos__leakignore() {
+  char *p = strdup(str);
+  result = cos(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cos__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cos(x);
+}
+
+void test__std__cos__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::cos(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__cos__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::cos(arg1);
+}
+
+void test__std__cos__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::cos(arg1) > 10) || (std::cos(arg1) < 100)) {}
+}
+
+void test__std__cos__leakignore() {
+  char *p = strdup(str);
+  result = std::cos(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__cos__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::cos(x);
+}
+
+void test__cosf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cosf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cosf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cosf(arg1);
+}
+
+void test__cosf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cosf(arg1) > 10) || (cosf(arg1) < 100)) {}
+}
+
+void test__cosf__leakignore() {
+  char *p = strdup(str);
+  result = cosf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cosf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cosf(x);
+}
+
+void test__std__cosf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::cosf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__cosf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::cosf(arg1);
+}
+
+void test__std__cosf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::cosf(arg1) > 10) || (std::cosf(arg1) < 100)) {}
+}
+
+void test__std__cosf__leakignore() {
+  char *p = strdup(str);
+  result = std::cosf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__cosf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::cosf(x);
+}
+
+void test__cosl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cosl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cosl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cosl(arg1);
+}
+
+void test__cosl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cosl(arg1) > 10) || (cosl(arg1) < 100)) {}
+}
+
+void test__cosl__leakignore() {
+  char *p = strdup(str);
+  result = cosl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cosl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cosl(x);
+}
+
+void test__std__cosl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::cosl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__cosl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::cosl(arg1);
+}
+
+void test__std__cosl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::cosl(arg1) > 10) || (std::cosl(arg1) < 100)) {}
+}
+
+void test__std__cosl__leakignore() {
+  char *p = strdup(str);
+  result = std::cosl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__cosl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::cosl(x);
+}
+
+void test__ccos__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ccos(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ccos__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ccos(arg1);
+}
+
+void test__ccos__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ccos(arg1) > 10) || (ccos(arg1) < 100)) {}
+}
+
+void test__ccos__leakignore() {
+  char *p = strdup(str);
+  result = ccos(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ccos__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ccos(x);
+}
+
+void test__ccosf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ccosf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ccosf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ccosf(arg1);
+}
+
+void test__ccosf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ccosf(arg1) > 10) || (ccosf(arg1) < 100)) {}
+}
+
+void test__ccosf__leakignore() {
+  char *p = strdup(str);
+  result = ccosf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ccosf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ccosf(x);
+}
+
+void test__ccosl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ccosl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ccosl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ccosl(arg1);
+}
+
+void test__ccosl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ccosl(arg1) > 10) || (ccosl(arg1) < 100)) {}
+}
+
+void test__ccosl__leakignore() {
+  char *p = strdup(str);
+  result = ccosl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ccosl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ccosl(x);
+}
+
+void test__cosh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cosh(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cosh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cosh(arg1);
+}
+
+void test__cosh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cosh(arg1) > 10) || (cosh(arg1) < 100)) {}
+}
+
+void test__cosh__leakignore() {
+  char *p = strdup(str);
+  result = cosh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cosh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cosh(x);
+}
+
+void test__std__cosh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::cosh(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__cosh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::cosh(arg1);
+}
+
+void test__std__cosh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::cosh(arg1) > 10) || (std::cosh(arg1) < 100)) {}
+}
+
+void test__std__cosh__leakignore() {
+  char *p = strdup(str);
+  result = std::cosh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__cosh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::cosh(x);
+}
+
+void test__coshf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = coshf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__coshf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  coshf(arg1);
+}
+
+void test__coshf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((coshf(arg1) > 10) || (coshf(arg1) < 100)) {}
+}
+
+void test__coshf__leakignore() {
+  char *p = strdup(str);
+  result = coshf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__coshf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = coshf(x);
+}
+
+void test__std__coshf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::coshf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__coshf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::coshf(arg1);
+}
+
+void test__std__coshf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::coshf(arg1) > 10) || (std::coshf(arg1) < 100)) {}
+}
+
+void test__std__coshf__leakignore() {
+  char *p = strdup(str);
+  result = std::coshf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__coshf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::coshf(x);
+}
+
+void test__coshl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = coshl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__coshl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  coshl(arg1);
+}
+
+void test__coshl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((coshl(arg1) > 10) || (coshl(arg1) < 100)) {}
+}
+
+void test__coshl__leakignore() {
+  char *p = strdup(str);
+  result = coshl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__coshl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = coshl(x);
+}
+
+void test__std__coshl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::coshl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__coshl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::coshl(arg1);
+}
+
+void test__std__coshl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::coshl(arg1) > 10) || (std::coshl(arg1) < 100)) {}
+}
+
+void test__std__coshl__leakignore() {
+  char *p = strdup(str);
+  result = std::coshl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__coshl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::coshl(x);
+}
+
+void test__ccosh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ccosh(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ccosh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ccosh(arg1);
+}
+
+void test__ccosh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ccosh(arg1) > 10) || (ccosh(arg1) < 100)) {}
+}
+
+void test__ccosh__leakignore() {
+  char *p = strdup(str);
+  result = ccosh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ccosh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ccosh(x);
+}
+
+void test__ccoshf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ccoshf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ccoshf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ccoshf(arg1);
+}
+
+void test__ccoshf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ccoshf(arg1) > 10) || (ccoshf(arg1) < 100)) {}
+}
+
+void test__ccoshf__leakignore() {
+  char *p = strdup(str);
+  result = ccoshf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ccoshf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ccoshf(x);
+}
+
+void test__ccoshl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ccoshl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ccoshl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ccoshl(arg1);
+}
+
+void test__ccoshl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ccoshl(arg1) > 10) || (ccoshl(arg1) < 100)) {}
+}
+
+void test__ccoshl__leakignore() {
+  char *p = strdup(str);
+  result = ccoshl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ccoshl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ccoshl(x);
+}
+
+void test__ctime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ctime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ctime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ctime(arg1);
+}
+
+void test__ctime__leakignore() {
+  char *p = strdup(str);
+  result = ctime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ctime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = ctime(NULL);
+}
+
+void test__ctime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = ctime(x);
+}
+
+void test__std__ctime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::ctime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ctime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ctime(arg1);
+}
+
+void test__std__ctime__leakignore() {
+  char *p = strdup(str);
+  result = std::ctime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ctime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::ctime(NULL);
+}
+
+void test__std__ctime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::ctime(x);
+}
+
+void test__difftime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = difftime(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__difftime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  difftime(arg1, arg2);
+}
+
+void test__difftime__leakignore() {
+  char *p = strdup(str);
+  result = difftime(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__difftime__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = difftime(x, arg2);
+}
+
+void test__difftime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = difftime(arg1, x);
+}
+
+void test__std__difftime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::difftime(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__difftime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::difftime(arg1, arg2);
+}
+
+void test__std__difftime__leakignore() {
+  char *p = strdup(str);
+  result = std::difftime(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__difftime__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::difftime(x, arg2);
+}
+
+void test__std__difftime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::difftime(arg1, x);
+}
+
+void test__div__noreturn() {
+  int x = 100;
+  if (cond) x=1; else div(arg1, arg2);
+  // 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__div__leakignore() {
+  char *p = strdup(str);
+  div(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__div__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  div(x, arg2);
+}
+
+void test__div__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  div(arg1, x);
+}
+
+void test__std__div__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::div(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__div__leakignore() {
+  char *p = strdup(str);
+  std::div(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__div__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::div(x, arg2);
+}
+
+void test__std__div__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::div(arg1, x);
+}
+
+void test__imaxdiv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else imaxdiv(arg1, arg2);
+  // 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__imaxdiv__leakignore() {
+  char *p = strdup(str);
+  imaxdiv(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__imaxdiv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  imaxdiv(x, arg2);
+}
+
+void test__imaxdiv__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  imaxdiv(arg1, x);
+}
+
+void test__std__imaxdiv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::imaxdiv(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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__imaxdiv__leakignore() {
+  char *p = strdup(str);
+  std::imaxdiv(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__imaxdiv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::imaxdiv(x, arg2);
+}
+
+void test__std__imaxdiv__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::imaxdiv(arg1, x);
+}
+
+void test__exit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else exit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__exit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  exit(x);
+}
+
+void test__std__exit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::exit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__exit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::exit(x);
+}
+
+void test__erf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = erf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__erf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  erf(arg1);
+}
+
+void test__erf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((erf(arg1) > 10) || (erf(arg1) < 100)) {}
+}
+
+void test__erf__leakignore() {
+  char *p = strdup(str);
+  result = erf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__erf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = erf(x);
+}
+
+void test__std__erf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::erf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__erf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::erf(arg1);
+}
+
+void test__std__erf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::erf(arg1) > 10) || (std::erf(arg1) < 100)) {}
+}
+
+void test__std__erf__leakignore() {
+  char *p = strdup(str);
+  result = std::erf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__erf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::erf(x);
+}
+
+void test__erff__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = erff(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__erff__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  erff(arg1);
+}
+
+void test__erff__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((erff(arg1) > 10) || (erff(arg1) < 100)) {}
+}
+
+void test__erff__leakignore() {
+  char *p = strdup(str);
+  result = erff(p);
+  // cppcheck-suppress memleak
+}
+
+void test__erff__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = erff(x);
+}
+
+void test__std__erff__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::erff(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__erff__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::erff(arg1);
+}
+
+void test__std__erff__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::erff(arg1) > 10) || (std::erff(arg1) < 100)) {}
+}
+
+void test__std__erff__leakignore() {
+  char *p = strdup(str);
+  result = std::erff(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__erff__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::erff(x);
+}
+
+void test__erfl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = erfl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__erfl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  erfl(arg1);
+}
+
+void test__erfl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((erfl(arg1) > 10) || (erfl(arg1) < 100)) {}
+}
+
+void test__erfl__leakignore() {
+  char *p = strdup(str);
+  result = erfl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__erfl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = erfl(x);
+}
+
+void test__std__erfl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::erfl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__erfl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::erfl(arg1);
+}
+
+void test__std__erfl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::erfl(arg1) > 10) || (std::erfl(arg1) < 100)) {}
+}
+
+void test__std__erfl__leakignore() {
+  char *p = strdup(str);
+  result = std::erfl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__erfl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::erfl(x);
+}
+
+void test__erfc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = erfc(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__erfc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  erfc(arg1);
+}
+
+void test__erfc__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((erfc(arg1) > 10) || (erfc(arg1) < 100)) {}
+}
+
+void test__erfc__leakignore() {
+  char *p = strdup(str);
+  result = erfc(p);
+  // cppcheck-suppress memleak
+}
+
+void test__erfc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = erfc(x);
+}
+
+void test__std__erfc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::erfc(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__erfc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::erfc(arg1);
+}
+
+void test__std__erfc__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::erfc(arg1) > 10) || (std::erfc(arg1) < 100)) {}
+}
+
+void test__std__erfc__leakignore() {
+  char *p = strdup(str);
+  result = std::erfc(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__erfc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::erfc(x);
+}
+
+void test__erfcf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = erfcf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__erfcf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  erfcf(arg1);
+}
+
+void test__erfcf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((erfcf(arg1) > 10) || (erfcf(arg1) < 100)) {}
+}
+
+void test__erfcf__leakignore() {
+  char *p = strdup(str);
+  result = erfcf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__erfcf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = erfcf(x);
+}
+
+void test__std__erfcf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::erfcf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__erfcf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::erfcf(arg1);
+}
+
+void test__std__erfcf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::erfcf(arg1) > 10) || (std::erfcf(arg1) < 100)) {}
+}
+
+void test__std__erfcf__leakignore() {
+  char *p = strdup(str);
+  result = std::erfcf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__erfcf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::erfcf(x);
+}
+
+void test__erfcl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = erfcl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__erfcl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  erfcl(arg1);
+}
+
+void test__erfcl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((erfcl(arg1) > 10) || (erfcl(arg1) < 100)) {}
+}
+
+void test__erfcl__leakignore() {
+  char *p = strdup(str);
+  result = erfcl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__erfcl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = erfcl(x);
+}
+
+void test__std__erfcl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::erfcl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__erfcl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::erfcl(arg1);
+}
+
+void test__std__erfcl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::erfcl(arg1) > 10) || (std::erfcl(arg1) < 100)) {}
+}
+
+void test__std__erfcl__leakignore() {
+  char *p = strdup(str);
+  result = std::erfcl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__erfcl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::erfcl(x);
+}
+
+void test__carg__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = carg(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__carg__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  carg(arg1);
+}
+
+void test__carg__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((carg(arg1) > 10) || (carg(arg1) < 100)) {}
+}
+
+void test__carg__leakignore() {
+  char *p = strdup(str);
+  result = carg(p);
+  // cppcheck-suppress memleak
+}
+
+void test__carg__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = carg(x);
+}
+
+void test__cargf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cargf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cargf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cargf(arg1);
+}
+
+void test__cargf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cargf(arg1) > 10) || (cargf(arg1) < 100)) {}
+}
+
+void test__cargf__leakignore() {
+  char *p = strdup(str);
+  result = cargf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cargf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cargf(x);
+}
+
+void test__cargl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cargl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cargl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cargl(arg1);
+}
+
+void test__cargl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cargl(arg1) > 10) || (cargl(arg1) < 100)) {}
+}
+
+void test__cargl__leakignore() {
+  char *p = strdup(str);
+  result = cargl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cargl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cargl(x);
+}
+
+void test__exp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = exp(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__exp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  exp(arg1);
+}
+
+void test__exp__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((exp(arg1) > 10) || (exp(arg1) < 100)) {}
+}
+
+void test__exp__leakignore() {
+  char *p = strdup(str);
+  result = exp(p);
+  // cppcheck-suppress memleak
+}
+
+void test__exp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = exp(x);
+}
+
+void test__std__exp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::exp(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__exp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::exp(arg1);
+}
+
+void test__std__exp__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::exp(arg1) > 10) || (std::exp(arg1) < 100)) {}
+}
+
+void test__std__exp__leakignore() {
+  char *p = strdup(str);
+  result = std::exp(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__exp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::exp(x);
+}
+
+void test__expf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = expf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__expf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  expf(arg1);
+}
+
+void test__expf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((expf(arg1) > 10) || (expf(arg1) < 100)) {}
+}
+
+void test__expf__leakignore() {
+  char *p = strdup(str);
+  result = expf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__expf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = expf(x);
+}
+
+void test__std__expf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::expf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__expf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::expf(arg1);
+}
+
+void test__std__expf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::expf(arg1) > 10) || (std::expf(arg1) < 100)) {}
+}
+
+void test__std__expf__leakignore() {
+  char *p = strdup(str);
+  result = std::expf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__expf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::expf(x);
+}
+
+void test__expl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = expl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__expl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  expl(arg1);
+}
+
+void test__expl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((expl(arg1) > 10) || (expl(arg1) < 100)) {}
+}
+
+void test__expl__leakignore() {
+  char *p = strdup(str);
+  result = expl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__expl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = expl(x);
+}
+
+void test__std__expl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::expl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__expl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::expl(arg1);
+}
+
+void test__std__expl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::expl(arg1) > 10) || (std::expl(arg1) < 100)) {}
+}
+
+void test__std__expl__leakignore() {
+  char *p = strdup(str);
+  result = std::expl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__expl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::expl(x);
+}
+
+void test__cexp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cexp(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cexp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cexp(arg1);
+}
+
+void test__cexp__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cexp(arg1) > 10) || (cexp(arg1) < 100)) {}
+}
+
+void test__cexp__leakignore() {
+  char *p = strdup(str);
+  result = cexp(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cexp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cexp(x);
+}
+
+void test__cexpf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cexpf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cexpf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cexpf(arg1);
+}
+
+void test__cexpf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cexpf(arg1) > 10) || (cexpf(arg1) < 100)) {}
+}
+
+void test__cexpf__leakignore() {
+  char *p = strdup(str);
+  result = cexpf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cexpf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cexpf(x);
+}
+
+void test__cexpl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cexpl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cexpl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cexpl(arg1);
+}
+
+void test__cexpl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cexpl(arg1) > 10) || (cexpl(arg1) < 100)) {}
+}
+
+void test__cexpl__leakignore() {
+  char *p = strdup(str);
+  result = cexpl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cexpl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cexpl(x);
+}
+
+void test__cimag__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cimag(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cimag__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cimag(arg1);
+}
+
+void test__cimag__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cimag(arg1) > 10) || (cimag(arg1) < 100)) {}
+}
+
+void test__cimag__leakignore() {
+  char *p = strdup(str);
+  result = cimag(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cimag__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cimag(x);
+}
+
+void test__cimagf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cimagf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cimagf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cimagf(arg1);
+}
+
+void test__cimagf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cimagf(arg1) > 10) || (cimagf(arg1) < 100)) {}
+}
+
+void test__cimagf__leakignore() {
+  char *p = strdup(str);
+  result = cimagf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cimagf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cimagf(x);
+}
+
+void test__cimagl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cimagl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cimagl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cimagl(arg1);
+}
+
+void test__cimagl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cimagl(arg1) > 10) || (cimagl(arg1) < 100)) {}
+}
+
+void test__cimagl__leakignore() {
+  char *p = strdup(str);
+  result = cimagl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cimagl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cimagl(x);
+}
+
+void test__exp2__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = exp2(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__exp2__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  exp2(arg1);
+}
+
+void test__exp2__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((exp2(arg1) > 10) || (exp2(arg1) < 100)) {}
+}
+
+void test__exp2__leakignore() {
+  char *p = strdup(str);
+  result = exp2(p);
+  // cppcheck-suppress memleak
+}
+
+void test__exp2__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = exp2(x);
+}
+
+void test__std__exp2__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::exp2(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__exp2__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::exp2(arg1);
+}
+
+void test__std__exp2__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::exp2(arg1) > 10) || (std::exp2(arg1) < 100)) {}
+}
+
+void test__std__exp2__leakignore() {
+  char *p = strdup(str);
+  result = std::exp2(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__exp2__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::exp2(x);
+}
+
+void test__exp2f__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = exp2f(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__exp2f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  exp2f(arg1);
+}
+
+void test__exp2f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((exp2f(arg1) > 10) || (exp2f(arg1) < 100)) {}
+}
+
+void test__exp2f__leakignore() {
+  char *p = strdup(str);
+  result = exp2f(p);
+  // cppcheck-suppress memleak
+}
+
+void test__exp2f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = exp2f(x);
+}
+
+void test__std__exp2f__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::exp2f(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__exp2f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::exp2f(arg1);
+}
+
+void test__std__exp2f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::exp2f(arg1) > 10) || (std::exp2f(arg1) < 100)) {}
+}
+
+void test__std__exp2f__leakignore() {
+  char *p = strdup(str);
+  result = std::exp2f(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__exp2f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::exp2f(x);
+}
+
+void test__exp2l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = exp2l(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__exp2l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  exp2l(arg1);
+}
+
+void test__exp2l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((exp2l(arg1) > 10) || (exp2l(arg1) < 100)) {}
+}
+
+void test__exp2l__leakignore() {
+  char *p = strdup(str);
+  result = exp2l(p);
+  // cppcheck-suppress memleak
+}
+
+void test__exp2l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = exp2l(x);
+}
+
+void test__std__exp2l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::exp2l(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__exp2l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::exp2l(arg1);
+}
+
+void test__std__exp2l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::exp2l(arg1) > 10) || (std::exp2l(arg1) < 100)) {}
+}
+
+void test__std__exp2l__leakignore() {
+  char *p = strdup(str);
+  result = std::exp2l(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__exp2l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::exp2l(x);
+}
+
+void test__expm1__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = expm1(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__expm1__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  expm1(arg1);
+}
+
+void test__expm1__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((expm1(arg1) > 10) || (expm1(arg1) < 100)) {}
+}
+
+void test__expm1__leakignore() {
+  char *p = strdup(str);
+  result = expm1(p);
+  // cppcheck-suppress memleak
+}
+
+void test__expm1__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = expm1(x);
+}
+
+void test__std__expm1__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::expm1(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__expm1__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::expm1(arg1);
+}
+
+void test__std__expm1__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::expm1(arg1) > 10) || (std::expm1(arg1) < 100)) {}
+}
+
+void test__std__expm1__leakignore() {
+  char *p = strdup(str);
+  result = std::expm1(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__expm1__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::expm1(x);
+}
+
+void test__expm1f__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = expm1f(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__expm1f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  expm1f(arg1);
+}
+
+void test__expm1f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((expm1f(arg1) > 10) || (expm1f(arg1) < 100)) {}
+}
+
+void test__expm1f__leakignore() {
+  char *p = strdup(str);
+  result = expm1f(p);
+  // cppcheck-suppress memleak
+}
+
+void test__expm1f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = expm1f(x);
+}
+
+void test__std__expm1f__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::expm1f(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__expm1f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::expm1f(arg1);
+}
+
+void test__std__expm1f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::expm1f(arg1) > 10) || (std::expm1f(arg1) < 100)) {}
+}
+
+void test__std__expm1f__leakignore() {
+  char *p = strdup(str);
+  result = std::expm1f(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__expm1f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::expm1f(x);
+}
+
+void test__expm1l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = expm1l(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__expm1l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  expm1l(arg1);
+}
+
+void test__expm1l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((expm1l(arg1) > 10) || (expm1l(arg1) < 100)) {}
+}
+
+void test__expm1l__leakignore() {
+  char *p = strdup(str);
+  result = expm1l(p);
+  // cppcheck-suppress memleak
+}
+
+void test__expm1l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = expm1l(x);
+}
+
+void test__std__expm1l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::expm1l(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__expm1l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::expm1l(arg1);
+}
+
+void test__std__expm1l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::expm1l(arg1) > 10) || (std::expm1l(arg1) < 100)) {}
+}
+
+void test__std__expm1l__leakignore() {
+  char *p = strdup(str);
+  result = std::expm1l(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__expm1l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::expm1l(x);
+}
+
+void test___Exit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _Exit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___Exit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _Exit(x);
+}
+
+void test__quick_exit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else quick_exit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__quick_exit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  quick_exit(x);
+}
+
+void test__fabs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fabs(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fabs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fabs(arg1);
+}
+
+void test__fabs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fabs(arg1) > 10) || (fabs(arg1) < 100)) {}
+}
+
+void test__fabs__leakignore() {
+  char *p = strdup(str);
+  result = fabs(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fabs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fabs(x);
+}
+
+void test__std__fabs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fabs(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fabs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fabs(arg1);
+}
+
+void test__std__fabs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fabs(arg1) > 10) || (std::fabs(arg1) < 100)) {}
+}
+
+void test__std__fabs__leakignore() {
+  char *p = strdup(str);
+  result = std::fabs(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fabs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fabs(x);
+}
+
+void test__fabsf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fabsf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fabsf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fabsf(arg1);
+}
+
+void test__fabsf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fabsf(arg1) > 10) || (fabsf(arg1) < 100)) {}
+}
+
+void test__fabsf__leakignore() {
+  char *p = strdup(str);
+  result = fabsf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fabsf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fabsf(x);
+}
+
+void test__std__fabsf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fabsf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fabsf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fabsf(arg1);
+}
+
+void test__std__fabsf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fabsf(arg1) > 10) || (std::fabsf(arg1) < 100)) {}
+}
+
+void test__std__fabsf__leakignore() {
+  char *p = strdup(str);
+  result = std::fabsf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fabsf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fabsf(x);
+}
+
+void test__fabsl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fabsl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fabsl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fabsl(arg1);
+}
+
+void test__fabsl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fabsl(arg1) > 10) || (fabsl(arg1) < 100)) {}
+}
+
+void test__fabsl__leakignore() {
+  char *p = strdup(str);
+  result = fabsl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fabsl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fabsl(x);
+}
+
+void test__std__fabsl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fabsl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fabsl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fabsl(arg1);
+}
+
+void test__std__fabsl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fabsl(arg1) > 10) || (std::fabsl(arg1) < 100)) {}
+}
+
+void test__std__fabsl__leakignore() {
+  char *p = strdup(str);
+  result = std::fabsl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fabsl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fabsl(x);
+}
+
+void test__fdim__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fdim(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fdim__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fdim(arg1, arg2);
+}
+
+void test__fdim__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fdim(arg1, arg2) > 10) || (fdim(arg1, arg2) < 100)) {}
+}
+
+void test__fdim__leakignore() {
+  char *p = strdup(str);
+  result = fdim(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fdim__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdim(x, arg2);
+}
+
+void test__fdim__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdim(arg1, x);
+}
+
+void test__std__fdim__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fdim(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fdim__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fdim(arg1, 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__fdim__leakignore() {
+  char *p = strdup(str);
+  result = std::fdim(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fdim__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fdim(x, arg2);
+}
+
+void test__std__fdim__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fdim(arg1, x);
+}
+
+void test__fdimf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fdimf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fdimf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fdimf(arg1, arg2);
+}
+
+void test__fdimf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fdimf(arg1, arg2) > 10) || (fdimf(arg1, arg2) < 100)) {}
+}
+
+void test__fdimf__leakignore() {
+  char *p = strdup(str);
+  result = fdimf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fdimf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdimf(x, arg2);
+}
+
+void test__fdimf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdimf(arg1, x);
+}
+
+void test__std__fdimf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fdimf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fdimf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fdimf(arg1, arg2);
+}
+
+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__fdimf__leakignore() {
+  char *p = strdup(str);
+  result = std::fdimf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fdimf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fdimf(x, arg2);
+}
+
+void test__std__fdimf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fdimf(arg1, x);
+}
+
+void test__fdiml__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fdiml(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fdiml__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fdiml(arg1, arg2);
+}
+
+void test__fdiml__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fdiml(arg1, arg2) > 10) || (fdiml(arg1, arg2) < 100)) {}
+}
+
+void test__fdiml__leakignore() {
+  char *p = strdup(str);
+  result = fdiml(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fdiml__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdiml(x, arg2);
+}
+
+void test__fdiml__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fdiml(arg1, x);
+}
+
+void test__std__fdiml__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fdiml(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fdiml__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fdiml(arg1, arg2);
+}
+
+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__fdiml__leakignore() {
+  char *p = strdup(str);
+  result = std::fdiml(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fdiml__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fdiml(x, arg2);
+}
+
+void test__std__fdiml__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fdiml(arg1, x);
+}
+
+void test__fclose__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fclose(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fclose__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fclose(NULL);
+}
+
+void test__fclose__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fclose(x);
+}
+
+void test__std__fclose__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fclose(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fclose__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fclose(NULL);
+}
+
+void test__std__fclose__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fclose(x);
+}
+
+void test__feof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = feof(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__feof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  feof(arg1);
+}
+
+void test__feof__leakignore() {
+  char *p = strdup(str);
+  result = feof(p);
+  // cppcheck-suppress memleak
+}
+
+void test__feof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = feof(NULL);
+}
+
+void test__feof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = feof(x);
+}
+
+void test__std__feof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::feof(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__feof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::feof(arg1);
+}
+
+void test__std__feof__leakignore() {
+  char *p = strdup(str);
+  result = std::feof(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__feof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::feof(NULL);
+}
+
+void test__std__feof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::feof(x);
+}
+
+void test__ferror__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ferror(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ferror__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ferror(arg1);
+}
+
+void test__ferror__leakignore() {
+  char *p = strdup(str);
+  result = ferror(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ferror__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = ferror(NULL);
+}
+
+void test__ferror__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = ferror(x);
+}
+
+void test__std__ferror__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::ferror(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ferror__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ferror(arg1);
+}
+
+void test__std__ferror__leakignore() {
+  char *p = strdup(str);
+  result = std::ferror(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ferror__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::ferror(NULL);
+}
+
+void test__std__ferror__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::ferror(x);
+}
+
+void test__fflush__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fflush(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fflush__leakignore() {
+  char *p = strdup(str);
+  fflush(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fflush__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fflush(x);
+}
+
+void test__std__fflush__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fflush(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fflush__leakignore() {
+  char *p = strdup(str);
+  std::fflush(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fflush__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fflush(x);
+}
+
+void test__fgetc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fgetc(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fgetc__leakignore() {
+  char *p = strdup(str);
+  fgetc(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fgetc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fgetc(NULL);
+}
+
+void test__fgetc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fgetc(x);
+}
+
+void test__std__fgetc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fgetc(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fgetc__leakignore() {
+  char *p = strdup(str);
+  std::fgetc(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fgetc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgetc(NULL);
+}
+
+void test__std__fgetc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fgetc(x);
+}
+
+void test__getc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getc(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getc__leakignore() {
+  char *p = strdup(str);
+  getc(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getc(NULL);
+}
+
+void test__getc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getc(x);
+}
+
+void test__std__getc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::getc(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__getc__leakignore() {
+  char *p = strdup(str);
+  std::getc(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__getc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::getc(NULL);
+}
+
+void test__std__getc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::getc(x);
+}
+
+void test__fgetwc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fgetwc(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fgetwc__leakignore() {
+  char *p = strdup(str);
+  fgetwc(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fgetwc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fgetwc(NULL);
+}
+
+void test__fgetwc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fgetwc(x);
+}
+
+void test__std__fgetwc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fgetwc(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fgetwc__leakignore() {
+  char *p = strdup(str);
+  std::fgetwc(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fgetwc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgetwc(NULL);
+}
+
+void test__std__fgetwc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fgetwc(x);
+}
+
+void test__getwc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getwc(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getwc__leakignore() {
+  char *p = strdup(str);
+  getwc(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getwc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  getwc(NULL);
+}
+
+void test__getwc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getwc(x);
+}
+
+void test__std__getwc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::getwc(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__getwc__leakignore() {
+  char *p = strdup(str);
+  std::getwc(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__getwc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::getwc(NULL);
+}
+
+void test__std__getwc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::getwc(x);
+}
+
+void test__fgetpos__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fgetpos(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fgetpos__leakignore() {
+  char *p = strdup(str);
+  fgetpos(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fgetpos__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fgetpos(NULL, arg2);
+}
+
+void test__fgetpos__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fgetpos(x, arg2);
+}
+
+void test__fgetpos__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fgetpos(arg1, NULL);
+}
+
+void test__std__fgetpos__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fgetpos(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fgetpos__leakignore() {
+  char *p = strdup(str);
+  std::fgetpos(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fgetpos__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgetpos(NULL, arg2);
+}
+
+void test__std__fgetpos__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fgetpos(x, arg2);
+}
+
+void test__std__fgetpos__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgetpos(arg1, NULL);
+}
+
+void test__floor__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = floor(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__floor__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  floor(arg1);
+}
+
+void test__floor__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((floor(arg1) > 10) || (floor(arg1) < 100)) {}
+}
+
+void test__floor__leakignore() {
+  char *p = strdup(str);
+  result = floor(p);
+  // cppcheck-suppress memleak
+}
+
+void test__floor__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = floor(x);
+}
+
+void test__std__floor__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::floor(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__floor__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::floor(arg1);
+}
+
+void test__std__floor__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::floor(arg1) > 10) || (std::floor(arg1) < 100)) {}
+}
+
+void test__std__floor__leakignore() {
+  char *p = strdup(str);
+  result = std::floor(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__floor__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::floor(x);
+}
+
+void test__floorf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = floorf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__floorf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  floorf(arg1);
+}
+
+void test__floorf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((floorf(arg1) > 10) || (floorf(arg1) < 100)) {}
+}
+
+void test__floorf__leakignore() {
+  char *p = strdup(str);
+  result = floorf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__floorf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = floorf(x);
+}
+
+void test__std__floorf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::floorf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__floorf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::floorf(arg1);
+}
+
+void test__std__floorf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::floorf(arg1) > 10) || (std::floorf(arg1) < 100)) {}
+}
+
+void test__std__floorf__leakignore() {
+  char *p = strdup(str);
+  result = std::floorf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__floorf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::floorf(x);
+}
+
+void test__floorl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = floorl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__floorl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  floorl(arg1);
+}
+
+void test__floorl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((floorl(arg1) > 10) || (floorl(arg1) < 100)) {}
+}
+
+void test__floorl__leakignore() {
+  char *p = strdup(str);
+  result = floorl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__floorl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = floorl(x);
+}
+
+void test__std__floorl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::floorl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__floorl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::floorl(arg1);
+}
+
+void test__std__floorl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::floorl(arg1) > 10) || (std::floorl(arg1) < 100)) {}
+}
+
+void test__std__floorl__leakignore() {
+  char *p = strdup(str);
+  result = std::floorl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__floorl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::floorl(x);
+}
+
+void test__fma__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fma(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fma__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fma(arg1, arg2, 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__fma__leakignore() {
+  char *p = strdup(str);
+  result = fma(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__fma__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fma(x, arg2, arg3);
+}
+
+void test__fma__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fma(arg1, x, arg3);
+}
+
+void test__fma__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fma(arg1, arg2, x);
+}
+
+void test__std__fma__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fma(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fma__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fma(arg1, arg2, arg3);
+}
+
+void test__std__fma__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fma(arg1, arg2, arg3) > 10) || (std::fma(arg1, arg2, arg3) < 100)) {}
+}
+
+void test__std__fma__leakignore() {
+  char *p = strdup(str);
+  result = std::fma(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fma__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fma(x, arg2, arg3);
+}
+
+void test__std__fma__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fma(arg1, x, arg3);
+}
+
+void test__std__fma__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fma(arg1, arg2, x);
+}
+
+void test__fmaf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fmaf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fmaf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmaf(arg1, arg2, arg3);
+}
+
+void test__fmaf__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmaf(arg1, arg2, arg3) > 10) || (fmaf(arg1, arg2, arg3) < 100)) {}
+}
+
+void test__fmaf__leakignore() {
+  char *p = strdup(str);
+  result = fmaf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__fmaf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmaf(x, arg2, arg3);
+}
+
+void test__fmaf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmaf(arg1, x, arg3);
+}
+
+void test__fmaf__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmaf(arg1, arg2, x);
+}
+
+void test__std__fmaf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fmaf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fmaf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmaf(arg1, arg2, arg3);
+}
+
+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__fmaf__leakignore() {
+  char *p = strdup(str);
+  result = std::fmaf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fmaf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmaf(x, arg2, arg3);
+}
+
+void test__std__fmaf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmaf(arg1, x, arg3);
+}
+
+void test__std__fmaf__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmaf(arg1, arg2, x);
+}
+
+void test__fmal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fmal(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fmal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmal(arg1, arg2, 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__fmal__leakignore() {
+  char *p = strdup(str);
+  result = fmal(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__fmal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmal(x, arg2, arg3);
+}
+
+void test__fmal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmal(arg1, x, arg3);
+}
+
+void test__fmal__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmal(arg1, arg2, x);
+}
+
+void test__std__fmal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fmal(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fmal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmal(arg1, arg2, 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__fmal__leakignore() {
+  char *p = strdup(str);
+  result = std::fmal(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fmal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmal(x, arg2, arg3);
+}
+
+void test__std__fmal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmal(arg1, x, arg3);
+}
+
+void test__std__fmal__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmal(arg1, arg2, x);
+}
+
+void test__fmax__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fmax(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fmax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmax(arg1, arg2);
+}
+
+void test__fmax__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmax(arg1, arg2) > 10) || (fmax(arg1, arg2) < 100)) {}
+}
+
+void test__fmax__leakignore() {
+  char *p = strdup(str);
+  result = fmax(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fmax__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmax(x, arg2);
+}
+
+void test__fmax__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmax(arg1, x);
+}
+
+void test__std__fmax__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fmax(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fmax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmax(arg1, arg2);
+}
+
+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__fmax__leakignore() {
+  char *p = strdup(str);
+  result = std::fmax(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fmax__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmax(x, arg2);
+}
+
+void test__std__fmax__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmax(arg1, x);
+}
+
+void test__fmaxf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fmaxf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fmaxf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmaxf(arg1, arg2);
+}
+
+void test__fmaxf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmaxf(arg1, arg2) > 10) || (fmaxf(arg1, arg2) < 100)) {}
+}
+
+void test__fmaxf__leakignore() {
+  char *p = strdup(str);
+  result = fmaxf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fmaxf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmaxf(x, arg2);
+}
+
+void test__fmaxf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmaxf(arg1, x);
+}
+
+void test__std__fmaxf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fmaxf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fmaxf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmaxf(arg1, arg2);
+}
+
+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__fmaxf__leakignore() {
+  char *p = strdup(str);
+  result = std::fmaxf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fmaxf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmaxf(x, arg2);
+}
+
+void test__std__fmaxf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmaxf(arg1, x);
+}
+
+void test__fmaxl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fmaxl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fmaxl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmaxl(arg1, arg2);
+}
+
+void test__fmaxl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmaxl(arg1, arg2) > 10) || (fmaxl(arg1, arg2) < 100)) {}
+}
+
+void test__fmaxl__leakignore() {
+  char *p = strdup(str);
+  result = fmaxl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fmaxl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmaxl(x, arg2);
+}
+
+void test__fmaxl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmaxl(arg1, x);
+}
+
+void test__std__fmaxl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fmaxl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fmaxl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmaxl(arg1, arg2);
+}
+
+void test__std__fmaxl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fmaxl(arg1, arg2) > 10) || (std::fmaxl(arg1, arg2) < 100)) {}
+}
+
+void test__std__fmaxl__leakignore() {
+  char *p = strdup(str);
+  result = std::fmaxl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fmaxl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmaxl(x, arg2);
+}
+
+void test__std__fmaxl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmaxl(arg1, x);
+}
+
+void test__fmin__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fmin(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fmin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmin(arg1, arg2);
+}
+
+void test__fmin__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmin(arg1, arg2) > 10) || (fmin(arg1, arg2) < 100)) {}
+}
+
+void test__fmin__leakignore() {
+  char *p = strdup(str);
+  result = fmin(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fmin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmin(x, arg2);
+}
+
+void test__fmin__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmin(arg1, x);
+}
+
+void test__std__fmin__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fmin(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fmin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmin(arg1, arg2);
+}
+
+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__fmin__leakignore() {
+  char *p = strdup(str);
+  result = std::fmin(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fmin__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmin(x, arg2);
+}
+
+void test__std__fmin__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmin(arg1, x);
+}
+
+void test__fminf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fminf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fminf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fminf(arg1, arg2);
+}
+
+void test__fminf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fminf(arg1, arg2) > 10) || (fminf(arg1, arg2) < 100)) {}
+}
+
+void test__fminf__leakignore() {
+  char *p = strdup(str);
+  result = fminf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fminf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fminf(x, arg2);
+}
+
+void test__fminf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fminf(arg1, x);
+}
+
+void test__std__fminf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fminf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fminf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fminf(arg1, arg2);
+}
+
+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__fminf__leakignore() {
+  char *p = strdup(str);
+  result = std::fminf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fminf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fminf(x, arg2);
+}
+
+void test__std__fminf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fminf(arg1, x);
+}
+
+void test__fminl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fminl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fminl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fminl(arg1, arg2);
+}
+
+void test__fminl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fminl(arg1, arg2) > 10) || (fminl(arg1, arg2) < 100)) {}
+}
+
+void test__fminl__leakignore() {
+  char *p = strdup(str);
+  result = fminl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fminl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fminl(x, arg2);
+}
+
+void test__fminl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fminl(arg1, x);
+}
+
+void test__std__fminl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fminl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fminl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fminl(arg1, arg2);
+}
+
+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__std__fminl__leakignore() {
+  char *p = strdup(str);
+  result = std::fminl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fminl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fminl(x, arg2);
+}
+
+void test__std__fminl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fminl(arg1, x);
+}
+
+void test__fmod__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fmod(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fmod__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmod(arg1, arg2);
+}
+
+void test__fmod__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmod(arg1, arg2) > 10) || (fmod(arg1, arg2) < 100)) {}
+}
+
+void test__fmod__leakignore() {
+  char *p = strdup(str);
+  result = fmod(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fmod__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmod(x, arg2);
+}
+
+void test__fmod__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmod(arg1, x);
+}
+
+void test__std__fmod__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fmod(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fmod__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmod(arg1, arg2);
+}
+
+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__fmod__leakignore() {
+  char *p = strdup(str);
+  result = std::fmod(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fmod__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmod(x, arg2);
+}
+
+void test__std__fmod__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmod(arg1, x);
+}
+
+void test__fmodf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fmodf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fmodf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmodf(arg1, arg2);
+}
+
+void test__fmodf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmodf(arg1, arg2) > 10) || (fmodf(arg1, arg2) < 100)) {}
+}
+
+void test__fmodf__leakignore() {
+  char *p = strdup(str);
+  result = fmodf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fmodf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmodf(x, arg2);
+}
+
+void test__fmodf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmodf(arg1, x);
+}
+
+void test__std__fmodf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fmodf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fmodf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmodf(arg1, arg2);
+}
+
+void test__std__fmodf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fmodf(arg1, arg2) > 10) || (std::fmodf(arg1, arg2) < 100)) {}
+}
+
+void test__std__fmodf__leakignore() {
+  char *p = strdup(str);
+  result = std::fmodf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fmodf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmodf(x, arg2);
+}
+
+void test__std__fmodf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmodf(arg1, x);
+}
+
+void test__fmodl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fmodl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fmodl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fmodl(arg1, arg2);
+}
+
+void test__fmodl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fmodl(arg1, arg2) > 10) || (fmodl(arg1, arg2) < 100)) {}
+}
+
+void test__fmodl__leakignore() {
+  char *p = strdup(str);
+  result = fmodl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fmodl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmodl(x, arg2);
+}
+
+void test__fmodl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fmodl(arg1, x);
+}
+
+void test__std__fmodl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fmodl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fmodl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fmodl(arg1, arg2);
+}
+
+void test__std__fmodl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fmodl(arg1, arg2) > 10) || (std::fmodl(arg1, arg2) < 100)) {}
+}
+
+void test__std__fmodl__leakignore() {
+  char *p = strdup(str);
+  result = std::fmodl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fmodl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmodl(x, arg2);
+}
+
+void test__std__fmodl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fmodl(arg1, x);
+}
+
+void test__fopen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fopen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fopen(arg1, arg2);
+}
+
+void test__fopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fopen(NULL, arg2);
+}
+
+void test__fopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fopen(x, arg2);
+}
+
+void test__fopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = fopen(arg1, NULL);
+}
+
+void test__fopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = fopen(arg1, x);
+}
+
+void test__std__fopen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fopen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fopen(arg1, arg2);
+}
+
+void test__std__fopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::fopen(NULL, arg2);
+}
+
+void test__std__fopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::fopen(x, arg2);
+}
+
+void test__std__fopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::fopen(arg1, NULL);
+}
+
+void test__std__fopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::fopen(arg1, x);
+}
+
+void test__fopen_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fopen_s(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fopen_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fopen_s(NULL, arg2, arg3);
+}
+
+void test__fopen_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fopen_s(arg1, NULL, arg3);
+}
+
+void test__fopen_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fopen_s(arg1, x, arg3);
+}
+
+void test__fopen_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  fopen_s(arg1, arg2, NULL);
+}
+
+void test__fopen_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fopen_s(arg1, arg2, x);
+}
+
+void test__fprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fprintf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fprintf__leakignore() {
+  char *p = strdup(str);
+  fprintf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fprintf(NULL, arg2);
+}
+
+void test__fprintf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fprintf(x, arg2);
+}
+
+void test__fprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fprintf(arg1, x);
+}
+
+void test__std__fprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fprintf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fprintf__leakignore() {
+  char *p = strdup(str);
+  std::fprintf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fprintf(NULL, arg2);
+}
+
+void test__std__fprintf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fprintf(x, arg2);
+}
+
+void test__std__fprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fprintf(arg1, x);
+}
+
+void test__vfprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vfprintf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vfprintf__leakignore() {
+  char *p = strdup(str);
+  vfprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__vfprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vfprintf(NULL, arg2, arg3);
+}
+
+void test__vfprintf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vfprintf(x, arg2, arg3);
+}
+
+void test__vfprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vfprintf(arg1, x, arg3);
+}
+
+void test__std__vfprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vfprintf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vfprintf__leakignore() {
+  char *p = strdup(str);
+  std::vfprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__vfprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vfprintf(NULL, arg2, arg3);
+}
+
+void test__std__vfprintf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vfprintf(x, arg2, arg3);
+}
+
+void test__std__vfprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vfprintf(arg1, x, arg3);
+}
+
+void test__vfwprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vfwprintf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vfwprintf__leakignore() {
+  char *p = strdup(str);
+  vfwprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__vfwprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vfwprintf(NULL, arg2, arg3);
+}
+
+void test__vfwprintf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vfwprintf(x, arg2, arg3);
+}
+
+void test__vfwprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vfwprintf(arg1, x, arg3);
+}
+
+void test__std__vfwprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vfwprintf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vfwprintf__leakignore() {
+  char *p = strdup(str);
+  std::vfwprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__vfwprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vfwprintf(NULL, arg2, arg3);
+}
+
+void test__std__vfwprintf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vfwprintf(x, arg2, arg3);
+}
+
+void test__std__vfwprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vfwprintf(arg1, x, arg3);
+}
+
+void test__fputc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fputc(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fputc__leakignore() {
+  char *p = strdup(str);
+  fputc(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fputc__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  fputc(!x, arg2);
+}
+
+void test__fputc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fputc(x, arg2);
+}
+
+void test__fputc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fputc(arg1, NULL);
+}
+
+void test__fputc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fputc(arg1, x);
+}
+
+void test__std__fputc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fputc(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fputc__leakignore() {
+  char *p = strdup(str);
+  std::fputc(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fputc__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::fputc(!x, arg2);
+}
+
+void test__std__fputc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fputc(x, arg2);
+}
+
+void test__std__fputc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fputc(arg1, NULL);
+}
+
+void test__std__fputc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fputc(arg1, x);
+}
+
+void test__fputwc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fputwc(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fputwc__leakignore() {
+  char *p = strdup(str);
+  fputwc(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fputwc__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  fputwc(!x, arg2);
+}
+
+void test__fputwc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fputwc(x, arg2);
+}
+
+void test__fputwc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fputwc(arg1, NULL);
+}
+
+void test__fputwc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fputwc(arg1, x);
+}
+
+void test__std__fputwc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fputwc(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fputwc__leakignore() {
+  char *p = strdup(str);
+  std::fputwc(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fputwc__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::fputwc(!x, arg2);
+}
+
+void test__std__fputwc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fputwc(x, arg2);
+}
+
+void test__std__fputwc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fputwc(arg1, NULL);
+}
+
+void test__std__fputwc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fputwc(arg1, x);
+}
+
+void test__fputs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fputs(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fputs__leakignore() {
+  char *p = strdup(str);
+  fputs(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fputs__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fputs(NULL, arg2);
+}
+
+void test__fputs__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fputs(x, arg2);
+}
+
+void test__fputs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fputs(arg1, NULL);
+}
+
+void test__fputs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fputs(arg1, x);
+}
+
+void test__std__fputs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fputs(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fputs__leakignore() {
+  char *p = strdup(str);
+  std::fputs(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fputs__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fputs(NULL, arg2);
+}
+
+void test__std__fputs__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fputs(x, arg2);
+}
+
+void test__std__fputs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fputs(arg1, NULL);
+}
+
+void test__std__fputs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fputs(arg1, x);
+}
+
+void test__fputws__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fputws(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fputws__leakignore() {
+  char *p = strdup(str);
+  fputws(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fputws__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fputws(NULL, arg2);
+}
+
+void test__fputws__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fputws(x, arg2);
+}
+
+void test__fputws__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fputws(arg1, NULL);
+}
+
+void test__fputws__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fputws(arg1, x);
+}
+
+void test__std__fputws__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fputws(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fputws__leakignore() {
+  char *p = strdup(str);
+  std::fputws(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fputws__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fputws(NULL, arg2);
+}
+
+void test__std__fputws__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fputws(x, arg2);
+}
+
+void test__std__fputws__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fputws(arg1, NULL);
+}
+
+void test__std__fputws__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fputws(arg1, x);
+}
+
+void test__fread__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fread(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fread__leakignore() {
+  char *p = strdup(str);
+  fread(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__fread__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fread(NULL, arg2, arg3, arg4);
+}
+
+void test__fread__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fread(arg1, x, arg3, arg4);
+}
+
+void test__fread__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fread(arg1, arg2, x, arg4);
+}
+
+void test__fread__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  fread(arg1, arg2, arg3, NULL);
+}
+
+void test__fread__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fread(arg1, arg2, arg3, x);
+}
+
+void test__std__fread__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fread(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fread__leakignore() {
+  char *p = strdup(str);
+  std::fread(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fread__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fread(NULL, arg2, arg3, arg4);
+}
+
+void test__std__fread__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fread(arg1, x, arg3, arg4);
+}
+
+void test__std__fread__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fread(arg1, arg2, x, arg4);
+}
+
+void test__std__fread__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fread(arg1, arg2, arg3, NULL);
+}
+
+void test__std__fread__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fread(arg1, arg2, arg3, x);
+}
+
+void test__free__noreturn() {
+  int x = 100;
+  if (cond) x=1; else free(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__free__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  free(x);
+}
+
+void test__std__free__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::free(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__free__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::free(x);
+}
+
+void test__freopen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = freopen(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__freopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  freopen(arg1, arg2, arg3);
+}
+
+void test__freopen__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = freopen(x, arg2, arg3);
+}
+
+void test__freopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = freopen(arg1, NULL, arg3);
+}
+
+void test__freopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = freopen(arg1, x, arg3);
+}
+
+void test__freopen__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = freopen(arg1, arg2, NULL);
+}
+
+void test__freopen__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = freopen(arg1, arg2, x);
+}
+
+void test__std__freopen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::freopen(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__freopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::freopen(arg1, arg2, arg3);
+}
+
+void test__std__freopen__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::freopen(x, arg2, arg3);
+}
+
+void test__std__freopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::freopen(arg1, NULL, arg3);
+}
+
+void test__std__freopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::freopen(arg1, x, arg3);
+}
+
+void test__std__freopen__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::freopen(arg1, arg2, NULL);
+}
+
+void test__std__freopen__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::freopen(arg1, arg2, x);
+}
+
+void test__freopen_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = freopen_s(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__freopen_s__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  freopen_s(arg1, arg2, arg3, arg4);
+}
+
+void test__freopen_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = freopen_s(x, arg2, arg3, arg4);
+}
+
+void test__freopen_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = freopen_s(arg1, x, arg3, arg4);
+}
+
+void test__freopen_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = freopen_s(arg1, arg2, NULL, arg4);
+}
+
+void test__freopen_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = freopen_s(arg1, arg2, x, arg4);
+}
+
+void test__freopen_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  result = freopen_s(arg1, arg2, arg3, NULL);
+}
+
+void test__freopen_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = freopen_s(arg1, arg2, arg3, x);
+}
+
+void test__frexp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else frexp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__frexp__leakignore() {
+  char *p = strdup(str);
+  frexp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__frexp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  frexp(x, arg2);
+}
+
+void test__frexp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  frexp(arg1, NULL);
+}
+
+void test__std__frexp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::frexp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__frexp__leakignore() {
+  char *p = strdup(str);
+  std::frexp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__frexp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::frexp(x, arg2);
+}
+
+void test__std__frexp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::frexp(arg1, NULL);
+}
+
+void test__frexpf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else frexpf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__frexpf__leakignore() {
+  char *p = strdup(str);
+  frexpf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__frexpf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  frexpf(x, arg2);
+}
+
+void test__frexpf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  frexpf(arg1, NULL);
+}
+
+void test__std__frexpf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::frexpf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__frexpf__leakignore() {
+  char *p = strdup(str);
+  std::frexpf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__frexpf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::frexpf(x, arg2);
+}
+
+void test__std__frexpf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::frexpf(arg1, NULL);
+}
+
+void test__frexpl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else frexpl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__frexpl__leakignore() {
+  char *p = strdup(str);
+  frexpl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__frexpl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  frexpl(x, arg2);
+}
+
+void test__frexpl__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  frexpl(arg1, NULL);
+}
+
+void test__std__frexpl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::frexpl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__frexpl__leakignore() {
+  char *p = strdup(str);
+  std::frexpl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__frexpl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::frexpl(x, arg2);
+}
+
+void test__std__frexpl__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::frexpl(arg1, NULL);
+}
+
+void test__hypot__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = hypot(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__hypot__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  hypot(arg1, arg2, arg3);
+}
+
+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__hypot__leakignore() {
+  char *p = strdup(str);
+  result = hypot(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__hypot__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = hypot(x, arg2, arg3);
+}
+
+void test__hypot__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = hypot(arg1, x, arg3);
+}
+
+void test__hypot__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = hypot(arg1, arg2, x);
+}
+
+void test__std__hypot__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::hypot(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__hypot__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::hypot(arg1, arg2, arg3);
+}
+
+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__hypot__leakignore() {
+  char *p = strdup(str);
+  result = std::hypot(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__hypot__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::hypot(x, arg2, arg3);
+}
+
+void test__std__hypot__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::hypot(arg1, x, arg3);
+}
+
+void test__std__hypot__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::hypot(arg1, arg2, x);
+}
+
+void test__hypotf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = hypotf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__hypotf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  hypotf(arg1, arg2);
+}
+
+void test__hypotf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((hypotf(arg1, arg2) > 10) || (hypotf(arg1, arg2) < 100)) {}
+}
+
+void test__hypotf__leakignore() {
+  char *p = strdup(str);
+  result = hypotf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__hypotf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = hypotf(x, arg2);
+}
+
+void test__hypotf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = hypotf(arg1, x);
+}
+
+void test__std__hypotf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::hypotf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__hypotf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::hypotf(arg1, arg2);
+}
+
+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__std__hypotf__leakignore() {
+  char *p = strdup(str);
+  result = std::hypotf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__hypotf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::hypotf(x, arg2);
+}
+
+void test__std__hypotf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::hypotf(arg1, x);
+}
+
+void test__hypotl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = hypotl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__hypotl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  hypotl(arg1, arg2);
+}
+
+void test__hypotl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((hypotl(arg1, arg2) > 10) || (hypotl(arg1, arg2) < 100)) {}
+}
+
+void test__hypotl__leakignore() {
+  char *p = strdup(str);
+  result = hypotl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__hypotl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = hypotl(x, arg2);
+}
+
+void test__hypotl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = hypotl(arg1, x);
+}
+
+void test__std__hypotl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::hypotl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__hypotl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::hypotl(arg1, arg2);
+}
+
+void test__std__hypotl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::hypotl(arg1, arg2) > 10) || (std::hypotl(arg1, arg2) < 100)) {}
+}
+
+void test__std__hypotl__leakignore() {
+  char *p = strdup(str);
+  result = std::hypotl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__hypotl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::hypotl(x, arg2);
+}
+
+void test__std__hypotl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::hypotl(arg1, x);
+}
+
+void test__fscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fscanf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fscanf__leakignore() {
+  char *p = strdup(str);
+  fscanf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fscanf(x, arg2);
+}
+
+void test__fscanf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fscanf(arg1, x);
+}
+
+void test__std__fscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fscanf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fscanf__leakignore() {
+  char *p = strdup(str);
+  std::fscanf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fscanf(x, arg2);
+}
+
+void test__std__fscanf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fscanf(arg1, x);
+}
+
+void test__vfscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vfscanf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vfscanf__leakignore() {
+  char *p = strdup(str);
+  vfscanf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__vfscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vfscanf(x, arg2, arg3);
+}
+
+void test__vfscanf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vfscanf(arg1, x, arg3);
+}
+
+void test__std__vfscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vfscanf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vfscanf__leakignore() {
+  char *p = strdup(str);
+  std::vfscanf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__vfscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vfscanf(x, arg2, arg3);
+}
+
+void test__std__vfscanf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vfscanf(arg1, x, arg3);
+}
+
+void test__vfwscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vfwscanf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vfwscanf__leakignore() {
+  char *p = strdup(str);
+  vfwscanf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__vfwscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vfwscanf(x, arg2, arg3);
+}
+
+void test__vfwscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  vfwscanf(arg1, NULL, arg3);
+}
+
+void test__vfwscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vfwscanf(arg1, x, arg3);
+}
+
+void test__std__vfwscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vfwscanf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vfwscanf__leakignore() {
+  char *p = strdup(str);
+  std::vfwscanf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__vfwscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vfwscanf(x, arg2, arg3);
+}
+
+void test__std__vfwscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vfwscanf(arg1, NULL, arg3);
+}
+
+void test__std__vfwscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vfwscanf(arg1, x, arg3);
+}
+
+void test__fseek__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fseek(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fseek__leakignore() {
+  char *p = strdup(str);
+  fseek(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__fseek__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fseek(NULL, arg2, arg3);
+}
+
+void test__fseek__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fseek(x, arg2, arg3);
+}
+
+void test__fseek__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fseek(arg1, x, arg3);
+}
+
+void test__fseek__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fseek(arg1, arg2, x);
+}
+
+void test__std__fseek__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fseek(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fseek__leakignore() {
+  char *p = strdup(str);
+  std::fseek(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fseek__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fseek(NULL, arg2, arg3);
+}
+
+void test__std__fseek__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fseek(x, arg2, arg3);
+}
+
+void test__std__fseek__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fseek(arg1, x, arg3);
+}
+
+void test__std__fseek__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fseek(arg1, arg2, x);
+}
+
+void test__fsetpos__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fsetpos(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fsetpos__leakignore() {
+  char *p = strdup(str);
+  fsetpos(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fsetpos__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fsetpos(NULL, arg2);
+}
+
+void test__fsetpos__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fsetpos(x, arg2);
+}
+
+void test__fsetpos__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fsetpos(arg1, NULL);
+}
+
+void test__fsetpos__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fsetpos(arg1, x);
+}
+
+void test__std__fsetpos__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fsetpos(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fsetpos__leakignore() {
+  char *p = strdup(str);
+  std::fsetpos(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fsetpos__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fsetpos(NULL, arg2);
+}
+
+void test__std__fsetpos__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fsetpos(x, arg2);
+}
+
+void test__std__fsetpos__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fsetpos(arg1, NULL);
+}
+
+void test__std__fsetpos__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fsetpos(arg1, x);
+}
+
+void test__fgets__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fgets(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fgets__leakignore() {
+  char *p = strdup(str);
+  fgets(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__fgets__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fgets(NULL, arg2, arg3);
+}
+
+void test__fgets__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  fgets(arg1, !x, arg3);
+}
+
+void test__fgets__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fgets(arg1, x, arg3);
+}
+
+void test__fgets__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  fgets(arg1, arg2, NULL);
+}
+
+void test__fgets__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fgets(arg1, arg2, x);
+}
+
+void test__std__fgets__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fgets(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fgets__leakignore() {
+  char *p = strdup(str);
+  std::fgets(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fgets__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgets(NULL, arg2, arg3);
+}
+
+void test__std__fgets__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::fgets(arg1, !x, arg3);
+}
+
+void test__std__fgets__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fgets(arg1, x, arg3);
+}
+
+void test__std__fgets__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgets(arg1, arg2, NULL);
+}
+
+void test__std__fgets__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fgets(arg1, arg2, x);
+}
+
+void test__fgetws__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fgetws(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fgetws__leakignore() {
+  char *p = strdup(str);
+  fgetws(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__fgetws__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fgetws(NULL, arg2, arg3);
+}
+
+void test__fgetws__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  fgetws(arg1, !x, arg3);
+}
+
+void test__fgetws__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fgetws(arg1, x, arg3);
+}
+
+void test__fgetws__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  fgetws(arg1, arg2, NULL);
+}
+
+void test__fgetws__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fgetws(arg1, arg2, x);
+}
+
+void test__std__fgetws__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fgetws(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fgetws__leakignore() {
+  char *p = strdup(str);
+  std::fgetws(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fgetws__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgetws(NULL, arg2, arg3);
+}
+
+void test__std__fgetws__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::fgetws(arg1, !x, arg3);
+}
+
+void test__std__fgetws__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fgetws(arg1, x, arg3);
+}
+
+void test__std__fgetws__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fgetws(arg1, arg2, NULL);
+}
+
+void test__std__fgetws__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fgetws(arg1, arg2, x);
+}
+
+void test__ftell__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ftell(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ftell__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ftell(arg1);
+}
+
+void test__ftell__leakignore() {
+  char *p = strdup(str);
+  result = ftell(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ftell__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = ftell(NULL);
+}
+
+void test__ftell__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = ftell(x);
+}
+
+void test__std__ftell__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::ftell(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ftell__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ftell(arg1);
+}
+
+void test__std__ftell__leakignore() {
+  char *p = strdup(str);
+  result = std::ftell(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ftell__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::ftell(NULL);
+}
+
+void test__std__ftell__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::ftell(x);
+}
+
+void test__fwide__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fwide(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fwide__leakignore() {
+  char *p = strdup(str);
+  fwide(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fwide__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fwide(NULL, arg2);
+}
+
+void test__fwide__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fwide(x, arg2);
+}
+
+void test__fwide__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fwide(arg1, x);
+}
+
+void test__std__fwide__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fwide(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fwide__leakignore() {
+  char *p = strdup(str);
+  std::fwide(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fwide__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fwide(NULL, arg2);
+}
+
+void test__std__fwide__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fwide(x, arg2);
+}
+
+void test__std__fwide__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fwide(arg1, x);
+}
+
+void test__fwrite__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fwrite(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fwrite__leakignore() {
+  char *p = strdup(str);
+  fwrite(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__fwrite__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fwrite(NULL, arg2, arg3, arg4);
+}
+
+void test__fwrite__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fwrite(x, arg2, arg3, arg4);
+}
+
+void test__fwrite__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fwrite(arg1, x, arg3, arg4);
+}
+
+void test__fwrite__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  fwrite(arg1, arg2, x, arg4);
+}
+
+void test__fwrite__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  fwrite(arg1, arg2, arg3, NULL);
+}
+
+void test__fwrite__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fwrite(arg1, arg2, arg3, x);
+}
+
+void test__std__fwrite__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fwrite(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fwrite__leakignore() {
+  char *p = strdup(str);
+  std::fwrite(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fwrite__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fwrite(NULL, arg2, arg3, arg4);
+}
+
+void test__std__fwrite__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fwrite(x, arg2, arg3, arg4);
+}
+
+void test__std__fwrite__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fwrite(arg1, x, arg3, arg4);
+}
+
+void test__std__fwrite__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fwrite(arg1, arg2, x, arg4);
+}
+
+void test__std__fwrite__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fwrite(arg1, arg2, arg3, NULL);
+}
+
+void test__std__fwrite__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fwrite(arg1, arg2, arg3, x);
+}
+
+void test__mblen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mblen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mblen__leakignore() {
+  char *p = strdup(str);
+  mblen(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__mblen__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mblen(x, arg2);
+}
+
+void test__mblen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mblen(arg1, x);
+}
+
+void test__std__mblen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::mblen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__mblen__leakignore() {
+  char *p = strdup(str);
+  std::mblen(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__mblen__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mblen(x, arg2);
+}
+
+void test__std__mblen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mblen(arg1, x);
+}
+
+void test__mbtowc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mbtowc(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mbtowc__leakignore() {
+  char *p = strdup(str);
+  mbtowc(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__mbtowc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbtowc(arg1, x, arg3);
+}
+
+void test__mbtowc__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbtowc(arg1, arg2, x);
+}
+
+void test__std__mbtowc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::mbtowc(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__mbtowc__leakignore() {
+  char *p = strdup(str);
+  std::mbtowc(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__mbtowc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbtowc(arg1, x, arg3);
+}
+
+void test__std__mbtowc__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbtowc(arg1, arg2, x);
+}
+
+void test__mbrlen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mbrlen(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mbrlen__leakignore() {
+  char *p = strdup(str);
+  mbrlen(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__mbrlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mbrlen(NULL, arg2, arg3);
+}
+
+void test__mbrlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mbrlen(x, arg2, arg3);
+}
+
+void test__mbrlen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrlen(arg1, x, arg3);
+}
+
+void test__mbrlen__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrlen(arg1, arg2, x);
+}
+
+void test__std__mbrlen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::mbrlen(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__mbrlen__leakignore() {
+  char *p = strdup(str);
+  std::mbrlen(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__mbrlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::mbrlen(NULL, arg2, arg3);
+}
+
+void test__std__mbrlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::mbrlen(x, arg2, arg3);
+}
+
+void test__std__mbrlen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbrlen(arg1, x, arg3);
+}
+
+void test__std__mbrlen__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbrlen(arg1, arg2, x);
+}
+
+void test__btowc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = btowc(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__btowc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  btowc(arg1);
+}
+
+void test__btowc__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((btowc(arg1) > 10) || (btowc(arg1) < 100)) {}
+}
+
+void test__btowc__leakignore() {
+  char *p = strdup(str);
+  result = btowc(p);
+  // cppcheck-suppress memleak
+}
+
+void test__btowc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = btowc(x);
+}
+
+void test__std__btowc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::btowc(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__btowc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::btowc(arg1);
+}
+
+void test__std__btowc__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::btowc(arg1) > 10) || (std::btowc(arg1) < 100)) {}
+}
+
+void test__std__btowc__leakignore() {
+  char *p = strdup(str);
+  result = std::btowc(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__btowc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::btowc(x);
+}
+
+void test__mbsinit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mbsinit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mbsinit__leakignore() {
+  char *p = strdup(str);
+  mbsinit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__mbsinit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbsinit(x);
+}
+
+void test__std__mbsinit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::mbsinit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__mbsinit__leakignore() {
+  char *p = strdup(str);
+  std::mbsinit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__mbsinit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbsinit(x);
+}
+
+void test__getwchar__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getwchar();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getwchar__leakignore() {
+  char *p = strdup(str);
+  getwchar();
+  // cppcheck-suppress memleak
+}
+
+void test__mbstowcs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mbstowcs(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mbstowcs__leakignore() {
+  char *p = strdup(str);
+  mbstowcs(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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__mbstowcs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbstowcs(arg1, arg2, x);
+}
+
+void test__std__mbstowcs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::mbstowcs(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__mbstowcs__leakignore() {
+  char *p = strdup(str);
+  std::mbstowcs(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__mbstowcs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::mbstowcs(arg1, NULL, arg3);
+}
+
+void test__std__mbstowcs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::mbstowcs(arg1, x, arg3);
+}
+
+void test__std__mbstowcs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbstowcs(arg1, arg2, x);
+}
+
+void test__mbsrtowcs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mbsrtowcs(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mbsrtowcs__leakignore() {
+  char *p = strdup(str);
+  mbsrtowcs(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__mbsrtowcs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  mbsrtowcs(arg1, NULL, arg3, arg4);
+}
+
+void test__mbsrtowcs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mbsrtowcs(arg1, x, arg3, arg4);
+}
+
+void test__mbsrtowcs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbsrtowcs(arg1, arg2, x, arg4);
+}
+
+void test__mbsrtowcs__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  mbsrtowcs(arg1, arg2, arg3, NULL);
+}
+
+void test__std__mbsrtowcs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::mbsrtowcs(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__mbsrtowcs__leakignore() {
+  char *p = strdup(str);
+  std::mbsrtowcs(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__std__mbsrtowcs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::mbsrtowcs(arg1, NULL, arg3, arg4);
+}
+
+void test__std__mbsrtowcs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::mbsrtowcs(arg1, x, arg3, arg4);
+}
+
+void test__std__mbsrtowcs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbsrtowcs(arg1, arg2, x, arg4);
+}
+
+void test__std__mbsrtowcs__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  std::mbsrtowcs(arg1, arg2, arg3, NULL);
+}
+
+void test__wctob__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wctob(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wctob__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wctob(arg1);
+}
+
+void test__wctob__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wctob(arg1) > 10) || (wctob(arg1) < 100)) {}
+}
+
+void test__wctob__leakignore() {
+  char *p = strdup(str);
+  result = wctob(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wctob__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wctob(x);
+}
+
+void test__std__wctob__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wctob(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wctob__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wctob(arg1);
+}
+
+void test__std__wctob__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wctob(arg1) > 10) || (std::wctob(arg1) < 100)) {}
+}
+
+void test__std__wctob__leakignore() {
+  char *p = strdup(str);
+  result = std::wctob(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wctob__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wctob(x);
+}
+
+void test__wctomb__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wctomb(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wctomb__leakignore() {
+  char *p = strdup(str);
+  wctomb(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wctomb__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wctomb(x, arg2);
+}
+
+void test__wctomb__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wctomb(arg1, x);
+}
+
+void test__std__wctomb__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wctomb(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wctomb__leakignore() {
+  char *p = strdup(str);
+  std::wctomb(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wctomb__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wctomb(x, arg2);
+}
+
+void test__std__wctomb__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wctomb(arg1, x);
+}
+
+void test__wcstombs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcstombs(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcstombs__leakignore() {
+  char *p = strdup(str);
+  wcstombs(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcstombs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstombs(arg1, NULL, arg3);
+}
+
+void test__wcstombs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcstombs(arg1, x, arg3);
+}
+
+void test__wcstombs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcstombs(arg1, arg2, x);
+}
+
+void test__std__wcstombs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wcstombs(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcstombs__leakignore() {
+  char *p = strdup(str);
+  std::wcstombs(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcstombs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcstombs(arg1, NULL, arg3);
+}
+
+void test__std__wcstombs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcstombs(arg1, x, arg3);
+}
+
+void test__std__wcstombs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcstombs(arg1, arg2, x);
+}
+
+void test__getchar__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getchar();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getchar__leakignore() {
+  char *p = strdup(str);
+  getchar();
+  // cppcheck-suppress memleak
+}
+
+void test__ungetc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ungetc(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ungetc__leakignore() {
+  char *p = strdup(str);
+  ungetc(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__ungetc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ungetc(x, arg2);
+}
+
+void test__ungetc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  ungetc(arg1, NULL);
+}
+
+void test__ungetc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ungetc(arg1, x);
+}
+
+void test__std__ungetc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::ungetc(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ungetc__leakignore() {
+  char *p = strdup(str);
+  std::ungetc(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ungetc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ungetc(x, arg2);
+}
+
+void test__std__ungetc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::ungetc(arg1, NULL);
+}
+
+void test__std__ungetc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::ungetc(arg1, x);
+}
+
+void test__ungetwc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ungetwc(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ungetwc__leakignore() {
+  char *p = strdup(str);
+  ungetwc(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__ungetwc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ungetwc(x, arg2);
+}
+
+void test__ungetwc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  ungetwc(arg1, NULL);
+}
+
+void test__ungetwc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ungetwc(arg1, x);
+}
+
+void test__std__ungetwc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::ungetwc(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ungetwc__leakignore() {
+  char *p = strdup(str);
+  std::ungetwc(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ungetwc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ungetwc(x, arg2);
+}
+
+void test__std__ungetwc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::ungetwc(arg1, NULL);
+}
+
+void test__std__ungetwc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::ungetwc(arg1, x);
+}
+
+void test__getenv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = getenv(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getenv__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  getenv(arg1);
+}
+
+void test__getenv__leakignore() {
+  char *p = strdup(str);
+  result = getenv(p);
+  // cppcheck-suppress memleak
+}
+
+void test__getenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = getenv(NULL);
+}
+
+void test__getenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = getenv(x);
+}
+
+void test__std__getenv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::getenv(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__getenv__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::getenv(arg1);
+}
+
+void test__std__getenv__leakignore() {
+  char *p = strdup(str);
+  result = std::getenv(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__getenv__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::getenv(NULL);
+}
+
+void test__std__getenv__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::getenv(x);
+}
+
+void test__gets__noreturn() {
+  int x = 100;
+  if (cond) x=1; else gets(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__gets__leakignore() {
+  char *p = strdup(str);
+  gets(p);
+  // cppcheck-suppress memleak
+}
+
+void test__gets__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  gets(NULL);
+}
+
+void test__std__gets__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::gets(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__gets__leakignore() {
+  char *p = strdup(str);
+  std::gets(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__gets__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::gets(NULL);
+}
+
+void test__gets_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else gets_s(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__gets_s__leakignore() {
+  char *p = strdup(str);
+  gets_s(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__gets_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  gets_s(NULL, arg2);
+}
+
+void test__gets_s__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  gets_s(arg1, !x);
+}
+
+void test__gets_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  gets_s(arg1, x);
+}
+
+void test__std__gets_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::gets_s(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__gets_s__leakignore() {
+  char *p = strdup(str);
+  std::gets_s(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__gets_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::gets_s(NULL, arg2);
+}
+
+void test__std__gets_s__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::gets_s(arg1, !x);
+}
+
+void test__std__gets_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::gets_s(arg1, x);
+}
+
+void test__gmtime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = gmtime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__gmtime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  gmtime(arg1);
+}
+
+void test__gmtime__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((gmtime(arg1) > 10) || (gmtime(arg1) < 100)) {}
+}
+
+void test__gmtime__leakignore() {
+  char *p = strdup(str);
+  result = gmtime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__gmtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = gmtime(NULL);
+}
+
+void test__gmtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = gmtime(x);
+}
+
+void test__std__gmtime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::gmtime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__gmtime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::gmtime(arg1);
+}
+
+void test__std__gmtime__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::gmtime(arg1) > 10) || (std::gmtime(arg1) < 100)) {}
+}
+
+void test__std__gmtime__leakignore() {
+  char *p = strdup(str);
+  result = std::gmtime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__gmtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::gmtime(NULL);
+}
+
+void test__std__gmtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::gmtime(x);
+}
+
+void test__isalnum__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isalnum(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isalnum__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isalnum(arg1);
+}
+
+void test__isalnum__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isalnum(arg1) > 10) || (isalnum(arg1) < 100)) {}
+}
+
+void test__isalnum__leakignore() {
+  char *p = strdup(str);
+  result = isalnum(p);
+  // cppcheck-suppress memleak
+}
+
+void test__isalnum__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isalnum(x);
+}
+
+void test__std__isalnum__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isalnum(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isalnum__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isalnum(arg1);
+}
+
+void test__std__isalnum__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isalnum(arg1) > 10) || (std::isalnum(arg1) < 100)) {}
+}
+
+void test__std__isalnum__leakignore() {
+  char *p = strdup(str);
+  result = std::isalnum(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isalnum__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isalnum(x);
+}
+
+void test__iswalnum__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = iswalnum(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__iswalnum__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswalnum(arg1);
+}
+
+void test__iswalnum__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswalnum(arg1) > 10) || (iswalnum(arg1) < 100)) {}
+}
+
+void test__iswalnum__leakignore() {
+  char *p = strdup(str);
+  result = iswalnum(p);
+  // cppcheck-suppress memleak
+}
+
+void test__iswalnum__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswalnum(x);
+}
+
+void test__std__iswalnum__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::iswalnum(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__iswalnum__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswalnum(arg1);
+}
+
+void test__std__iswalnum__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswalnum(arg1) > 10) || (std::iswalnum(arg1) < 100)) {}
+}
+
+void test__std__iswalnum__leakignore() {
+  char *p = strdup(str);
+  result = std::iswalnum(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__iswalnum__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswalnum(x);
+}
+
+void test__isalpha__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isalpha(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isalpha__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isalpha(arg1);
+}
+
+void test__isalpha__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isalpha(arg1) > 10) || (isalpha(arg1) < 100)) {}
+}
+
+void test__isalpha__leakignore() {
+  char *p = strdup(str);
+  result = isalpha(p);
+  // cppcheck-suppress memleak
+}
+
+void test__isalpha__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isalpha(x);
+}
+
+void test__std__isalpha__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isalpha(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isalpha__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isalpha(arg1);
+}
+
+void test__std__isalpha__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isalpha(arg1) > 10) || (std::isalpha(arg1) < 100)) {}
+}
+
+void test__std__isalpha__leakignore() {
+  char *p = strdup(str);
+  result = std::isalpha(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isalpha__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isalpha(x);
+}
+
+void test__iswalpha__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = iswalpha(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__iswalpha__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswalpha(arg1);
+}
+
+void test__iswalpha__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswalpha(arg1) > 10) || (iswalpha(arg1) < 100)) {}
+}
+
+void test__iswalpha__leakignore() {
+  char *p = strdup(str);
+  result = iswalpha(p);
+  // cppcheck-suppress memleak
+}
+
+void test__iswalpha__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswalpha(x);
+}
+
+void test__std__iswalpha__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::iswalpha(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__iswalpha__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswalpha(arg1);
+}
+
+void test__std__iswalpha__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswalpha(arg1) > 10) || (std::iswalpha(arg1) < 100)) {}
+}
+
+void test__std__iswalpha__leakignore() {
+  char *p = strdup(str);
+  result = std::iswalpha(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__iswalpha__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswalpha(x);
+}
+
+void test__isblank__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isblank(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isblank__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isblank(arg1);
+}
+
+void test__isblank__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isblank(arg1) > 10) || (isblank(arg1) < 100)) {}
+}
+
+void test__isblank__leakignore() {
+  char *p = strdup(str);
+  result = isblank(p);
+  // cppcheck-suppress memleak
+}
+
+void test__isblank__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isblank(x);
+}
+
+void test__std__isblank__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isblank(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isblank__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isblank(arg1);
+}
+
+void test__std__isblank__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isblank(arg1) > 10) || (std::isblank(arg1) < 100)) {}
+}
+
+void test__std__isblank__leakignore() {
+  char *p = strdup(str);
+  result = std::isblank(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isblank__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isblank(x);
+}
+
+void test__iswblank__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = iswblank(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__iswblank__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswblank(arg1);
+}
+
+void test__iswblank__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswblank(arg1) > 10) || (iswblank(arg1) < 100)) {}
+}
+
+void test__iswblank__leakignore() {
+  char *p = strdup(str);
+  result = iswblank(p);
+  // cppcheck-suppress memleak
+}
+
+void test__iswblank__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswblank(x);
+}
+
+void test__std__iswblank__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::iswblank(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__iswblank__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswblank(arg1);
+}
+
+void test__std__iswblank__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswblank(arg1) > 10) || (std::iswblank(arg1) < 100)) {}
+}
+
+void test__std__iswblank__leakignore() {
+  char *p = strdup(str);
+  result = std::iswblank(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__iswblank__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswblank(x);
+}
+
+void test__iscntrl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = iscntrl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__iscntrl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iscntrl(arg1);
+}
+
+void test__iscntrl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iscntrl(arg1) > 10) || (iscntrl(arg1) < 100)) {}
+}
+
+void test__iscntrl__leakignore() {
+  char *p = strdup(str);
+  result = iscntrl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__iscntrl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iscntrl(x);
+}
+
+void test__std__iscntrl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::iscntrl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__iscntrl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iscntrl(arg1);
+}
+
+void test__std__iscntrl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iscntrl(arg1) > 10) || (std::iscntrl(arg1) < 100)) {}
+}
+
+void test__std__iscntrl__leakignore() {
+  char *p = strdup(str);
+  result = std::iscntrl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__iscntrl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iscntrl(x);
+}
+
+void test__iswcntrl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = iswcntrl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__iswcntrl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswcntrl(arg1);
+}
+
+void test__iswcntrl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswcntrl(arg1) > 10) || (iswcntrl(arg1) < 100)) {}
+}
+
+void test__iswcntrl__leakignore() {
+  char *p = strdup(str);
+  result = iswcntrl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__iswcntrl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswcntrl(x);
+}
+
+void test__std__iswcntrl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::iswcntrl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__iswcntrl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswcntrl(arg1);
+}
+
+void test__std__iswcntrl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswcntrl(arg1) > 10) || (std::iswcntrl(arg1) < 100)) {}
+}
+
+void test__std__iswcntrl__leakignore() {
+  char *p = strdup(str);
+  result = std::iswcntrl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__iswcntrl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswcntrl(x);
+}
+
+void test__iswctype__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = iswctype(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__iswctype__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswctype(arg1, arg2);
+}
+
+void test__iswctype__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswctype(arg1, arg2) > 10) || (iswctype(arg1, arg2) < 100)) {}
+}
+
+void test__iswctype__leakignore() {
+  char *p = strdup(str);
+  result = iswctype(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__iswctype__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswctype(x, arg2);
+}
+
+void test__iswctype__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswctype(arg1, x);
+}
+
+void test__std__iswctype__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::iswctype(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__iswctype__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswctype(arg1, arg2);
+}
+
+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__std__iswctype__leakignore() {
+  char *p = strdup(str);
+  result = std::iswctype(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__iswctype__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswctype(x, arg2);
+}
+
+void test__std__iswctype__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswctype(arg1, x);
+}
+
+void test__isdigit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isdigit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isdigit(arg1);
+}
+
+void test__isdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isdigit(arg1) > 10) || (isdigit(arg1) < 100)) {}
+}
+
+void test__isdigit__leakignore() {
+  char *p = strdup(str);
+  result = isdigit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__isdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isdigit(x);
+}
+
+void test__std__isdigit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isdigit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isdigit(arg1);
+}
+
+void test__std__isdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isdigit(arg1) > 10) || (std::isdigit(arg1) < 100)) {}
+}
+
+void test__std__isdigit__leakignore() {
+  char *p = strdup(str);
+  result = std::isdigit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isdigit(x);
+}
+
+void test__iswdigit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = iswdigit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__iswdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswdigit(arg1);
+}
+
+void test__iswdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswdigit(arg1) > 10) || (iswdigit(arg1) < 100)) {}
+}
+
+void test__iswdigit__leakignore() {
+  char *p = strdup(str);
+  result = iswdigit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__iswdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswdigit(x);
+}
+
+void test__std__iswdigit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::iswdigit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__iswdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswdigit(arg1);
+}
+
+void test__std__iswdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswdigit(arg1) > 10) || (std::iswdigit(arg1) < 100)) {}
+}
+
+void test__std__iswdigit__leakignore() {
+  char *p = strdup(str);
+  result = std::iswdigit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__iswdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswdigit(x);
+}
+
+void test__isgraph__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isgraph(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isgraph__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isgraph(arg1);
+}
+
+void test__isgraph__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isgraph(arg1) > 10) || (isgraph(arg1) < 100)) {}
+}
+
+void test__isgraph__leakignore() {
+  char *p = strdup(str);
+  result = isgraph(p);
+  // cppcheck-suppress memleak
+}
+
+void test__isgraph__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isgraph(x);
+}
+
+void test__std__isgraph__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isgraph(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isgraph__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isgraph(arg1);
+}
+
+void test__std__isgraph__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isgraph(arg1) > 10) || (std::isgraph(arg1) < 100)) {}
+}
+
+void test__std__isgraph__leakignore() {
+  char *p = strdup(str);
+  result = std::isgraph(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isgraph__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isgraph(x);
+}
+
+void test__iswgraph__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = iswgraph(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__iswgraph__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswgraph(arg1);
+}
+
+void test__iswgraph__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswgraph(arg1) > 10) || (iswgraph(arg1) < 100)) {}
+}
+
+void test__iswgraph__leakignore() {
+  char *p = strdup(str);
+  result = iswgraph(p);
+  // cppcheck-suppress memleak
+}
+
+void test__iswgraph__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswgraph(x);
+}
+
+void test__std__iswgraph__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::iswgraph(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__iswgraph__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswgraph(arg1);
+}
+
+void test__std__iswgraph__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswgraph(arg1) > 10) || (std::iswgraph(arg1) < 100)) {}
+}
+
+void test__std__iswgraph__leakignore() {
+  char *p = strdup(str);
+  result = std::iswgraph(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__iswgraph__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswgraph(x);
+}
+
+void test__islower__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = islower(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__islower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  islower(arg1);
+}
+
+void test__islower__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((islower(arg1) > 10) || (islower(arg1) < 100)) {}
+}
+
+void test__islower__leakignore() {
+  char *p = strdup(str);
+  result = islower(p);
+  // cppcheck-suppress memleak
+}
+
+void test__islower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = islower(x);
+}
+
+void test__std__islower__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::islower(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__islower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::islower(arg1);
+}
+
+void test__std__islower__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::islower(arg1) > 10) || (std::islower(arg1) < 100)) {}
+}
+
+void test__std__islower__leakignore() {
+  char *p = strdup(str);
+  result = std::islower(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__islower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::islower(x);
+}
+
+void test__iswlower__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = iswlower(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__iswlower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswlower(arg1);
+}
+
+void test__iswlower__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswlower(arg1) > 10) || (iswlower(arg1) < 100)) {}
+}
+
+void test__iswlower__leakignore() {
+  char *p = strdup(str);
+  result = iswlower(p);
+  // cppcheck-suppress memleak
+}
+
+void test__iswlower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswlower(x);
+}
+
+void test__std__iswlower__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::iswlower(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__iswlower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswlower(arg1);
+}
+
+void test__std__iswlower__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswlower(arg1) > 10) || (std::iswlower(arg1) < 100)) {}
+}
+
+void test__std__iswlower__leakignore() {
+  char *p = strdup(str);
+  result = std::iswlower(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__iswlower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswlower(x);
+}
+
+void test__isprint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isprint(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isprint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isprint(arg1);
+}
+
+void test__isprint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isprint(arg1) > 10) || (isprint(arg1) < 100)) {}
+}
+
+void test__isprint__leakignore() {
+  char *p = strdup(str);
+  result = isprint(p);
+  // cppcheck-suppress memleak
+}
+
+void test__isprint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isprint(x);
+}
+
+void test__std__isprint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isprint(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isprint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isprint(arg1);
+}
+
+void test__std__isprint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isprint(arg1) > 10) || (std::isprint(arg1) < 100)) {}
+}
+
+void test__std__isprint__leakignore() {
+  char *p = strdup(str);
+  result = std::isprint(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isprint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isprint(x);
+}
+
+void test__iswprint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = iswprint(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__iswprint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswprint(arg1);
+}
+
+void test__iswprint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswprint(arg1) > 10) || (iswprint(arg1) < 100)) {}
+}
+
+void test__iswprint__leakignore() {
+  char *p = strdup(str);
+  result = iswprint(p);
+  // cppcheck-suppress memleak
+}
+
+void test__iswprint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswprint(x);
+}
+
+void test__std__iswprint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::iswprint(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__iswprint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswprint(arg1);
+}
+
+void test__std__iswprint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswprint(arg1) > 10) || (std::iswprint(arg1) < 100)) {}
+}
+
+void test__std__iswprint__leakignore() {
+  char *p = strdup(str);
+  result = std::iswprint(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__iswprint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswprint(x);
+}
+
+void test__ispunct__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ispunct(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ispunct__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ispunct(arg1);
+}
+
+void test__ispunct__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ispunct(arg1) > 10) || (ispunct(arg1) < 100)) {}
+}
+
+void test__ispunct__leakignore() {
+  char *p = strdup(str);
+  result = ispunct(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ispunct__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ispunct(x);
+}
+
+void test__std__ispunct__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::ispunct(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ispunct__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ispunct(arg1);
+}
+
+void test__std__ispunct__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::ispunct(arg1) > 10) || (std::ispunct(arg1) < 100)) {}
+}
+
+void test__std__ispunct__leakignore() {
+  char *p = strdup(str);
+  result = std::ispunct(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ispunct__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ispunct(x);
+}
+
+void test__iswpunct__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = iswpunct(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__iswpunct__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswpunct(arg1);
+}
+
+void test__iswpunct__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswpunct(arg1) > 10) || (iswpunct(arg1) < 100)) {}
+}
+
+void test__iswpunct__leakignore() {
+  char *p = strdup(str);
+  result = iswpunct(p);
+  // cppcheck-suppress memleak
+}
+
+void test__iswpunct__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswpunct(x);
+}
+
+void test__std__iswpunct__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::iswpunct(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__iswpunct__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswpunct(arg1);
+}
+
+void test__std__iswpunct__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswpunct(arg1) > 10) || (std::iswpunct(arg1) < 100)) {}
+}
+
+void test__std__iswpunct__leakignore() {
+  char *p = strdup(str);
+  result = std::iswpunct(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__iswpunct__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswpunct(x);
+}
+
+void test__isspace__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isspace(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isspace__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isspace(arg1);
+}
+
+void test__isspace__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isspace(arg1) > 10) || (isspace(arg1) < 100)) {}
+}
+
+void test__isspace__leakignore() {
+  char *p = strdup(str);
+  result = isspace(p);
+  // cppcheck-suppress memleak
+}
+
+void test__isspace__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isspace(x);
+}
+
+void test__std__isspace__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isspace(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isspace__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isspace(arg1);
+}
+
+void test__std__isspace__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isspace(arg1) > 10) || (std::isspace(arg1) < 100)) {}
+}
+
+void test__std__isspace__leakignore() {
+  char *p = strdup(str);
+  result = std::isspace(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isspace__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isspace(x);
+}
+
+void test__iswspace__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = iswspace(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__iswspace__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswspace(arg1);
+}
+
+void test__iswspace__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswspace(arg1) > 10) || (iswspace(arg1) < 100)) {}
+}
+
+void test__iswspace__leakignore() {
+  char *p = strdup(str);
+  result = iswspace(p);
+  // cppcheck-suppress memleak
+}
+
+void test__iswspace__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswspace(x);
+}
+
+void test__std__iswspace__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::iswspace(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__iswspace__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswspace(arg1);
+}
+
+void test__std__iswspace__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswspace(arg1) > 10) || (std::iswspace(arg1) < 100)) {}
+}
+
+void test__std__iswspace__leakignore() {
+  char *p = strdup(str);
+  result = std::iswspace(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__iswspace__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswspace(x);
+}
+
+void test__isupper__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isupper(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isupper(arg1);
+}
+
+void test__isupper__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isupper(arg1) > 10) || (isupper(arg1) < 100)) {}
+}
+
+void test__isupper__leakignore() {
+  char *p = strdup(str);
+  result = isupper(p);
+  // cppcheck-suppress memleak
+}
+
+void test__isupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isupper(x);
+}
+
+void test__std__isupper__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isupper(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isupper(arg1);
+}
+
+void test__std__isupper__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isupper(arg1) > 10) || (std::isupper(arg1) < 100)) {}
+}
+
+void test__std__isupper__leakignore() {
+  char *p = strdup(str);
+  result = std::isupper(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isupper(x);
+}
+
+void test__iswupper__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = iswupper(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__iswupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswupper(arg1);
+}
+
+void test__iswupper__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswupper(arg1) > 10) || (iswupper(arg1) < 100)) {}
+}
+
+void test__iswupper__leakignore() {
+  char *p = strdup(str);
+  result = iswupper(p);
+  // cppcheck-suppress memleak
+}
+
+void test__iswupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswupper(x);
+}
+
+void test__std__iswupper__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::iswupper(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__iswupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswupper(arg1);
+}
+
+void test__std__iswupper__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswupper(arg1) > 10) || (std::iswupper(arg1) < 100)) {}
+}
+
+void test__std__iswupper__leakignore() {
+  char *p = strdup(str);
+  result = std::iswupper(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__iswupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswupper(x);
+}
+
+void test__isxdigit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isxdigit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isxdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isxdigit(arg1);
+}
+
+void test__isxdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isxdigit(arg1) > 10) || (isxdigit(arg1) < 100)) {}
+}
+
+void test__isxdigit__leakignore() {
+  char *p = strdup(str);
+  result = isxdigit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__isxdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isxdigit(x);
+}
+
+void test__std__isxdigit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isxdigit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isxdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isxdigit(arg1);
+}
+
+void test__std__isxdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isxdigit(arg1) > 10) || (std::isxdigit(arg1) < 100)) {}
+}
+
+void test__std__isxdigit__leakignore() {
+  char *p = strdup(str);
+  result = std::isxdigit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isxdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isxdigit(x);
+}
+
+void test__iswxdigit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = iswxdigit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__iswxdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  iswxdigit(arg1);
+}
+
+void test__iswxdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((iswxdigit(arg1) > 10) || (iswxdigit(arg1) < 100)) {}
+}
+
+void test__iswxdigit__leakignore() {
+  char *p = strdup(str);
+  result = iswxdigit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__iswxdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = iswxdigit(x);
+}
+
+void test__std__iswxdigit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::iswxdigit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__iswxdigit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::iswxdigit(arg1);
+}
+
+void test__std__iswxdigit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::iswxdigit(arg1) > 10) || (std::iswxdigit(arg1) < 100)) {}
+}
+
+void test__std__iswxdigit__leakignore() {
+  char *p = strdup(str);
+  result = std::iswxdigit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__iswxdigit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::iswxdigit(x);
+}
+
+void test__towctrans__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = towctrans(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__towctrans__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  towctrans(arg1, arg2);
+}
+
+void test__towctrans__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((towctrans(arg1, arg2) > 10) || (towctrans(arg1, arg2) < 100)) {}
+}
+
+void test__towctrans__leakignore() {
+  char *p = strdup(str);
+  result = towctrans(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__towctrans__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = towctrans(x, arg2);
+}
+
+void test__towctrans__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = towctrans(arg1, x);
+}
+
+void test__std__towctrans__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::towctrans(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__towctrans__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::towctrans(arg1, 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__towctrans__leakignore() {
+  char *p = strdup(str);
+  result = std::towctrans(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__towctrans__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::towctrans(x, arg2);
+}
+
+void test__std__towctrans__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::towctrans(arg1, x);
+}
+
+void test__towlower__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = towlower(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__towlower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  towlower(arg1);
+}
+
+void test__towlower__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((towlower(arg1) > 10) || (towlower(arg1) < 100)) {}
+}
+
+void test__towlower__leakignore() {
+  char *p = strdup(str);
+  result = towlower(p);
+  // cppcheck-suppress memleak
+}
+
+void test__towlower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = towlower(x);
+}
+
+void test__std__towlower__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::towlower(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__towlower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::towlower(arg1);
+}
+
+void test__std__towlower__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::towlower(arg1) > 10) || (std::towlower(arg1) < 100)) {}
+}
+
+void test__std__towlower__leakignore() {
+  char *p = strdup(str);
+  result = std::towlower(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__towlower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::towlower(x);
+}
+
+void test__towupper__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = towupper(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__towupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  towupper(arg1);
+}
+
+void test__towupper__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((towupper(arg1) > 10) || (towupper(arg1) < 100)) {}
+}
+
+void test__towupper__leakignore() {
+  char *p = strdup(str);
+  result = towupper(p);
+  // cppcheck-suppress memleak
+}
+
+void test__towupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = towupper(x);
+}
+
+void test__std__towupper__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::towupper(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__towupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::towupper(arg1);
+}
+
+void test__std__towupper__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::towupper(arg1) > 10) || (std::towupper(arg1) < 100)) {}
+}
+
+void test__std__towupper__leakignore() {
+  char *p = strdup(str);
+  result = std::towupper(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__towupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::towupper(x);
+}
+
+void test__wctrans__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wctrans(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wctrans__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wctrans(arg1);
+}
+
+void test__wctrans__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wctrans(arg1) > 10) || (wctrans(arg1) < 100)) {}
+}
+
+void test__wctrans__leakignore() {
+  char *p = strdup(str);
+  result = wctrans(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wctrans__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wctrans(NULL);
+}
+
+void test__wctrans__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wctrans(x);
+}
+
+void test__std__wctrans__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wctrans(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wctrans__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wctrans(arg1);
+}
+
+void test__std__wctrans__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wctrans(arg1) > 10) || (std::wctrans(arg1) < 100)) {}
+}
+
+void test__std__wctrans__leakignore() {
+  char *p = strdup(str);
+  result = std::wctrans(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wctrans__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wctrans(NULL);
+}
+
+void test__std__wctrans__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wctrans(x);
+}
+
+void test__wctype__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wctype(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wctype__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wctype(arg1);
+}
+
+void test__wctype__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wctype(arg1) > 10) || (wctype(arg1) < 100)) {}
+}
+
+void test__wctype__leakignore() {
+  char *p = strdup(str);
+  result = wctype(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wctype__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wctype(NULL);
+}
+
+void test__wctype__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wctype(x);
+}
+
+void test__std__wctype__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wctype(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wctype__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wctype(arg1);
+}
+
+void test__std__wctype__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wctype(arg1) > 10) || (std::wctype(arg1) < 100)) {}
+}
+
+void test__std__wctype__leakignore() {
+  char *p = strdup(str);
+  result = std::wctype(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wctype__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wctype(NULL);
+}
+
+void test__std__wctype__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wctype(x);
+}
+
+void test__cabs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cabs(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cabs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cabs(arg1);
+}
+
+void test__cabs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cabs(arg1) > 10) || (cabs(arg1) < 100)) {}
+}
+
+void test__cabs__leakignore() {
+  char *p = strdup(str);
+  result = cabs(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cabs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cabs(x);
+}
+
+void test__cabsf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cabsf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cabsf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cabsf(arg1);
+}
+
+void test__cabsf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cabsf(arg1) > 10) || (cabsf(arg1) < 100)) {}
+}
+
+void test__cabsf__leakignore() {
+  char *p = strdup(str);
+  result = cabsf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cabsf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cabsf(x);
+}
+
+void test__cabsl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cabsl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cabsl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cabsl(arg1);
+}
+
+void test__cabsl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cabsl(arg1) > 10) || (cabsl(arg1) < 100)) {}
+}
+
+void test__cabsl__leakignore() {
+  char *p = strdup(str);
+  result = cabsl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cabsl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cabsl(x);
+}
+
+void test__cacos__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cacos(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cacos__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cacos(arg1);
+}
+
+void test__cacos__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cacos(arg1) > 10) || (cacos(arg1) < 100)) {}
+}
+
+void test__cacos__leakignore() {
+  char *p = strdup(str);
+  result = cacos(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cacos__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cacos(x);
+}
+
+void test__cacosf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cacosf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cacosf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cacosf(arg1);
+}
+
+void test__cacosf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cacosf(arg1) > 10) || (cacosf(arg1) < 100)) {}
+}
+
+void test__cacosf__leakignore() {
+  char *p = strdup(str);
+  result = cacosf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cacosf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cacosf(x);
+}
+
+void test__cacosl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cacosl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cacosl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cacosl(arg1);
+}
+
+void test__cacosl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cacosl(arg1) > 10) || (cacosl(arg1) < 100)) {}
+}
+
+void test__cacosl__leakignore() {
+  char *p = strdup(str);
+  result = cacosl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cacosl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cacosl(x);
+}
+
+void test__cacosh__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cacosh(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cacosh__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cacosh(arg1);
+}
+
+void test__cacosh__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cacosh(arg1) > 10) || (cacosh(arg1) < 100)) {}
+}
+
+void test__cacosh__leakignore() {
+  char *p = strdup(str);
+  result = cacosh(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cacosh__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cacosh(x);
+}
+
+void test__cacoshf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cacoshf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cacoshf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cacoshf(arg1);
+}
+
+void test__cacoshf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cacoshf(arg1) > 10) || (cacoshf(arg1) < 100)) {}
+}
+
+void test__cacoshf__leakignore() {
+  char *p = strdup(str);
+  result = cacoshf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cacoshf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cacoshf(x);
+}
+
+void test__cacoshl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cacoshl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cacoshl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cacoshl(arg1);
+}
+
+void test__cacoshl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cacoshl(arg1) > 10) || (cacoshl(arg1) < 100)) {}
+}
+
+void test__cacoshl__leakignore() {
+  char *p = strdup(str);
+  result = cacoshl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__cacoshl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cacoshl(x);
+}
+
+void test__labs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = labs(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__labs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  labs(arg1);
+}
+
+void test__labs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((labs(arg1) > 10) || (labs(arg1) < 100)) {}
+}
+
+void test__labs__leakignore() {
+  char *p = strdup(str);
+  result = labs(p);
+  // cppcheck-suppress memleak
+}
+
+void test__labs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = labs(x);
+}
+
+void test__std__labs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::labs(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__labs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::labs(arg1);
+}
+
+void test__std__labs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::labs(arg1) > 10) || (std::labs(arg1) < 100)) {}
+}
+
+void test__std__labs__leakignore() {
+  char *p = strdup(str);
+  result = std::labs(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__labs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::labs(x);
+}
+
+void test__llabs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = llabs(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__llabs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  llabs(arg1);
+}
+
+void test__llabs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((llabs(arg1) > 10) || (llabs(arg1) < 100)) {}
+}
+
+void test__llabs__leakignore() {
+  char *p = strdup(str);
+  result = llabs(p);
+  // cppcheck-suppress memleak
+}
+
+void test__llabs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = llabs(x);
+}
+
+void test__std__llabs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::llabs(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__llabs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::llabs(arg1);
+}
+
+void test__std__llabs__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::llabs(arg1) > 10) || (std::llabs(arg1) < 100)) {}
+}
+
+void test__std__llabs__leakignore() {
+  char *p = strdup(str);
+  result = std::llabs(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__llabs__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::llabs(x);
+}
+
+void test__ldexp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ldexp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ldexp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ldexp(arg1, arg2);
+}
+
+void test__ldexp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ldexp(arg1, arg2) > 10) || (ldexp(arg1, arg2) < 100)) {}
+}
+
+void test__ldexp__leakignore() {
+  char *p = strdup(str);
+  result = ldexp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__ldexp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ldexp(x, arg2);
+}
+
+void test__ldexp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ldexp(arg1, x);
+}
+
+void test__std__ldexp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::ldexp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ldexp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ldexp(arg1, arg2);
+}
+
+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__std__ldexp__leakignore() {
+  char *p = strdup(str);
+  result = std::ldexp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ldexp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ldexp(x, arg2);
+}
+
+void test__std__ldexp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ldexp(arg1, x);
+}
+
+void test__ldexpf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ldexpf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ldexpf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ldexpf(arg1, arg2);
+}
+
+void test__ldexpf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ldexpf(arg1, arg2) > 10) || (ldexpf(arg1, arg2) < 100)) {}
+}
+
+void test__ldexpf__leakignore() {
+  char *p = strdup(str);
+  result = ldexpf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__ldexpf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ldexpf(x, arg2);
+}
+
+void test__ldexpf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ldexpf(arg1, x);
+}
+
+void test__std__ldexpf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::ldexpf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ldexpf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ldexpf(arg1, arg2);
+}
+
+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__std__ldexpf__leakignore() {
+  char *p = strdup(str);
+  result = std::ldexpf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ldexpf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ldexpf(x, arg2);
+}
+
+void test__std__ldexpf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ldexpf(arg1, x);
+}
+
+void test__ldexpl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ldexpl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ldexpl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ldexpl(arg1, arg2);
+}
+
+void test__ldexpl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ldexpl(arg1, arg2) > 10) || (ldexpl(arg1, arg2) < 100)) {}
+}
+
+void test__ldexpl__leakignore() {
+  char *p = strdup(str);
+  result = ldexpl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__ldexpl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ldexpl(x, arg2);
+}
+
+void test__ldexpl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ldexpl(arg1, x);
+}
+
+void test__std__ldexpl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::ldexpl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ldexpl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ldexpl(arg1, arg2);
+}
+
+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__ldexpl__leakignore() {
+  char *p = strdup(str);
+  result = std::ldexpl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ldexpl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ldexpl(x, arg2);
+}
+
+void test__std__ldexpl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ldexpl(arg1, x);
+}
+
+void test__lgamma__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = lgamma(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__lgamma__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lgamma(arg1);
+}
+
+void test__lgamma__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lgamma(arg1) > 10) || (lgamma(arg1) < 100)) {}
+}
+
+void test__lgamma__leakignore() {
+  char *p = strdup(str);
+  result = lgamma(p);
+  // cppcheck-suppress memleak
+}
+
+void test__lgamma__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lgamma(x);
+}
+
+void test__std__lgamma__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::lgamma(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__lgamma__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lgamma(arg1);
+}
+
+void test__std__lgamma__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lgamma(arg1) > 10) || (std::lgamma(arg1) < 100)) {}
+}
+
+void test__std__lgamma__leakignore() {
+  char *p = strdup(str);
+  result = std::lgamma(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__lgamma__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lgamma(x);
+}
+
+void test__lgammaf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = lgammaf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__lgammaf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lgammaf(arg1);
+}
+
+void test__lgammaf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lgammaf(arg1) > 10) || (lgammaf(arg1) < 100)) {}
+}
+
+void test__lgammaf__leakignore() {
+  char *p = strdup(str);
+  result = lgammaf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__lgammaf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lgammaf(x);
+}
+
+void test__std__lgammaf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::lgammaf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__lgammaf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lgammaf(arg1);
+}
+
+void test__std__lgammaf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lgammaf(arg1) > 10) || (std::lgammaf(arg1) < 100)) {}
+}
+
+void test__std__lgammaf__leakignore() {
+  char *p = strdup(str);
+  result = std::lgammaf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__lgammaf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lgammaf(x);
+}
+
+void test__lgammal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = lgammal(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__lgammal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lgammal(arg1);
+}
+
+void test__lgammal__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lgammal(arg1) > 10) || (lgammal(arg1) < 100)) {}
+}
+
+void test__lgammal__leakignore() {
+  char *p = strdup(str);
+  result = lgammal(p);
+  // cppcheck-suppress memleak
+}
+
+void test__lgammal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lgammal(x);
+}
+
+void test__std__lgammal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::lgammal(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__lgammal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lgammal(arg1);
+}
+
+void test__std__lgammal__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lgammal(arg1) > 10) || (std::lgammal(arg1) < 100)) {}
+}
+
+void test__std__lgammal__leakignore() {
+  char *p = strdup(str);
+  result = std::lgammal(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__lgammal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lgammal(x);
+}
+
+void test__rint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = rint(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__rint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  rint(arg1);
+}
+
+void test__rint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((rint(arg1) > 10) || (rint(arg1) < 100)) {}
+}
+
+void test__rint__leakignore() {
+  char *p = strdup(str);
+  result = rint(p);
+  // cppcheck-suppress memleak
+}
+
+void test__rint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = rint(x);
+}
+
+void test__std__rint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::rint(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__rint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::rint(arg1);
+}
+
+void test__std__rint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::rint(arg1) > 10) || (std::rint(arg1) < 100)) {}
+}
+
+void test__std__rint__leakignore() {
+  char *p = strdup(str);
+  result = std::rint(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__rint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::rint(x);
+}
+
+void test__rintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = rintf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__rintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  rintf(arg1);
+}
+
+void test__rintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((rintf(arg1) > 10) || (rintf(arg1) < 100)) {}
+}
+
+void test__rintf__leakignore() {
+  char *p = strdup(str);
+  result = rintf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__rintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = rintf(x);
+}
+
+void test__std__rintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::rintf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__rintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::rintf(arg1);
+}
+
+void test__std__rintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::rintf(arg1) > 10) || (std::rintf(arg1) < 100)) {}
+}
+
+void test__std__rintf__leakignore() {
+  char *p = strdup(str);
+  result = std::rintf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__rintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::rintf(x);
+}
+
+void test__rintl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = rintl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__rintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  rintl(arg1);
+}
+
+void test__rintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((rintl(arg1) > 10) || (rintl(arg1) < 100)) {}
+}
+
+void test__rintl__leakignore() {
+  char *p = strdup(str);
+  result = rintl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__rintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = rintl(x);
+}
+
+void test__std__rintl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::rintl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__rintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::rintl(arg1);
+}
+
+void test__std__rintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::rintl(arg1) > 10) || (std::rintl(arg1) < 100)) {}
+}
+
+void test__std__rintl__leakignore() {
+  char *p = strdup(str);
+  result = std::rintl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__rintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::rintl(x);
+}
+
+void test__lrint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = lrint(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__lrint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lrint(arg1);
+}
+
+void test__lrint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lrint(arg1) > 10) || (lrint(arg1) < 100)) {}
+}
+
+void test__lrint__leakignore() {
+  char *p = strdup(str);
+  result = lrint(p);
+  // cppcheck-suppress memleak
+}
+
+void test__lrint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lrint(x);
+}
+
+void test__std__lrint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::lrint(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__lrint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lrint(arg1);
+}
+
+void test__std__lrint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lrint(arg1) > 10) || (std::lrint(arg1) < 100)) {}
+}
+
+void test__std__lrint__leakignore() {
+  char *p = strdup(str);
+  result = std::lrint(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__lrint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lrint(x);
+}
+
+void test__lrintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = lrintf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__lrintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lrintf(arg1);
+}
+
+void test__lrintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lrintf(arg1) > 10) || (lrintf(arg1) < 100)) {}
+}
+
+void test__lrintf__leakignore() {
+  char *p = strdup(str);
+  result = lrintf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__lrintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lrintf(x);
+}
+
+void test__std__lrintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::lrintf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__lrintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lrintf(arg1);
+}
+
+void test__std__lrintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lrintf(arg1) > 10) || (std::lrintf(arg1) < 100)) {}
+}
+
+void test__std__lrintf__leakignore() {
+  char *p = strdup(str);
+  result = std::lrintf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__lrintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lrintf(x);
+}
+
+void test__lrintl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = lrintl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__lrintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lrintl(arg1);
+}
+
+void test__lrintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lrintl(arg1) > 10) || (lrintl(arg1) < 100)) {}
+}
+
+void test__lrintl__leakignore() {
+  char *p = strdup(str);
+  result = lrintl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__lrintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lrintl(x);
+}
+
+void test__std__lrintl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::lrintl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__lrintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lrintl(arg1);
+}
+
+void test__std__lrintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lrintl(arg1) > 10) || (std::lrintl(arg1) < 100)) {}
+}
+
+void test__std__lrintl__leakignore() {
+  char *p = strdup(str);
+  result = std::lrintl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__lrintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lrintl(x);
+}
+
+void test__llrint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = llrint(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__llrint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  llrint(arg1);
+}
+
+void test__llrint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((llrint(arg1) > 10) || (llrint(arg1) < 100)) {}
+}
+
+void test__llrint__leakignore() {
+  char *p = strdup(str);
+  result = llrint(p);
+  // cppcheck-suppress memleak
+}
+
+void test__llrint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = llrint(x);
+}
+
+void test__std__llrint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::llrint(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__llrint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::llrint(arg1);
+}
+
+void test__std__llrint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::llrint(arg1) > 10) || (std::llrint(arg1) < 100)) {}
+}
+
+void test__std__llrint__leakignore() {
+  char *p = strdup(str);
+  result = std::llrint(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__llrint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::llrint(x);
+}
+
+void test__llrintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = llrintf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__llrintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  llrintf(arg1);
+}
+
+void test__llrintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((llrintf(arg1) > 10) || (llrintf(arg1) < 100)) {}
+}
+
+void test__llrintf__leakignore() {
+  char *p = strdup(str);
+  result = llrintf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__llrintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = llrintf(x);
+}
+
+void test__std__llrintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::llrintf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__llrintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::llrintf(arg1);
+}
+
+void test__std__llrintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::llrintf(arg1) > 10) || (std::llrintf(arg1) < 100)) {}
+}
+
+void test__std__llrintf__leakignore() {
+  char *p = strdup(str);
+  result = std::llrintf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__llrintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::llrintf(x);
+}
+
+void test__llrintl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = llrintl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__llrintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  llrintl(arg1);
+}
+
+void test__llrintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((llrintl(arg1) > 10) || (llrintl(arg1) < 100)) {}
+}
+
+void test__llrintl__leakignore() {
+  char *p = strdup(str);
+  result = llrintl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__llrintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = llrintl(x);
+}
+
+void test__std__llrintl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::llrintl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__llrintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::llrintl(arg1);
+}
+
+void test__std__llrintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::llrintl(arg1) > 10) || (std::llrintl(arg1) < 100)) {}
+}
+
+void test__std__llrintl__leakignore() {
+  char *p = strdup(str);
+  result = std::llrintl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__llrintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::llrintl(x);
+}
+
+void test__llround__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = llround(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__llround__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  llround(arg1);
+}
+
+void test__llround__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((llround(arg1) > 10) || (llround(arg1) < 100)) {}
+}
+
+void test__llround__leakignore() {
+  char *p = strdup(str);
+  result = llround(p);
+  // cppcheck-suppress memleak
+}
+
+void test__llround__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = llround(x);
+}
+
+void test__std__llround__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::llround(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__llround__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::llround(arg1);
+}
+
+void test__std__llround__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::llround(arg1) > 10) || (std::llround(arg1) < 100)) {}
+}
+
+void test__std__llround__leakignore() {
+  char *p = strdup(str);
+  result = std::llround(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__llround__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::llround(x);
+}
+
+void test__llroundf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = llroundf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__llroundf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  llroundf(arg1);
+}
+
+void test__llroundf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((llroundf(arg1) > 10) || (llroundf(arg1) < 100)) {}
+}
+
+void test__llroundf__leakignore() {
+  char *p = strdup(str);
+  result = llroundf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__llroundf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = llroundf(x);
+}
+
+void test__std__llroundf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::llroundf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__llroundf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::llroundf(arg1);
+}
+
+void test__std__llroundf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::llroundf(arg1) > 10) || (std::llroundf(arg1) < 100)) {}
+}
+
+void test__std__llroundf__leakignore() {
+  char *p = strdup(str);
+  result = std::llroundf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__llroundf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::llroundf(x);
+}
+
+void test__llroundl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = llroundl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__llroundl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  llroundl(arg1);
+}
+
+void test__llroundl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((llroundl(arg1) > 10) || (llroundl(arg1) < 100)) {}
+}
+
+void test__llroundl__leakignore() {
+  char *p = strdup(str);
+  result = llroundl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__llroundl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = llroundl(x);
+}
+
+void test__std__llroundl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::llroundl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__llroundl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::llroundl(arg1);
+}
+
+void test__std__llroundl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::llroundl(arg1) > 10) || (std::llroundl(arg1) < 100)) {}
+}
+
+void test__std__llroundl__leakignore() {
+  char *p = strdup(str);
+  result = std::llroundl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__llroundl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::llroundl(x);
+}
+
+void test__lround__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = lround(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__lround__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lround(arg1);
+}
+
+void test__lround__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lround(arg1) > 10) || (lround(arg1) < 100)) {}
+}
+
+void test__lround__leakignore() {
+  char *p = strdup(str);
+  result = lround(p);
+  // cppcheck-suppress memleak
+}
+
+void test__lround__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lround(x);
+}
+
+void test__std__lround__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::lround(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__lround__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lround(arg1);
+}
+
+void test__std__lround__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lround(arg1) > 10) || (std::lround(arg1) < 100)) {}
+}
+
+void test__std__lround__leakignore() {
+  char *p = strdup(str);
+  result = std::lround(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__lround__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lround(x);
+}
+
+void test__lroundf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = lroundf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__lroundf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lroundf(arg1);
+}
+
+void test__lroundf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lroundf(arg1) > 10) || (lroundf(arg1) < 100)) {}
+}
+
+void test__lroundf__leakignore() {
+  char *p = strdup(str);
+  result = lroundf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__lroundf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lroundf(x);
+}
+
+void test__std__lroundf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::lroundf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__lroundf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lroundf(arg1);
+}
+
+void test__std__lroundf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lroundf(arg1) > 10) || (std::lroundf(arg1) < 100)) {}
+}
+
+void test__std__lroundf__leakignore() {
+  char *p = strdup(str);
+  result = std::lroundf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__lroundf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lroundf(x);
+}
+
+void test__lroundl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = lroundl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__lroundl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  lroundl(arg1);
+}
+
+void test__lroundl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lroundl(arg1) > 10) || (lroundl(arg1) < 100)) {}
+}
+
+void test__lroundl__leakignore() {
+  char *p = strdup(str);
+  result = lroundl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__lroundl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = lroundl(x);
+}
+
+void test__std__lroundl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::lroundl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__lroundl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::lroundl(arg1);
+}
+
+void test__std__lroundl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lroundl(arg1) > 10) || (std::lroundl(arg1) < 100)) {}
+}
+
+void test__std__lroundl__leakignore() {
+  char *p = strdup(str);
+  result = std::lroundl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__lroundl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::lroundl(x);
+}
+
+void test__rand__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = rand();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__rand__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  rand();
+}
+
+void test__rand__leakignore() {
+  char *p = strdup(str);
+  result = rand();
+  // cppcheck-suppress memleak
+}
+
+void test__srand__noreturn() {
+  int x = 100;
+  if (cond) x=1; else srand(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__srand__leakignore() {
+  char *p = strdup(str);
+  srand(p);
+  // cppcheck-suppress memleak
+}
+
+void test__srand__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  srand(x);
+}
+
+void test__std__srand__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::srand(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__srand__leakignore() {
+  char *p = strdup(str);
+  std::srand(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__srand__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::srand(x);
+}
+
+void test__ldiv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ldiv(arg1, arg2);
+  // 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__ldiv__leakignore() {
+  char *p = strdup(str);
+  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__std__ldiv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__ldiv__leakignore() {
+  char *p = strdup(str);
+  std::ldiv(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ldiv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ldiv(x, arg2);
+}
+
+void test__std__ldiv__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ldiv(arg1, x);
+}
+
+void test__lldiv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else lldiv(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__lldiv__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((lldiv(arg1, arg2) > 10) || (lldiv(arg1, arg2) < 100)) {}
+}
+
+void test__lldiv__leakignore() {
+  char *p = strdup(str);
+  lldiv(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__lldiv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  lldiv(x, arg2);
+}
+
+void test__lldiv__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  lldiv(arg1, x);
+}
+
+void test__std__lldiv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::lldiv(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__lldiv__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::lldiv(arg1, arg2) > 10) || (std::lldiv(arg1, arg2) < 100)) {}
+}
+
+void test__std__lldiv__leakignore() {
+  char *p = strdup(str);
+  std::lldiv(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__lldiv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::lldiv(x, arg2);
+}
+
+void test__std__lldiv__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::lldiv(arg1, x);
+}
+
+void test__localtime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else localtime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__localtime__leakignore() {
+  char *p = strdup(str);
+  localtime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__localtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  localtime(NULL);
+}
+
+void test__localtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  localtime(x);
+}
+
+void test__std__localtime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::localtime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__localtime__leakignore() {
+  char *p = strdup(str);
+  std::localtime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__localtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::localtime(NULL);
+}
+
+void test__std__localtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::localtime(x);
+}
+
+void test__localtime_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else localtime_s(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__localtime_s__leakignore() {
+  char *p = strdup(str);
+  localtime_s(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__localtime_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  localtime_s(NULL, arg2);
+}
+
+void test__localtime_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  localtime_s(arg1, NULL);
+}
+
+void test__std__localtime_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::localtime_s(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__localtime_s__leakignore() {
+  char *p = strdup(str);
+  std::localtime_s(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__localtime_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::localtime_s(NULL, arg2);
+}
+
+void test__std__localtime_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::localtime_s(arg1, NULL);
+}
+
+void test__log__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = log(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__log__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log(arg1);
+}
+
+void test__log__leakignore() {
+  char *p = strdup(str);
+  result = log(p);
+  // cppcheck-suppress memleak
+}
+
+void test__log__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log(x);
+}
+
+void test__std__log__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::log(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__log__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log(arg1);
+}
+
+void test__std__log__leakignore() {
+  char *p = strdup(str);
+  result = std::log(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__log__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log(x);
+}
+
+void test__logf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = logf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__logf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  logf(arg1);
+}
+
+void test__logf__leakignore() {
+  char *p = strdup(str);
+  result = logf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__logf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = logf(x);
+}
+
+void test__std__logf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::logf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__logf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::logf(arg1);
+}
+
+void test__std__logf__leakignore() {
+  char *p = strdup(str);
+  result = std::logf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__logf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::logf(x);
+}
+
+void test__logl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = logl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__logl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  logl(arg1);
+}
+
+void test__logl__leakignore() {
+  char *p = strdup(str);
+  result = logl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__logl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = logl(x);
+}
+
+void test__std__logl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::logl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__logl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::logl(arg1);
+}
+
+void test__std__logl__leakignore() {
+  char *p = strdup(str);
+  result = std::logl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__logl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::logl(x);
+}
+
+void test__clog__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = clog(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__clog__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  clog(arg1);
+}
+
+void test__clog__leakignore() {
+  char *p = strdup(str);
+  result = clog(p);
+  // cppcheck-suppress memleak
+}
+
+void test__clog__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = clog(x);
+}
+
+void test__clogf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = clogf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__clogf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  clogf(arg1);
+}
+
+void test__clogf__leakignore() {
+  char *p = strdup(str);
+  result = clogf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__clogf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = clogf(x);
+}
+
+void test__clogl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = clogl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__clogl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  clogl(arg1);
+}
+
+void test__clogl__leakignore() {
+  char *p = strdup(str);
+  result = clogl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__clogl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = clogl(x);
+}
+
+void test__conj__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = conj(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__conj__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  conj(arg1);
+}
+
+void test__conj__leakignore() {
+  char *p = strdup(str);
+  result = conj(p);
+  // cppcheck-suppress memleak
+}
+
+void test__conj__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = conj(x);
+}
+
+void test__conjf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = conjf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__conjf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  conjf(arg1);
+}
+
+void test__conjf__leakignore() {
+  char *p = strdup(str);
+  result = conjf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__conjf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = conjf(x);
+}
+
+void test__conjl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = conjl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__conjl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  conjl(arg1);
+}
+
+void test__conjl__leakignore() {
+  char *p = strdup(str);
+  result = conjl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__conjl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = conjl(x);
+}
+
+void test__fpclassify__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = fpclassify(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fpclassify__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  fpclassify(arg1);
+}
+
+void test__fpclassify__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((fpclassify(arg1) > 10) || (fpclassify(arg1) < 100)) {}
+}
+
+void test__fpclassify__leakignore() {
+  char *p = strdup(str);
+  result = fpclassify(p);
+  // cppcheck-suppress memleak
+}
+
+void test__fpclassify__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = fpclassify(x);
+}
+
+void test__std__fpclassify__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::fpclassify(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fpclassify__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::fpclassify(arg1);
+}
+
+void test__std__fpclassify__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::fpclassify(arg1) > 10) || (std::fpclassify(arg1) < 100)) {}
+}
+
+void test__std__fpclassify__leakignore() {
+  char *p = strdup(str);
+  result = std::fpclassify(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fpclassify__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::fpclassify(x);
+}
+
+void test__isfinite__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isfinite(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isfinite__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isfinite(arg1);
+}
+
+void test__isfinite__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isfinite(arg1) > 10) || (isfinite(arg1) < 100)) {}
+}
+
+void test__isfinite__leakignore() {
+  char *p = strdup(str);
+  result = isfinite(p);
+  // cppcheck-suppress memleak
+}
+
+void test__isfinite__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isfinite(x);
+}
+
+void test__std__isfinite__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isfinite(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isfinite__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isfinite(arg1);
+}
+
+void test__std__isfinite__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isfinite(arg1) > 10) || (std::isfinite(arg1) < 100)) {}
+}
+
+void test__std__isfinite__leakignore() {
+  char *p = strdup(str);
+  result = std::isfinite(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isfinite__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isfinite(x);
+}
+
+void test__isgreater__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isgreater(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isgreater__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isgreater(arg1, arg2);
+}
+
+void test__isgreater__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isgreater(arg1, arg2) > 10) || (isgreater(arg1, arg2) < 100)) {}
+}
+
+void test__isgreater__leakignore() {
+  char *p = strdup(str);
+  result = isgreater(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__isgreater__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isgreater(x, arg2);
+}
+
+void test__isgreater__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isgreater(arg1, x);
+}
+
+void test__std__isgreater__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isgreater(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isgreater__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isgreater(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__std__isgreater__leakignore() {
+  char *p = strdup(str);
+  result = std::isgreater(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isgreater__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isgreater(x, arg2);
+}
+
+void test__std__isgreater__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isgreater(arg1, x);
+}
+
+void test__isgreaterequal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isgreaterequal(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isgreaterequal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isgreaterequal(arg1, arg2);
+}
+
+void test__isgreaterequal__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isgreaterequal(arg1, arg2) > 10) || (isgreaterequal(arg1, arg2) < 100)) {}
+}
+
+void test__isgreaterequal__leakignore() {
+  char *p = strdup(str);
+  result = isgreaterequal(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__isgreaterequal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isgreaterequal(x, arg2);
+}
+
+void test__isgreaterequal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isgreaterequal(arg1, x);
+}
+
+void test__std__isgreaterequal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isgreaterequal(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isgreaterequal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isgreaterequal(arg1, arg2);
+}
+
+void test__std__isgreaterequal__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isgreaterequal(arg1, arg2) > 10) || (std::isgreaterequal(arg1, arg2) < 100)) {}
+}
+
+void test__std__isgreaterequal__leakignore() {
+  char *p = strdup(str);
+  result = std::isgreaterequal(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isgreaterequal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isgreaterequal(x, arg2);
+}
+
+void test__std__isgreaterequal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isgreaterequal(arg1, x);
+}
+
+void test__isinf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isinf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isinf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isinf(arg1);
+}
+
+void test__isinf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isinf(arg1) > 10) || (isinf(arg1) < 100)) {}
+}
+
+void test__isinf__leakignore() {
+  char *p = strdup(str);
+  result = isinf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__isinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isinf(x);
+}
+
+void test__std__isinf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isinf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isinf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isinf(arg1);
+}
+
+void test__std__isinf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isinf(arg1) > 10) || (std::isinf(arg1) < 100)) {}
+}
+
+void test__std__isinf__leakignore() {
+  char *p = strdup(str);
+  result = std::isinf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isinf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isinf(x);
+}
+
+void test__logb__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = logb(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__logb__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  logb(arg1);
+}
+
+void test__logb__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((logb(arg1) > 10) || (logb(arg1) < 100)) {}
+}
+
+void test__logb__leakignore() {
+  char *p = strdup(str);
+  result = logb(p);
+  // cppcheck-suppress memleak
+}
+
+void test__logb__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = logb(x);
+}
+
+void test__std__logb__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::logb(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__logb__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::logb(arg1);
+}
+
+void test__std__logb__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::logb(arg1) > 10) || (std::logb(arg1) < 100)) {}
+}
+
+void test__std__logb__leakignore() {
+  char *p = strdup(str);
+  result = std::logb(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__logb__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::logb(x);
+}
+
+void test__logbf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = logbf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__logbf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  logbf(arg1);
+}
+
+void test__logbf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((logbf(arg1) > 10) || (logbf(arg1) < 100)) {}
+}
+
+void test__logbf__leakignore() {
+  char *p = strdup(str);
+  result = logbf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__logbf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = logbf(x);
+}
+
+void test__std__logbf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::logbf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__logbf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::logbf(arg1);
+}
+
+void test__std__logbf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::logbf(arg1) > 10) || (std::logbf(arg1) < 100)) {}
+}
+
+void test__std__logbf__leakignore() {
+  char *p = strdup(str);
+  result = std::logbf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__logbf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::logbf(x);
+}
+
+void test__logbl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = logbl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__logbl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  logbl(arg1);
+}
+
+void test__logbl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((logbl(arg1) > 10) || (logbl(arg1) < 100)) {}
+}
+
+void test__logbl__leakignore() {
+  char *p = strdup(str);
+  result = logbl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__logbl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = logbl(x);
+}
+
+void test__std__logbl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::logbl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__logbl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::logbl(arg1);
+}
+
+void test__std__logbl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::logbl(arg1) > 10) || (std::logbl(arg1) < 100)) {}
+}
+
+void test__std__logbl__leakignore() {
+  char *p = strdup(str);
+  result = std::logbl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__logbl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::logbl(x);
+}
+
+void test__isless__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isless(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isless__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isless(arg1, arg2);
+}
+
+void test__isless__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isless(arg1, arg2) > 10) || (isless(arg1, arg2) < 100)) {}
+}
+
+void test__isless__leakignore() {
+  char *p = strdup(str);
+  result = isless(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__isless__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isless(x, arg2);
+}
+
+void test__isless__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isless(arg1, x);
+}
+
+void test__std__isless__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isless(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isless__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isless(arg1, arg2);
+}
+
+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__isless__leakignore() {
+  char *p = strdup(str);
+  result = std::isless(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isless__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isless(x, arg2);
+}
+
+void test__std__isless__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isless(arg1, x);
+}
+
+void test__islessequal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = islessequal(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__islessequal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  islessequal(arg1, arg2);
+}
+
+void test__islessequal__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((islessequal(arg1, arg2) > 10) || (islessequal(arg1, arg2) < 100)) {}
+}
+
+void test__islessequal__leakignore() {
+  char *p = strdup(str);
+  result = islessequal(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__islessequal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = islessequal(x, arg2);
+}
+
+void test__islessequal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = islessequal(arg1, x);
+}
+
+void test__std__islessequal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::islessequal(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__islessequal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::islessequal(arg1, arg2);
+}
+
+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__std__islessequal__leakignore() {
+  char *p = strdup(str);
+  result = std::islessequal(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__islessequal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::islessequal(x, arg2);
+}
+
+void test__std__islessequal__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::islessequal(arg1, x);
+}
+
+void test__islessgreater__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = islessgreater(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__islessgreater__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  islessgreater(arg1, arg2);
+}
+
+void test__islessgreater__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((islessgreater(arg1, arg2) > 10) || (islessgreater(arg1, arg2) < 100)) {}
+}
+
+void test__islessgreater__leakignore() {
+  char *p = strdup(str);
+  result = islessgreater(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__islessgreater__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = islessgreater(x, arg2);
+}
+
+void test__islessgreater__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = islessgreater(arg1, x);
+}
+
+void test__std__islessgreater__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::islessgreater(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__islessgreater__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::islessgreater(arg1, arg2);
+}
+
+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__islessgreater__leakignore() {
+  char *p = strdup(str);
+  result = std::islessgreater(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__islessgreater__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::islessgreater(x, arg2);
+}
+
+void test__std__islessgreater__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::islessgreater(arg1, x);
+}
+
+void test__nan__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = nan(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__nan__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nan(arg1);
+}
+
+void test__nan__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nan(arg1) > 10) || (nan(arg1) < 100)) {}
+}
+
+void test__nan__leakignore() {
+  char *p = strdup(str);
+  result = nan(p);
+  // cppcheck-suppress memleak
+}
+
+void test__nan__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = nan(NULL);
+}
+
+void test__nan__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = nan(x);
+}
+
+void test__std__nan__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::nan(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__nan__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nan(arg1);
+}
+
+void test__std__nan__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nan(arg1) > 10) || (std::nan(arg1) < 100)) {}
+}
+
+void test__std__nan__leakignore() {
+  char *p = strdup(str);
+  result = std::nan(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__nan__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::nan(NULL);
+}
+
+void test__std__nan__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::nan(x);
+}
+
+void test__nanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = nanf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__nanf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nanf(arg1);
+}
+
+void test__nanf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nanf(arg1) > 10) || (nanf(arg1) < 100)) {}
+}
+
+void test__nanf__leakignore() {
+  char *p = strdup(str);
+  result = nanf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__nanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = nanf(NULL);
+}
+
+void test__nanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = nanf(x);
+}
+
+void test__std__nanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::nanf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__nanf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nanf(arg1);
+}
+
+void test__std__nanf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nanf(arg1) > 10) || (std::nanf(arg1) < 100)) {}
+}
+
+void test__std__nanf__leakignore() {
+  char *p = strdup(str);
+  result = std::nanf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__nanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::nanf(NULL);
+}
+
+void test__std__nanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::nanf(x);
+}
+
+void test__nanl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = nanl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__nanl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nanl(arg1);
+}
+
+void test__nanl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nanl(arg1) > 10) || (nanl(arg1) < 100)) {}
+}
+
+void test__nanl__leakignore() {
+  char *p = strdup(str);
+  result = nanl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__nanl__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = nanl(NULL);
+}
+
+void test__nanl__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = nanl(x);
+}
+
+void test__std__nanl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::nanl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__nanl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nanl(arg1);
+}
+
+void test__std__nanl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nanl(arg1) > 10) || (std::nanl(arg1) < 100)) {}
+}
+
+void test__std__nanl__leakignore() {
+  char *p = strdup(str);
+  result = std::nanl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__nanl__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::nanl(NULL);
+}
+
+void test__std__nanl__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::nanl(x);
+}
+
+void test__isnan__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isnan(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isnan__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isnan(arg1);
+}
+
+void test__isnan__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isnan(arg1) > 10) || (isnan(arg1) < 100)) {}
+}
+
+void test__isnan__leakignore() {
+  char *p = strdup(str);
+  result = isnan(p);
+  // cppcheck-suppress memleak
+}
+
+void test__isnan__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isnan(x);
+}
+
+void test__std__isnan__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isnan(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isnan__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isnan(arg1);
+}
+
+void test__std__isnan__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isnan(arg1) > 10) || (std::isnan(arg1) < 100)) {}
+}
+
+void test__std__isnan__leakignore() {
+  char *p = strdup(str);
+  result = std::isnan(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isnan__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isnan(x);
+}
+
+void test__isnormal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isnormal(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isnormal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isnormal(arg1);
+}
+
+void test__isnormal__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isnormal(arg1) > 10) || (isnormal(arg1) < 100)) {}
+}
+
+void test__isnormal__leakignore() {
+  char *p = strdup(str);
+  result = isnormal(p);
+  // cppcheck-suppress memleak
+}
+
+void test__isnormal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isnormal(x);
+}
+
+void test__std__isnormal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isnormal(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isnormal__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isnormal(arg1);
+}
+
+void test__std__isnormal__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isnormal(arg1) > 10) || (std::isnormal(arg1) < 100)) {}
+}
+
+void test__std__isnormal__leakignore() {
+  char *p = strdup(str);
+  result = std::isnormal(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isnormal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isnormal(x);
+}
+
+void test__isunordered__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = isunordered(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__isunordered__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  isunordered(arg1, arg2);
+}
+
+void test__isunordered__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((isunordered(arg1, arg2) > 10) || (isunordered(arg1, arg2) < 100)) {}
+}
+
+void test__isunordered__leakignore() {
+  char *p = strdup(str);
+  result = isunordered(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__isunordered__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isunordered(x, arg2);
+}
+
+void test__isunordered__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = isunordered(arg1, x);
+}
+
+void test__std__isunordered__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::isunordered(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__isunordered__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::isunordered(arg1, arg2);
+}
+
+void test__std__isunordered__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::isunordered(arg1, arg2) > 10) || (std::isunordered(arg1, arg2) < 100)) {}
+}
+
+void test__std__isunordered__leakignore() {
+  char *p = strdup(str);
+  result = std::isunordered(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__isunordered__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isunordered(x, arg2);
+}
+
+void test__std__isunordered__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::isunordered(arg1, x);
+}
+
+void test__ilogb__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ilogb(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ilogb__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ilogb(arg1);
+}
+
+void test__ilogb__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ilogb(arg1) > 10) || (ilogb(arg1) < 100)) {}
+}
+
+void test__ilogb__leakignore() {
+  char *p = strdup(str);
+  result = ilogb(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ilogb__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ilogb(x);
+}
+
+void test__std__ilogb__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::ilogb(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ilogb__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ilogb(arg1);
+}
+
+void test__std__ilogb__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::ilogb(arg1) > 10) || (std::ilogb(arg1) < 100)) {}
+}
+
+void test__std__ilogb__leakignore() {
+  char *p = strdup(str);
+  result = std::ilogb(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ilogb__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ilogb(x);
+}
+
+void test__ilogbf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ilogbf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ilogbf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ilogbf(arg1);
+}
+
+void test__ilogbf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ilogbf(arg1) > 10) || (ilogbf(arg1) < 100)) {}
+}
+
+void test__ilogbf__leakignore() {
+  char *p = strdup(str);
+  result = ilogbf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ilogbf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ilogbf(x);
+}
+
+void test__std__ilogbf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::ilogbf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ilogbf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ilogbf(arg1);
+}
+
+void test__std__ilogbf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::ilogbf(arg1) > 10) || (std::ilogbf(arg1) < 100)) {}
+}
+
+void test__std__ilogbf__leakignore() {
+  char *p = strdup(str);
+  result = std::ilogbf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ilogbf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ilogbf(x);
+}
+
+void test__ilogbl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = ilogbl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ilogbl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ilogbl(arg1);
+}
+
+void test__ilogbl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((ilogbl(arg1) > 10) || (ilogbl(arg1) < 100)) {}
+}
+
+void test__ilogbl__leakignore() {
+  char *p = strdup(str);
+  result = ilogbl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ilogbl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = ilogbl(x);
+}
+
+void test__std__ilogbl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::ilogbl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ilogbl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::ilogbl(arg1);
+}
+
+void test__std__ilogbl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::ilogbl(arg1) > 10) || (std::ilogbl(arg1) < 100)) {}
+}
+
+void test__std__ilogbl__leakignore() {
+  char *p = strdup(str);
+  result = std::ilogbl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ilogbl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::ilogbl(x);
+}
+
+void test__log10__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = log10(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__log10__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log10(arg1);
+}
+
+void test__log10__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log10(arg1) > 10) || (log10(arg1) < 100)) {}
+}
+
+void test__log10__leakignore() {
+  char *p = strdup(str);
+  result = log10(p);
+  // cppcheck-suppress memleak
+}
+
+void test__log10__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log10(x);
+}
+
+void test__std__log10__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::log10(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__log10__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log10(arg1);
+}
+
+void test__std__log10__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log10(arg1) > 10) || (std::log10(arg1) < 100)) {}
+}
+
+void test__std__log10__leakignore() {
+  char *p = strdup(str);
+  result = std::log10(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__log10__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log10(x);
+}
+
+void test__log10f__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = log10f(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__log10f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log10f(arg1);
+}
+
+void test__log10f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log10f(arg1) > 10) || (log10f(arg1) < 100)) {}
+}
+
+void test__log10f__leakignore() {
+  char *p = strdup(str);
+  result = log10f(p);
+  // cppcheck-suppress memleak
+}
+
+void test__log10f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log10f(x);
+}
+
+void test__std__log10f__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::log10f(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__log10f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log10f(arg1);
+}
+
+void test__std__log10f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log10f(arg1) > 10) || (std::log10f(arg1) < 100)) {}
+}
+
+void test__std__log10f__leakignore() {
+  char *p = strdup(str);
+  result = std::log10f(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__log10f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log10f(x);
+}
+
+void test__log10l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = log10l(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__log10l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log10l(arg1);
+}
+
+void test__log10l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log10l(arg1) > 10) || (log10l(arg1) < 100)) {}
+}
+
+void test__log10l__leakignore() {
+  char *p = strdup(str);
+  result = log10l(p);
+  // cppcheck-suppress memleak
+}
+
+void test__log10l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log10l(x);
+}
+
+void test__std__log10l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::log10l(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__log10l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log10l(arg1);
+}
+
+void test__std__log10l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log10l(arg1) > 10) || (std::log10l(arg1) < 100)) {}
+}
+
+void test__std__log10l__leakignore() {
+  char *p = strdup(str);
+  result = std::log10l(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__log10l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log10l(x);
+}
+
+void test__log1p__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = log1p(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__log1p__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log1p(arg1);
+}
+
+void test__log1p__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log1p(arg1) > 10) || (log1p(arg1) < 100)) {}
+}
+
+void test__log1p__leakignore() {
+  char *p = strdup(str);
+  result = log1p(p);
+  // cppcheck-suppress memleak
+}
+
+void test__log1p__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log1p(x);
+}
+
+void test__std__log1p__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::log1p(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__log1p__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log1p(arg1);
+}
+
+void test__std__log1p__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log1p(arg1) > 10) || (std::log1p(arg1) < 100)) {}
+}
+
+void test__std__log1p__leakignore() {
+  char *p = strdup(str);
+  result = std::log1p(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__log1p__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log1p(x);
+}
+
+void test__log1pf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = log1pf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__log1pf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log1pf(arg1);
+}
+
+void test__log1pf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log1pf(arg1) > 10) || (log1pf(arg1) < 100)) {}
+}
+
+void test__log1pf__leakignore() {
+  char *p = strdup(str);
+  result = log1pf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__log1pf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log1pf(x);
+}
+
+void test__std__log1pf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::log1pf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__log1pf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log1pf(arg1);
+}
+
+void test__std__log1pf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log1pf(arg1) > 10) || (std::log1pf(arg1) < 100)) {}
+}
+
+void test__std__log1pf__leakignore() {
+  char *p = strdup(str);
+  result = std::log1pf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__log1pf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log1pf(x);
+}
+
+void test__log1pl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = log1pl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__log1pl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log1pl(arg1);
+}
+
+void test__log1pl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log1pl(arg1) > 10) || (log1pl(arg1) < 100)) {}
+}
+
+void test__log1pl__leakignore() {
+  char *p = strdup(str);
+  result = log1pl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__log1pl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log1pl(x);
+}
+
+void test__std__log1pl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::log1pl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__log1pl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log1pl(arg1);
+}
+
+void test__std__log1pl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log1pl(arg1) > 10) || (std::log1pl(arg1) < 100)) {}
+}
+
+void test__std__log1pl__leakignore() {
+  char *p = strdup(str);
+  result = std::log1pl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__log1pl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log1pl(x);
+}
+
+void test__log2__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = log2(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__log2__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log2(arg1);
+}
+
+void test__log2__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log2(arg1) > 10) || (log2(arg1) < 100)) {}
+}
+
+void test__log2__leakignore() {
+  char *p = strdup(str);
+  result = log2(p);
+  // cppcheck-suppress memleak
+}
+
+void test__log2__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log2(x);
+}
+
+void test__std__log2__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::log2(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__log2__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log2(arg1);
+}
+
+void test__std__log2__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log2(arg1) > 10) || (std::log2(arg1) < 100)) {}
+}
+
+void test__std__log2__leakignore() {
+  char *p = strdup(str);
+  result = std::log2(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__log2__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log2(x);
+}
+
+void test__log2f__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = log2f(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__log2f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log2f(arg1);
+}
+
+void test__log2f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log2f(arg1) > 10) || (log2f(arg1) < 100)) {}
+}
+
+void test__log2f__leakignore() {
+  char *p = strdup(str);
+  result = log2f(p);
+  // cppcheck-suppress memleak
+}
+
+void test__log2f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log2f(x);
+}
+
+void test__std__log2f__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::log2f(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__log2f__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log2f(arg1);
+}
+
+void test__std__log2f__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log2f(arg1) > 10) || (std::log2f(arg1) < 100)) {}
+}
+
+void test__std__log2f__leakignore() {
+  char *p = strdup(str);
+  result = std::log2f(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__log2f__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log2f(x);
+}
+
+void test__log2l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = log2l(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__log2l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  log2l(arg1);
+}
+
+void test__log2l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((log2l(arg1) > 10) || (log2l(arg1) < 100)) {}
+}
+
+void test__log2l__leakignore() {
+  char *p = strdup(str);
+  result = log2l(p);
+  // cppcheck-suppress memleak
+}
+
+void test__log2l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = log2l(x);
+}
+
+void test__std__log2l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::log2l(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__log2l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::log2l(arg1);
+}
+
+void test__std__log2l__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::log2l(arg1) > 10) || (std::log2l(arg1) < 100)) {}
+}
+
+void test__std__log2l__leakignore() {
+  char *p = strdup(str);
+  result = std::log2l(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__log2l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::log2l(x);
+}
+
+void test__nearbyint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = nearbyint(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__nearbyint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nearbyint(arg1);
+}
+
+void test__nearbyint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nearbyint(arg1) > 10) || (nearbyint(arg1) < 100)) {}
+}
+
+void test__nearbyint__leakignore() {
+  char *p = strdup(str);
+  result = nearbyint(p);
+  // cppcheck-suppress memleak
+}
+
+void test__nearbyint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nearbyint(x);
+}
+
+void test__std__nearbyint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::nearbyint(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__nearbyint__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nearbyint(arg1);
+}
+
+void test__std__nearbyint__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nearbyint(arg1) > 10) || (std::nearbyint(arg1) < 100)) {}
+}
+
+void test__std__nearbyint__leakignore() {
+  char *p = strdup(str);
+  result = std::nearbyint(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__nearbyint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nearbyint(x);
+}
+
+void test__nearbyintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = nearbyintf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__nearbyintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nearbyintf(arg1);
+}
+
+void test__nearbyintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nearbyintf(arg1) > 10) || (nearbyintf(arg1) < 100)) {}
+}
+
+void test__nearbyintf__leakignore() {
+  char *p = strdup(str);
+  result = nearbyintf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__nearbyintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nearbyintf(x);
+}
+
+void test__std__nearbyintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::nearbyintf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__nearbyintf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nearbyintf(arg1);
+}
+
+void test__std__nearbyintf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nearbyintf(arg1) > 10) || (std::nearbyintf(arg1) < 100)) {}
+}
+
+void test__std__nearbyintf__leakignore() {
+  char *p = strdup(str);
+  result = std::nearbyintf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__nearbyintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nearbyintf(x);
+}
+
+void test__nearbyintl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = nearbyintl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__nearbyintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nearbyintl(arg1);
+}
+
+void test__nearbyintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nearbyintl(arg1) > 10) || (nearbyintl(arg1) < 100)) {}
+}
+
+void test__nearbyintl__leakignore() {
+  char *p = strdup(str);
+  result = nearbyintl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__nearbyintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nearbyintl(x);
+}
+
+void test__std__nearbyintl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::nearbyintl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__nearbyintl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nearbyintl(arg1);
+}
+
+void test__std__nearbyintl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nearbyintl(arg1) > 10) || (std::nearbyintl(arg1) < 100)) {}
+}
+
+void test__std__nearbyintl__leakignore() {
+  char *p = strdup(str);
+  result = std::nearbyintl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__nearbyintl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nearbyintl(x);
+}
+
+void test__nextafter__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = nextafter(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__nextafter__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nextafter(arg1, arg2);
+}
+
+void test__nextafter__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nextafter(arg1, arg2) > 10) || (nextafter(arg1, arg2) < 100)) {}
+}
+
+void test__nextafter__leakignore() {
+  char *p = strdup(str);
+  result = nextafter(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__nextafter__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nextafter(x, arg2);
+}
+
+void test__nextafter__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nextafter(arg1, x);
+}
+
+void test__std__nextafter__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::nextafter(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__nextafter__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nextafter(arg1, arg2);
+}
+
+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__std__nextafter__leakignore() {
+  char *p = strdup(str);
+  result = std::nextafter(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__nextafter__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nextafter(x, arg2);
+}
+
+void test__std__nextafter__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nextafter(arg1, x);
+}
+
+void test__nextafterf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = nextafterf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__nextafterf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nextafterf(arg1, arg2);
+}
+
+void test__nextafterf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nextafterf(arg1, arg2) > 10) || (nextafterf(arg1, arg2) < 100)) {}
+}
+
+void test__nextafterf__leakignore() {
+  char *p = strdup(str);
+  result = nextafterf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__nextafterf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nextafterf(x, arg2);
+}
+
+void test__nextafterf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nextafterf(arg1, x);
+}
+
+void test__std__nextafterf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::nextafterf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__nextafterf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nextafterf(arg1, arg2);
+}
+
+void test__std__nextafterf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::nextafterf(arg1, arg2) > 10) || (std::nextafterf(arg1, arg2) < 100)) {}
+}
+
+void test__std__nextafterf__leakignore() {
+  char *p = strdup(str);
+  result = std::nextafterf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__nextafterf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nextafterf(x, arg2);
+}
+
+void test__std__nextafterf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nextafterf(arg1, x);
+}
+
+void test__nextafterl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = nextafterl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__nextafterl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nextafterl(arg1, arg2);
+}
+
+void test__nextafterl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nextafterl(arg1, arg2) > 10) || (nextafterl(arg1, arg2) < 100)) {}
+}
+
+void test__nextafterl__leakignore() {
+  char *p = strdup(str);
+  result = nextafterl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__nextafterl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nextafterl(x, arg2);
+}
+
+void test__nextafterl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nextafterl(arg1, x);
+}
+
+void test__std__nextafterl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::nextafterl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__nextafterl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nextafterl(arg1, arg2);
+}
+
+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__std__nextafterl__leakignore() {
+  char *p = strdup(str);
+  result = std::nextafterl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__nextafterl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nextafterl(x, arg2);
+}
+
+void test__std__nextafterl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nextafterl(arg1, x);
+}
+
+void test__nexttoward__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = nexttoward(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__nexttoward__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nexttoward(arg1, arg2);
+}
+
+void test__nexttoward__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nexttoward(arg1, arg2) > 10) || (nexttoward(arg1, arg2) < 100)) {}
+}
+
+void test__nexttoward__leakignore() {
+  char *p = strdup(str);
+  result = nexttoward(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__nexttoward__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nexttoward(x, arg2);
+}
+
+void test__nexttoward__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nexttoward(arg1, x);
+}
+
+void test__std__nexttoward__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::nexttoward(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__nexttoward__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nexttoward(arg1, arg2);
+}
+
+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__std__nexttoward__leakignore() {
+  char *p = strdup(str);
+  result = std::nexttoward(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__nexttoward__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nexttoward(x, arg2);
+}
+
+void test__std__nexttoward__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nexttoward(arg1, x);
+}
+
+void test__nexttowardf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = nexttowardf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__nexttowardf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nexttowardf(arg1, arg2);
+}
+
+void test__nexttowardf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nexttowardf(arg1, arg2) > 10) || (nexttowardf(arg1, arg2) < 100)) {}
+}
+
+void test__nexttowardf__leakignore() {
+  char *p = strdup(str);
+  result = nexttowardf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__nexttowardf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nexttowardf(x, arg2);
+}
+
+void test__nexttowardf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nexttowardf(arg1, x);
+}
+
+void test__std__nexttowardf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::nexttowardf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__nexttowardf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nexttowardf(arg1, arg2);
+}
+
+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__nexttowardf__leakignore() {
+  char *p = strdup(str);
+  result = std::nexttowardf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__nexttowardf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nexttowardf(x, arg2);
+}
+
+void test__std__nexttowardf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nexttowardf(arg1, x);
+}
+
+void test__nexttowardl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = nexttowardl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__nexttowardl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  nexttowardl(arg1, arg2);
+}
+
+void test__nexttowardl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((nexttowardl(arg1, arg2) > 10) || (nexttowardl(arg1, arg2) < 100)) {}
+}
+
+void test__nexttowardl__leakignore() {
+  char *p = strdup(str);
+  result = nexttowardl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__nexttowardl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nexttowardl(x, arg2);
+}
+
+void test__nexttowardl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = nexttowardl(arg1, x);
+}
+
+void test__std__nexttowardl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::nexttowardl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__nexttowardl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::nexttowardl(arg1, arg2);
+}
+
+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__nexttowardl__leakignore() {
+  char *p = strdup(str);
+  result = std::nexttowardl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__nexttowardl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nexttowardl(x, arg2);
+}
+
+void test__std__nexttowardl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::nexttowardl(arg1, x);
+}
+
+void test__longjmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else longjmp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__longjmp__leakignore() {
+  char *p = strdup(str);
+  longjmp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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__std__longjmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::longjmp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__longjmp__leakignore() {
+  char *p = strdup(str);
+  std::longjmp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__longjmp__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::longjmp(x, arg2);
+}
+
+void test__std__longjmp__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::longjmp(arg1, x);
+}
+
+void test__malloc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = malloc(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__malloc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  malloc(arg1);
+}
+
+void test__malloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = malloc(x);
+}
+
+void test__std__malloc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::malloc(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__malloc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::malloc(arg1);
+}
+
+void test__std__malloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::malloc(x);
+}
+
+void test__alloca__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = alloca(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__alloca__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  alloca(arg1);
+}
+
+void test__alloca__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = alloca(x);
+}
+
+void test__memchr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = memchr(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__memchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  memchr(arg1, arg2, arg3);
+}
+
+void test__memchr__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((memchr(arg1, arg2, arg3) > 10) || (memchr(arg1, arg2, arg3) < 100)) {}
+}
+
+void test__memchr__leakignore() {
+  char *p = strdup(str);
+  result = memchr(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__memchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = memchr(NULL, arg2, arg3);
+}
+
+void test__memchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = memchr(x, arg2, arg3);
+}
+
+void test__memchr__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = memchr(arg1, !x, arg3);
+}
+
+void test__memchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = memchr(arg1, x, arg3);
+}
+
+void test__memchr__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = memchr(arg1, arg2, !x);
+}
+
+void test__memchr__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = memchr(arg1, arg2, x);
+}
+
+void test__std__memchr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::memchr(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__memchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::memchr(arg1, arg2, arg3);
+}
+
+void test__std__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__memchr__leakignore() {
+  char *p = strdup(str);
+  result = std::memchr(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__memchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::memchr(NULL, arg2, arg3);
+}
+
+void test__std__memchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::memchr(x, arg2, arg3);
+}
+
+void test__std__memchr__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::memchr(arg1, !x, arg3);
+}
+
+void test__std__memchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::memchr(arg1, x, arg3);
+}
+
+void test__std__memchr__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::memchr(arg1, arg2, !x);
+}
+
+void test__std__memchr__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::memchr(arg1, arg2, x);
+}
+
+void test__wmemchr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wmemchr(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wmemchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wmemchr(arg1, arg2, arg3);
+}
+
+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__wmemchr__leakignore() {
+  char *p = strdup(str);
+  result = wmemchr(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wmemchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wmemchr(NULL, arg2, arg3);
+}
+
+void test__wmemchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wmemchr(x, arg2, arg3);
+}
+
+void test__wmemchr__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = wmemchr(arg1, !x, arg3);
+}
+
+void test__wmemchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wmemchr(arg1, x, arg3);
+}
+
+void test__wmemchr__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = wmemchr(arg1, arg2, !x);
+}
+
+void test__wmemchr__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wmemchr(arg1, arg2, x);
+}
+
+void test__std__wmemchr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wmemchr(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wmemchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wmemchr(arg1, arg2, arg3);
+}
+
+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__wmemchr__leakignore() {
+  char *p = strdup(str);
+  result = std::wmemchr(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wmemchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wmemchr(NULL, arg2, arg3);
+}
+
+void test__std__wmemchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wmemchr(x, arg2, arg3);
+}
+
+void test__std__wmemchr__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::wmemchr(arg1, !x, arg3);
+}
+
+void test__std__wmemchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wmemchr(arg1, x, arg3);
+}
+
+void test__std__wmemchr__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::wmemchr(arg1, arg2, !x);
+}
+
+void test__std__wmemchr__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wmemchr(arg1, arg2, x);
+}
+
+void test__memcmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = memcmp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__memcmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  memcmp(arg1, arg2, arg3);
+}
+
+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__memcmp__leakignore() {
+  char *p = strdup(str);
+  result = memcmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__memcmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = memcmp(NULL, arg2, arg3);
+}
+
+void test__memcmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = memcmp(x, arg2, arg3);
+}
+
+void test__memcmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = memcmp(arg1, NULL, arg3);
+}
+
+void test__memcmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = memcmp(arg1, x, arg3);
+}
+
+void test__memcmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = memcmp(arg1, arg2, !x);
+}
+
+void test__memcmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = memcmp(arg1, arg2, x);
+}
+
+void test__std__memcmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::memcmp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__memcmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::memcmp(arg1, arg2, arg3);
+}
+
+void test__std__memcmp__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::memcmp(arg1, arg2, arg3) > 10) || (std::memcmp(arg1, arg2, arg3) < 100)) {}
+}
+
+void test__std__memcmp__leakignore() {
+  char *p = strdup(str);
+  result = std::memcmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__memcmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::memcmp(NULL, arg2, arg3);
+}
+
+void test__std__memcmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::memcmp(x, arg2, arg3);
+}
+
+void test__std__memcmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::memcmp(arg1, NULL, arg3);
+}
+
+void test__std__memcmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::memcmp(arg1, x, arg3);
+}
+
+void test__std__memcmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::memcmp(arg1, arg2, !x);
+}
+
+void test__std__memcmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::memcmp(arg1, arg2, x);
+}
+
+void test__wmemcmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wmemcmp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wmemcmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wmemcmp(arg1, arg2, arg3);
+}
+
+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__wmemcmp__leakignore() {
+  char *p = strdup(str);
+  result = wmemcmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wmemcmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wmemcmp(NULL, arg2, arg3);
+}
+
+void test__wmemcmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wmemcmp(x, arg2, arg3);
+}
+
+void test__wmemcmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wmemcmp(arg1, NULL, arg3);
+}
+
+void test__wmemcmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wmemcmp(arg1, x, arg3);
+}
+
+void test__wmemcmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = wmemcmp(arg1, arg2, !x);
+}
+
+void test__wmemcmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wmemcmp(arg1, arg2, x);
+}
+
+void test__std__wmemcmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wmemcmp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wmemcmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wmemcmp(arg1, arg2, arg3);
+}
+
+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__wmemcmp__leakignore() {
+  char *p = strdup(str);
+  result = std::wmemcmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wmemcmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wmemcmp(NULL, arg2, arg3);
+}
+
+void test__std__wmemcmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wmemcmp(x, arg2, arg3);
+}
+
+void test__std__wmemcmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wmemcmp(arg1, NULL, arg3);
+}
+
+void test__std__wmemcmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wmemcmp(arg1, x, arg3);
+}
+
+void test__std__wmemcmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::wmemcmp(arg1, arg2, !x);
+}
+
+void test__std__wmemcmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wmemcmp(arg1, arg2, x);
+}
+
+void test__memcpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else memcpy(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__memcpy__leakignore() {
+  char *p = strdup(str);
+  memcpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__memcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  memcpy(NULL, arg2, arg3);
+}
+
+void test__memcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  memcpy(arg1, NULL, arg3);
+}
+
+void test__memcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  memcpy(arg1, x, arg3);
+}
+
+void test__memcpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  memcpy(arg1, arg2, !x);
+}
+
+void test__memcpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memcpy(arg1, arg2, x);
+}
+
+void test__std__memcpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::memcpy(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__memcpy__leakignore() {
+  char *p = strdup(str);
+  std::memcpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__memcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::memcpy(NULL, arg2, arg3);
+}
+
+void test__std__memcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::memcpy(arg1, NULL, arg3);
+}
+
+void test__std__memcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::memcpy(arg1, x, arg3);
+}
+
+void test__std__memcpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::memcpy(arg1, arg2, !x);
+}
+
+void test__std__memcpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::memcpy(arg1, arg2, x);
+}
+
+void test__wmemcpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wmemcpy(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wmemcpy__leakignore() {
+  char *p = strdup(str);
+  wmemcpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wmemcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wmemcpy(NULL, arg2, arg3);
+}
+
+void test__wmemcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wmemcpy(arg1, NULL, arg3);
+}
+
+void test__wmemcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wmemcpy(arg1, x, arg3);
+}
+
+void test__wmemcpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wmemcpy(arg1, arg2, !x);
+}
+
+void test__wmemcpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wmemcpy(arg1, arg2, x);
+}
+
+void test__std__wmemcpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wmemcpy(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wmemcpy__leakignore() {
+  char *p = strdup(str);
+  std::wmemcpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wmemcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wmemcpy(NULL, arg2, arg3);
+}
+
+void test__std__wmemcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wmemcpy(arg1, NULL, arg3);
+}
+
+void test__std__wmemcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wmemcpy(arg1, x, arg3);
+}
+
+void test__std__wmemcpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::wmemcpy(arg1, arg2, !x);
+}
+
+void test__std__wmemcpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wmemcpy(arg1, arg2, x);
+}
+
+void test__memcpy_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else memcpy_s(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__memcpy_s__leakignore() {
+  char *p = strdup(str);
+  memcpy_s(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__memcpy_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  memcpy_s(NULL, arg2, arg3, arg4);
+}
+
+void test__memcpy_s__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  memcpy_s(arg1, !x, arg3, arg4);
+}
+
+void test__memcpy_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memcpy_s(arg1, x, arg3, arg4);
+}
+
+void test__memcpy_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  memcpy_s(arg1, arg2, NULL, arg4);
+}
+
+void test__memcpy_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  memcpy_s(arg1, arg2, x, arg4);
+}
+
+void test__memcpy_s__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  memcpy_s(arg1, arg2, arg3, !x);
+}
+
+void test__memcpy_s__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memcpy_s(arg1, arg2, arg3, x);
+}
+
+void test__wmemcpy_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wmemcpy_s(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wmemcpy_s__leakignore() {
+  char *p = strdup(str);
+  wmemcpy_s(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__wmemcpy_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wmemcpy_s(NULL, arg2, arg3, arg4);
+}
+
+void test__wmemcpy_s__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wmemcpy_s(arg1, !x, arg3, arg4);
+}
+
+void test__wmemcpy_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wmemcpy_s(arg1, x, arg3, arg4);
+}
+
+void test__wmemcpy_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  wmemcpy_s(arg1, arg2, NULL, arg4);
+}
+
+void test__wmemcpy_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wmemcpy_s(arg1, arg2, x, arg4);
+}
+
+void test__wmemcpy_s__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wmemcpy_s(arg1, arg2, arg3, !x);
+}
+
+void test__wmemcpy_s__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wmemcpy_s(arg1, arg2, arg3, x);
+}
+
+void test__memmove__noreturn() {
+  int x = 100;
+  if (cond) x=1; else memmove(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__memmove__leakignore() {
+  char *p = strdup(str);
+  memmove(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__memmove__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  memmove(NULL, arg2, arg3);
+}
+
+void test__memmove__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  memmove(arg1, NULL, arg3);
+}
+
+void test__memmove__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  memmove(arg1, x, arg3);
+}
+
+void test__memmove__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  memmove(arg1, arg2, !x);
+}
+
+void test__memmove__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memmove(arg1, arg2, x);
+}
+
+void test__std__memmove__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::memmove(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__memmove__leakignore() {
+  char *p = strdup(str);
+  std::memmove(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__memmove__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::memmove(NULL, arg2, arg3);
+}
+
+void test__std__memmove__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::memmove(arg1, NULL, arg3);
+}
+
+void test__std__memmove__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::memmove(arg1, x, arg3);
+}
+
+void test__std__memmove__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::memmove(arg1, arg2, !x);
+}
+
+void test__std__memmove__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::memmove(arg1, arg2, x);
+}
+
+void test__wmemmove__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wmemmove(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wmemmove__leakignore() {
+  char *p = strdup(str);
+  wmemmove(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wmemmove__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wmemmove(NULL, arg2, arg3);
+}
+
+void test__wmemmove__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wmemmove(arg1, NULL, arg3);
+}
+
+void test__wmemmove__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wmemmove(arg1, x, arg3);
+}
+
+void test__wmemmove__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wmemmove(arg1, arg2, !x);
+}
+
+void test__wmemmove__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wmemmove(arg1, arg2, x);
+}
+
+void test__std__wmemmove__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wmemmove(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wmemmove__leakignore() {
+  char *p = strdup(str);
+  std::wmemmove(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wmemmove__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wmemmove(NULL, arg2, arg3);
+}
+
+void test__std__wmemmove__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wmemmove(arg1, NULL, arg3);
+}
+
+void test__std__wmemmove__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wmemmove(arg1, x, arg3);
+}
+
+void test__std__wmemmove__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::wmemmove(arg1, arg2, !x);
+}
+
+void test__std__wmemmove__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wmemmove(arg1, arg2, x);
+}
+
+void test__memset_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else memset_s(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__memset_s__leakignore() {
+  char *p = strdup(str);
+  memset_s(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__memset_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  memset_s(NULL, arg2, arg3, arg4);
+}
+
+void test__memset_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memset_s(arg1, x, arg3, arg4);
+}
+
+void test__memset_s__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memset_s(arg1, arg2, x, arg4);
+}
+
+void test__memset_s__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memset_s(arg1, arg2, arg3, x);
+}
+
+void test__memset__noreturn() {
+  int x = 100;
+  if (cond) x=1; else memset(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__memset__leakignore() {
+  char *p = strdup(str);
+  memset(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__memset__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  memset(NULL, arg2, arg3);
+}
+
+void test__memset__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memset(arg1, x, arg3);
+}
+
+void test__memset__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  memset(arg1, arg2, !x);
+}
+
+void test__memset__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  memset(arg1, arg2, x);
+}
+
+void test__std__memset__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::memset(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__memset__leakignore() {
+  char *p = strdup(str);
+  std::memset(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__memset__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::memset(NULL, arg2, arg3);
+}
+
+void test__std__memset__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::memset(arg1, x, arg3);
+}
+
+void test__std__memset__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::memset(arg1, arg2, !x);
+}
+
+void test__std__memset__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::memset(arg1, arg2, x);
+}
+
+void test__wmemset__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wmemset(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wmemset__leakignore() {
+  char *p = strdup(str);
+  wmemset(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wmemset__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wmemset(NULL, arg2, arg3);
+}
+
+void test__wmemset__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wmemset(arg1, x, arg3);
+}
+
+void test__wmemset__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wmemset(arg1, arg2, !x);
+}
+
+void test__wmemset__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wmemset(arg1, arg2, x);
+}
+
+void test__std__wmemset__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wmemset(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wmemset__leakignore() {
+  char *p = strdup(str);
+  std::wmemset(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wmemset__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wmemset(NULL, arg2, arg3);
+}
+
+void test__std__wmemset__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wmemset(arg1, x, arg3);
+}
+
+void test__std__wmemset__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::wmemset(arg1, arg2, !x);
+}
+
+void test__std__wmemset__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wmemset(arg1, arg2, x);
+}
+
+void test__mktime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mktime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mktime__leakignore() {
+  char *p = strdup(str);
+  mktime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__mktime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mktime(NULL);
+}
+
+void test__mktime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mktime(x);
+}
+
+void test__std__mktime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::mktime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__mktime__leakignore() {
+  char *p = strdup(str);
+  std::mktime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__mktime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::mktime(NULL);
+}
+
+void test__std__mktime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::mktime(x);
+}
+
+void test__mkxtime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mkxtime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mkxtime__leakignore() {
+  char *p = strdup(str);
+  mkxtime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__mkxtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  mkxtime(NULL);
+}
+
+void test__mkxtime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mkxtime(x);
+}
+
+void test__modf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else modf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__modf__leakignore() {
+  char *p = strdup(str);
+  modf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__modf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  modf(x, arg2);
+}
+
+void test__modf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  modf(arg1, NULL);
+}
+
+void test__std__modf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::modf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__modf__leakignore() {
+  char *p = strdup(str);
+  std::modf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__modf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::modf(x, arg2);
+}
+
+void test__std__modf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::modf(arg1, NULL);
+}
+
+void test__modff__noreturn() {
+  int x = 100;
+  if (cond) x=1; else modff(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__modff__leakignore() {
+  char *p = strdup(str);
+  modff(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__modff__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  modff(x, arg2);
+}
+
+void test__modff__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  modff(arg1, NULL);
+}
+
+void test__std__modff__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::modff(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__modff__leakignore() {
+  char *p = strdup(str);
+  std::modff(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__modff__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::modff(x, arg2);
+}
+
+void test__std__modff__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::modff(arg1, NULL);
+}
+
+void test__modfl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else modfl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__modfl__leakignore() {
+  char *p = strdup(str);
+  modfl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__modfl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  modfl(x, arg2);
+}
+
+void test__modfl__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  modfl(arg1, NULL);
+}
+
+void test__std__modfl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::modfl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__modfl__leakignore() {
+  char *p = strdup(str);
+  std::modfl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__modfl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::modfl(x, arg2);
+}
+
+void test__std__modfl__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::modfl(arg1, NULL);
+}
+
+void test__perror__noreturn() {
+  int x = 100;
+  if (cond) x=1; else perror(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__perror__leakignore() {
+  char *p = strdup(str);
+  perror(p);
+  // cppcheck-suppress memleak
+}
+
+void test__perror__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  perror(x);
+}
+
+void test__std__perror__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::perror(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__perror__leakignore() {
+  char *p = strdup(str);
+  std::perror(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__perror__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::perror(x);
+}
+
+void test__pow__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = pow(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__pow__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  pow(arg1, arg2);
+}
+
+void test__pow__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((pow(arg1, arg2) > 10) || (pow(arg1, arg2) < 100)) {}
+}
+
+void test__pow__leakignore() {
+  char *p = strdup(str);
+  result = pow(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__pow__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = pow(x, arg2);
+}
+
+void test__pow__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = pow(arg1, x);
+}
+
+void test__std__pow__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::pow(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__pow__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::pow(arg1, arg2);
+}
+
+void test__std__pow__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::pow(arg1, arg2) > 10) || (std::pow(arg1, arg2) < 100)) {}
+}
+
+void test__std__pow__leakignore() {
+  char *p = strdup(str);
+  result = std::pow(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__pow__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::pow(x, arg2);
+}
+
+void test__std__pow__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::pow(arg1, x);
+}
+
+void test__powf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = powf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__powf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  powf(arg1, arg2);
+}
+
+void test__powf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((powf(arg1, arg2) > 10) || (powf(arg1, arg2) < 100)) {}
+}
+
+void test__powf__leakignore() {
+  char *p = strdup(str);
+  result = powf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__powf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = powf(x, arg2);
+}
+
+void test__powf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = powf(arg1, x);
+}
+
+void test__std__powf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::powf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__powf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::powf(arg1, arg2);
+}
+
+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__powf__leakignore() {
+  char *p = strdup(str);
+  result = std::powf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__powf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::powf(x, arg2);
+}
+
+void test__std__powf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::powf(arg1, x);
+}
+
+void test__powl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = powl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__powl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  powl(arg1, arg2);
+}
+
+void test__powl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((powl(arg1, arg2) > 10) || (powl(arg1, arg2) < 100)) {}
+}
+
+void test__powl__leakignore() {
+  char *p = strdup(str);
+  result = powl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__powl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = powl(x, arg2);
+}
+
+void test__powl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = powl(arg1, x);
+}
+
+void test__std__powl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::powl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__powl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::powl(arg1, arg2);
+}
+
+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__powl__leakignore() {
+  char *p = strdup(str);
+  result = std::powl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__powl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::powl(x, arg2);
+}
+
+void test__std__powl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::powl(arg1, x);
+}
+
+void test__cpow__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cpow(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cpow__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cpow(arg1, arg2);
+}
+
+void test__cpow__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cpow(arg1, arg2) > 10) || (cpow(arg1, arg2) < 100)) {}
+}
+
+void test__cpow__leakignore() {
+  char *p = strdup(str);
+  result = cpow(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__cpow__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cpow(x, arg2);
+}
+
+void test__cpow__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cpow(arg1, x);
+}
+
+void test__cpowf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cpowf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cpowf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cpowf(arg1, arg2);
+}
+
+void test__cpowf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cpowf(arg1, arg2) > 10) || (cpowf(arg1, arg2) < 100)) {}
+}
+
+void test__cpowf__leakignore() {
+  char *p = strdup(str);
+  result = cpowf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__cpowf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cpowf(x, arg2);
+}
+
+void test__cpowf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cpowf(arg1, x);
+}
+
+void test__cpowl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = cpowl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__cpowl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  cpowl(arg1, arg2);
+}
+
+void test__cpowl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((cpowl(arg1, arg2) > 10) || (cpowl(arg1, arg2) < 100)) {}
+}
+
+void test__cpowl__leakignore() {
+  char *p = strdup(str);
+  result = cpowl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__cpowl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cpowl(x, arg2);
+}
+
+void test__cpowl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = cpowl(arg1, x);
+}
+
+void test__remainder__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = remainder(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__remainder__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  remainder(arg1, arg2);
+}
+
+void test__remainder__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((remainder(arg1, arg2) > 10) || (remainder(arg1, arg2) < 100)) {}
+}
+
+void test__remainder__leakignore() {
+  char *p = strdup(str);
+  result = remainder(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__remainder__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remainder(x, arg2);
+}
+
+void test__remainder__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remainder(arg1, x);
+}
+
+void test__std__remainder__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::remainder(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__remainder__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::remainder(arg1, arg2);
+}
+
+void test__std__remainder__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::remainder(arg1, arg2) > 10) || (std::remainder(arg1, arg2) < 100)) {}
+}
+
+void test__std__remainder__leakignore() {
+  char *p = strdup(str);
+  result = std::remainder(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__remainder__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remainder(x, arg2);
+}
+
+void test__std__remainder__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remainder(arg1, x);
+}
+
+void test__remainderf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = remainderf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__remainderf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  remainderf(arg1, arg2);
+}
+
+void test__remainderf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((remainderf(arg1, arg2) > 10) || (remainderf(arg1, arg2) < 100)) {}
+}
+
+void test__remainderf__leakignore() {
+  char *p = strdup(str);
+  result = remainderf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__remainderf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remainderf(x, arg2);
+}
+
+void test__remainderf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remainderf(arg1, x);
+}
+
+void test__std__remainderf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::remainderf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__remainderf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::remainderf(arg1, arg2);
+}
+
+void test__std__remainderf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::remainderf(arg1, arg2) > 10) || (std::remainderf(arg1, arg2) < 100)) {}
+}
+
+void test__std__remainderf__leakignore() {
+  char *p = strdup(str);
+  result = std::remainderf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__remainderf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remainderf(x, arg2);
+}
+
+void test__std__remainderf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remainderf(arg1, x);
+}
+
+void test__remainderl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = remainderl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__remainderl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  remainderl(arg1, arg2);
+}
+
+void test__remainderl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((remainderl(arg1, arg2) > 10) || (remainderl(arg1, arg2) < 100)) {}
+}
+
+void test__remainderl__leakignore() {
+  char *p = strdup(str);
+  result = remainderl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__remainderl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remainderl(x, arg2);
+}
+
+void test__remainderl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remainderl(arg1, x);
+}
+
+void test__std__remainderl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::remainderl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__remainderl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::remainderl(arg1, arg2);
+}
+
+void test__std__remainderl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::remainderl(arg1, arg2) > 10) || (std::remainderl(arg1, arg2) < 100)) {}
+}
+
+void test__std__remainderl__leakignore() {
+  char *p = strdup(str);
+  result = std::remainderl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__remainderl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remainderl(x, arg2);
+}
+
+void test__std__remainderl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remainderl(arg1, x);
+}
+
+void test__remquo__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = remquo(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__remquo__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  remquo(arg1, arg2, arg3);
+}
+
+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__remquo__leakignore() {
+  char *p = strdup(str);
+  result = remquo(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__remquo__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remquo(x, arg2, arg3);
+}
+
+void test__remquo__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remquo(arg1, x, arg3);
+}
+
+void test__remquo__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = remquo(arg1, arg2, NULL);
+}
+
+void test__std__remquo__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::remquo(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__remquo__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::remquo(arg1, arg2, arg3);
+}
+
+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__remquo__leakignore() {
+  char *p = strdup(str);
+  result = std::remquo(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__remquo__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remquo(x, arg2, arg3);
+}
+
+void test__std__remquo__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remquo(arg1, x, arg3);
+}
+
+void test__std__remquo__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::remquo(arg1, arg2, NULL);
+}
+
+void test__remquof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = remquof(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__remquof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  remquof(arg1, arg2, arg3);
+}
+
+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__remquof__leakignore() {
+  char *p = strdup(str);
+  result = remquof(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__remquof__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remquof(x, arg2, arg3);
+}
+
+void test__remquof__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remquof(arg1, x, arg3);
+}
+
+void test__remquof__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = remquof(arg1, arg2, NULL);
+}
+
+void test__std__remquof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::remquof(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__remquof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::remquof(arg1, arg2, arg3);
+}
+
+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__remquof__leakignore() {
+  char *p = strdup(str);
+  result = std::remquof(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__remquof__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remquof(x, arg2, arg3);
+}
+
+void test__std__remquof__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remquof(arg1, x, arg3);
+}
+
+void test__std__remquof__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::remquof(arg1, arg2, NULL);
+}
+
+void test__remquol__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = remquol(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__remquol__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  remquol(arg1, arg2, arg3);
+}
+
+void test__remquol__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((remquol(arg1, arg2, arg3) > 10) || (remquol(arg1, arg2, arg3) < 100)) {}
+}
+
+void test__remquol__leakignore() {
+  char *p = strdup(str);
+  result = remquol(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__remquol__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remquol(x, arg2, arg3);
+}
+
+void test__remquol__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = remquol(arg1, x, arg3);
+}
+
+void test__remquol__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = remquol(arg1, arg2, NULL);
+}
+
+void test__std__remquol__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::remquol(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__remquol__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::remquol(arg1, arg2, arg3);
+}
+
+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__remquol__leakignore() {
+  char *p = strdup(str);
+  result = std::remquol(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__remquol__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remquol(x, arg2, arg3);
+}
+
+void test__std__remquol__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::remquol(arg1, x, arg3);
+}
+
+void test__std__remquol__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::remquol(arg1, arg2, NULL);
+}
+
+void test__printf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else printf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__printf__leakignore() {
+  char *p = strdup(str);
+  printf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__printf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  printf(x);
+}
+
+void test__std__printf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::printf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__printf__leakignore() {
+  char *p = strdup(str);
+  std::printf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__printf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::printf(x);
+}
+
+void test__vprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vprintf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vprintf__leakignore() {
+  char *p = strdup(str);
+  vprintf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__vprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vprintf(x, arg2);
+}
+
+void test__std__vprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vprintf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vprintf__leakignore() {
+  char *p = strdup(str);
+  std::vprintf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__vprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vprintf(x, arg2);
+}
+
+void test__vwprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vwprintf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vwprintf__leakignore() {
+  char *p = strdup(str);
+  vwprintf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__vwprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vwprintf(x, arg2);
+}
+
+void test__std__vwprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vwprintf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vwprintf__leakignore() {
+  char *p = strdup(str);
+  std::vwprintf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__vwprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vwprintf(x, arg2);
+}
+
+void test__bsearch__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = bsearch(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__bsearch__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  bsearch(arg1, arg2, arg3, arg4, arg5);
+}
+
+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__bsearch__leakignore() {
+  char *p = strdup(str);
+  result = bsearch(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__bsearch__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = bsearch(NULL, arg2, arg3, arg4, arg5);
+}
+
+void test__bsearch__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = bsearch(x, arg2, arg3, arg4, arg5);
+}
+
+void test__bsearch__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = bsearch(arg1, NULL, arg3, arg4, arg5);
+}
+
+void test__bsearch__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = bsearch(arg1, x, arg3, arg4, arg5);
+}
+
+void test__bsearch__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = bsearch(arg1, arg2, x, arg4, arg5);
+}
+
+void test__bsearch__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = bsearch(arg1, arg2, arg3, x, arg5);
+}
+
+void test__bsearch__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  result = bsearch(arg1, arg2, arg3, arg4, NULL);
+}
+
+void test__bsearch__arg5__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = bsearch(arg1, arg2, arg3, arg4, x);
+}
+
+void test__std__bsearch__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::bsearch(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__bsearch__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::bsearch(arg1, arg2, arg3, arg4, arg5);
+}
+
+void test__std__bsearch__pure(int arg1,int arg2,int arg3,int arg4,int arg5) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::bsearch(arg1, arg2, arg3, arg4, arg5) > 10) || (std::bsearch(arg1, arg2, arg3, arg4, arg5) < 100)) {}
+}
+
+void test__std__bsearch__leakignore() {
+  char *p = strdup(str);
+  result = std::bsearch(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__std__bsearch__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::bsearch(NULL, arg2, arg3, arg4, arg5);
+}
+
+void test__std__bsearch__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::bsearch(x, arg2, arg3, arg4, arg5);
+}
+
+void test__std__bsearch__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::bsearch(arg1, NULL, arg3, arg4, arg5);
+}
+
+void test__std__bsearch__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::bsearch(arg1, x, arg3, arg4, arg5);
+}
+
+void test__std__bsearch__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::bsearch(arg1, arg2, x, arg4, arg5);
+}
+
+void test__std__bsearch__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::bsearch(arg1, arg2, arg3, x, arg5);
+}
+
+void test__std__bsearch__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::bsearch(arg1, arg2, arg3, arg4, NULL);
+}
+
+void test__std__bsearch__arg5__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::bsearch(arg1, arg2, arg3, arg4, x);
+}
+
+void test__qsort__noreturn() {
+  int x = 100;
+  if (cond) x=1; else qsort(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__qsort__leakignore() {
+  char *p = strdup(str);
+  qsort(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__qsort__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  qsort(NULL, arg2, arg3, arg4);
+}
+
+void test__qsort__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  qsort(x, arg2, arg3, arg4);
+}
+
+void test__qsort__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qsort(arg1, x, arg3, arg4);
+}
+
+void test__qsort__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  qsort(arg1, arg2, x, arg4);
+}
+
+void test__qsort__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  qsort(arg1, arg2, arg3, NULL);
+}
+
+void test__qsort__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  qsort(arg1, arg2, arg3, x);
+}
+
+void test__std__qsort__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::qsort(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__qsort__leakignore() {
+  char *p = strdup(str);
+  std::qsort(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__std__qsort__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::qsort(NULL, arg2, arg3, arg4);
+}
+
+void test__std__qsort__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::qsort(x, arg2, arg3, arg4);
+}
+
+void test__std__qsort__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::qsort(arg1, x, arg3, arg4);
+}
+
+void test__std__qsort__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::qsort(arg1, arg2, x, arg4);
+}
+
+void test__std__qsort__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  std::qsort(arg1, arg2, arg3, NULL);
+}
+
+void test__std__qsort__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::qsort(arg1, arg2, arg3, x);
+}
+
+void test__putc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else putc(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__putc__leakignore() {
+  char *p = strdup(str);
+  putc(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__putc__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  putc(!x, arg2);
+}
+
+void test__putc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  putc(x, arg2);
+}
+
+void test__putc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  putc(arg1, NULL);
+}
+
+void test__putc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  putc(arg1, x);
+}
+
+void test__std__putc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::putc(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__putc__leakignore() {
+  char *p = strdup(str);
+  std::putc(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__putc__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::putc(!x, arg2);
+}
+
+void test__std__putc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::putc(x, arg2);
+}
+
+void test__std__putc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::putc(arg1, NULL);
+}
+
+void test__std__putc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::putc(arg1, x);
+}
+
+void test__putwc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else putwc(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__putwc__leakignore() {
+  char *p = strdup(str);
+  putwc(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__putwc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  putwc(x, arg2);
+}
+
+void test__putwc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  putwc(arg1, NULL);
+}
+
+void test__putwc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  putwc(arg1, x);
+}
+
+void test__std__putwc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::putwc(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__putwc__leakignore() {
+  char *p = strdup(str);
+  std::putwc(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__putwc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::putwc(x, arg2);
+}
+
+void test__std__putwc__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::putwc(arg1, NULL);
+}
+
+void test__std__putwc__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::putwc(arg1, x);
+}
+
+void test__putchar__noreturn() {
+  int x = 100;
+  if (cond) x=1; else putchar(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__putchar__leakignore() {
+  char *p = strdup(str);
+  putchar(p);
+  // cppcheck-suppress memleak
+}
+
+void test__putchar__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  putchar(!x);
+}
+
+void test__putchar__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  putchar(x);
+}
+
+void test__std__putchar__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::putchar(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__putchar__leakignore() {
+  char *p = strdup(str);
+  std::putchar(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__putchar__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::putchar(!x);
+}
+
+void test__std__putchar__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::putchar(x);
+}
+
+void test__putwchar__noreturn() {
+  int x = 100;
+  if (cond) x=1; else putwchar(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__putwchar__leakignore() {
+  char *p = strdup(str);
+  putwchar(p);
+  // cppcheck-suppress memleak
+}
+
+void test__putwchar__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  putwchar(x);
+}
+
+void test__std__putwchar__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::putwchar(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__putwchar__leakignore() {
+  char *p = strdup(str);
+  std::putwchar(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__putwchar__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::putwchar(x);
+}
+
+void test__puts__noreturn() {
+  int x = 100;
+  if (cond) x=1; else puts(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__puts__leakignore() {
+  char *p = strdup(str);
+  puts(p);
+  // cppcheck-suppress memleak
+}
+
+void test__puts__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  puts(!x);
+}
+
+void test__puts__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  puts(NULL);
+}
+
+void test__puts__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  puts(x);
+}
+
+void test__std__puts__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::puts(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__puts__leakignore() {
+  char *p = strdup(str);
+  std::puts(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__puts__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::puts(!x);
+}
+
+void test__std__puts__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::puts(NULL);
+}
+
+void test__std__puts__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::puts(x);
+}
+
+void test__realloc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else realloc(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__realloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  realloc(x, arg2);
+}
+
+void test__realloc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  realloc(arg1, x);
+}
+
+void test__std__realloc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::realloc(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__realloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::realloc(x, arg2);
+}
+
+void test__std__realloc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::realloc(arg1, x);
+}
+
+void test__remove__noreturn() {
+  int x = 100;
+  if (cond) x=1; else remove(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__remove__leakignore() {
+  char *p = strdup(str);
+  remove(p);
+  // cppcheck-suppress memleak
+}
+
+void test__remove__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  remove(NULL);
+}
+
+void test__remove__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  remove(x);
+}
+
+void test__std__remove__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::remove(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__remove__leakignore() {
+  char *p = strdup(str);
+  std::remove(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__remove__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::remove(NULL);
+}
+
+void test__std__remove__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::remove(x);
+}
+
+void test__rename__noreturn() {
+  int x = 100;
+  if (cond) x=1; else rename(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__rename__leakignore() {
+  char *p = strdup(str);
+  rename(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__rename__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  rename(NULL, arg2);
+}
+
+void test__rename__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  rename(x, arg2);
+}
+
+void test__rename__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  rename(arg1, NULL);
+}
+
+void test__rename__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  rename(arg1, x);
+}
+
+void test__std__rename__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::rename(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__rename__leakignore() {
+  char *p = strdup(str);
+  std::rename(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__rename__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::rename(NULL, arg2);
+}
+
+void test__std__rename__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::rename(x, arg2);
+}
+
+void test__std__rename__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::rename(arg1, NULL);
+}
+
+void test__std__rename__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::rename(arg1, x);
+}
+
+void test__rewind__noreturn() {
+  int x = 100;
+  if (cond) x=1; else rewind(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__rewind__leakignore() {
+  char *p = strdup(str);
+  rewind(p);
+  // cppcheck-suppress memleak
+}
+
+void test__rewind__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  rewind(NULL);
+}
+
+void test__rewind__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  rewind(x);
+}
+
+void test__std__rewind__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::rewind(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__rewind__leakignore() {
+  char *p = strdup(str);
+  std::rewind(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__rewind__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::rewind(NULL);
+}
+
+void test__std__rewind__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::rewind(x);
+}
+
+void test__round__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = round(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__round__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  round(arg1);
+}
+
+void test__round__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((round(arg1) > 10) || (round(arg1) < 100)) {}
+}
+
+void test__round__leakignore() {
+  char *p = strdup(str);
+  result = round(p);
+  // cppcheck-suppress memleak
+}
+
+void test__round__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = round(x);
+}
+
+void test__std__round__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::round(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__round__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::round(arg1);
+}
+
+void test__std__round__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::round(arg1) > 10) || (std::round(arg1) < 100)) {}
+}
+
+void test__std__round__leakignore() {
+  char *p = strdup(str);
+  result = std::round(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__round__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::round(x);
+}
+
+void test__roundf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = roundf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__roundf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  roundf(arg1);
+}
+
+void test__roundf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((roundf(arg1) > 10) || (roundf(arg1) < 100)) {}
+}
+
+void test__roundf__leakignore() {
+  char *p = strdup(str);
+  result = roundf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__roundf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = roundf(x);
+}
+
+void test__std__roundf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::roundf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__roundf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::roundf(arg1);
+}
+
+void test__std__roundf__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::roundf(arg1) > 10) || (std::roundf(arg1) < 100)) {}
+}
+
+void test__std__roundf__leakignore() {
+  char *p = strdup(str);
+  result = std::roundf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__roundf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::roundf(x);
+}
+
+void test__roundl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = roundl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__roundl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  roundl(arg1);
+}
+
+void test__roundl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((roundl(arg1) > 10) || (roundl(arg1) < 100)) {}
+}
+
+void test__roundl__leakignore() {
+  char *p = strdup(str);
+  result = roundl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__roundl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = roundl(x);
+}
+
+void test__std__roundl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::roundl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__roundl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::roundl(arg1);
+}
+
+void test__std__roundl__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::roundl(arg1) > 10) || (std::roundl(arg1) < 100)) {}
+}
+
+void test__std__roundl__leakignore() {
+  char *p = strdup(str);
+  result = std::roundl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__roundl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::roundl(x);
+}
+
+void test__scalbn__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = scalbn(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__scalbn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  scalbn(arg1, arg2);
+}
+
+void test__scalbn__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((scalbn(arg1, arg2) > 10) || (scalbn(arg1, arg2) < 100)) {}
+}
+
+void test__scalbn__leakignore() {
+  char *p = strdup(str);
+  result = scalbn(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__scalbn__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbn(x, arg2);
+}
+
+void test__scalbn__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbn(arg1, x);
+}
+
+void test__std__scalbn__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::scalbn(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__scalbn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::scalbn(arg1, arg2);
+}
+
+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__scalbn__leakignore() {
+  char *p = strdup(str);
+  result = std::scalbn(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__scalbn__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbn(x, arg2);
+}
+
+void test__std__scalbn__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbn(arg1, x);
+}
+
+void test__scalbnf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = scalbnf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__scalbnf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  scalbnf(arg1, arg2);
+}
+
+void test__scalbnf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((scalbnf(arg1, arg2) > 10) || (scalbnf(arg1, arg2) < 100)) {}
+}
+
+void test__scalbnf__leakignore() {
+  char *p = strdup(str);
+  result = scalbnf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__scalbnf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbnf(x, arg2);
+}
+
+void test__scalbnf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbnf(arg1, x);
+}
+
+void test__std__scalbnf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::scalbnf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__scalbnf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::scalbnf(arg1, arg2);
+}
+
+void test__std__scalbnf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::scalbnf(arg1, arg2) > 10) || (std::scalbnf(arg1, arg2) < 100)) {}
+}
+
+void test__std__scalbnf__leakignore() {
+  char *p = strdup(str);
+  result = std::scalbnf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__scalbnf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbnf(x, arg2);
+}
+
+void test__std__scalbnf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbnf(arg1, x);
+}
+
+void test__scalbnl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = scalbnl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__scalbnl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  scalbnl(arg1, arg2);
+}
+
+void test__scalbnl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((scalbnl(arg1, arg2) > 10) || (scalbnl(arg1, arg2) < 100)) {}
+}
+
+void test__scalbnl__leakignore() {
+  char *p = strdup(str);
+  result = scalbnl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__scalbnl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbnl(x, arg2);
+}
+
+void test__scalbnl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbnl(arg1, x);
+}
+
+void test__std__scalbnl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::scalbnl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__scalbnl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::scalbnl(arg1, arg2);
+}
+
+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__scalbnl__leakignore() {
+  char *p = strdup(str);
+  result = std::scalbnl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__scalbnl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbnl(x, arg2);
+}
+
+void test__std__scalbnl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbnl(arg1, x);
+}
+
+void test__scalbln__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = scalbln(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__scalbln__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  scalbln(arg1, arg2);
+}
+
+void test__scalbln__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((scalbln(arg1, arg2) > 10) || (scalbln(arg1, arg2) < 100)) {}
+}
+
+void test__scalbln__leakignore() {
+  char *p = strdup(str);
+  result = scalbln(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__scalbln__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbln(x, arg2);
+}
+
+void test__scalbln__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalbln(arg1, x);
+}
+
+void test__std__scalbln__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::scalbln(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__scalbln__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::scalbln(arg1, 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__scalbln__leakignore() {
+  char *p = strdup(str);
+  result = std::scalbln(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__scalbln__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbln(x, arg2);
+}
+
+void test__std__scalbln__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalbln(arg1, x);
+}
+
+void test__scalblnf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = scalblnf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__scalblnf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  scalblnf(arg1, arg2);
+}
+
+void test__scalblnf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((scalblnf(arg1, arg2) > 10) || (scalblnf(arg1, arg2) < 100)) {}
+}
+
+void test__scalblnf__leakignore() {
+  char *p = strdup(str);
+  result = scalblnf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__scalblnf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalblnf(x, arg2);
+}
+
+void test__scalblnf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalblnf(arg1, x);
+}
+
+void test__std__scalblnf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::scalblnf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__scalblnf__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::scalblnf(arg1, arg2);
+}
+
+void test__std__scalblnf__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::scalblnf(arg1, arg2) > 10) || (std::scalblnf(arg1, arg2) < 100)) {}
+}
+
+void test__std__scalblnf__leakignore() {
+  char *p = strdup(str);
+  result = std::scalblnf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__scalblnf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalblnf(x, arg2);
+}
+
+void test__std__scalblnf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalblnf(arg1, x);
+}
+
+void test__scalblnl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = scalblnl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__scalblnl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  scalblnl(arg1, arg2);
+}
+
+void test__scalblnl__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((scalblnl(arg1, arg2) > 10) || (scalblnl(arg1, arg2) < 100)) {}
+}
+
+void test__scalblnl__leakignore() {
+  char *p = strdup(str);
+  result = scalblnl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__scalblnl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalblnl(x, arg2);
+}
+
+void test__scalblnl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = scalblnl(arg1, x);
+}
+
+void test__std__scalblnl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::scalblnl(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__scalblnl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::scalblnl(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__std__scalblnl__leakignore() {
+  char *p = strdup(str);
+  result = std::scalblnl(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__scalblnl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalblnl(x, arg2);
+}
+
+void test__std__scalblnl__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::scalblnl(arg1, x);
+}
+
+void test__signbit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = signbit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__signbit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  signbit(arg1);
+}
+
+void test__signbit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((signbit(arg1) > 10) || (signbit(arg1) < 100)) {}
+}
+
+void test__signbit__leakignore() {
+  char *p = strdup(str);
+  result = signbit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__signbit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = signbit(x);
+}
+
+void test__std__signbit__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::signbit(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__signbit__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::signbit(arg1);
+}
+
+void test__std__signbit__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::signbit(arg1) > 10) || (std::signbit(arg1) < 100)) {}
+}
+
+void test__std__signbit__leakignore() {
+  char *p = strdup(str);
+  result = std::signbit(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__signbit__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::signbit(x);
+}
+
+void test__signal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else signal(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__signal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  signal(x, arg2);
+}
+
+void test__std__signal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::signal(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__signal__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::signal(x, arg2);
+}
+
+void test__raise__noreturn() {
+  int x = 100;
+  if (cond) x=1; else raise(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__raise__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  raise(x);
+}
+
+void test__std__raise__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else scanf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__scanf__leakignore() {
+  char *p = strdup(str);
+  scanf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__scanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  scanf(NULL);
+}
+
+void test__scanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  scanf(x);
+}
+
+void test__std__scanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::scanf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__scanf__leakignore() {
+  char *p = strdup(str);
+  std::scanf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__scanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::scanf(NULL);
+}
+
+void test__std__scanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::scanf(x);
+}
+
+void test__vsscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vsscanf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vsscanf__leakignore() {
+  char *p = strdup(str);
+  vsscanf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__vsscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vsscanf(NULL, arg2, arg3);
+}
+
+void test__vsscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vsscanf(x, arg2, arg3);
+}
+
+void test__vsscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  vsscanf(arg1, NULL, arg3);
+}
+
+void test__vsscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vsscanf(arg1, x, arg3);
+}
+
+void test__std__vsscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vsscanf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vsscanf__leakignore() {
+  char *p = strdup(str);
+  std::vsscanf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__vsscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vsscanf(NULL, arg2, arg3);
+}
+
+void test__std__vsscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vsscanf(x, arg2, arg3);
+}
+
+void test__std__vsscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vsscanf(arg1, NULL, arg3);
+}
+
+void test__std__vsscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vsscanf(arg1, x, arg3);
+}
+
+void test__vswscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vswscanf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vswscanf__leakignore() {
+  char *p = strdup(str);
+  vswscanf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__vswscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vswscanf(NULL, arg2, arg3);
+}
+
+void test__vswscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vswscanf(x, arg2, arg3);
+}
+
+void test__vswscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  vswscanf(arg1, NULL, arg3);
+}
+
+void test__vswscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vswscanf(arg1, x, arg3);
+}
+
+void test__std__vswscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vswscanf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vswscanf__leakignore() {
+  char *p = strdup(str);
+  std::vswscanf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__vswscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vswscanf(NULL, arg2, arg3);
+}
+
+void test__std__vswscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vswscanf(x, arg2, arg3);
+}
+
+void test__std__vswscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vswscanf(arg1, NULL, arg3);
+}
+
+void test__std__vswscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vswscanf(arg1, x, arg3);
+}
+
+void test__vscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vscanf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vscanf__leakignore() {
+  char *p = strdup(str);
+  vscanf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__vscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vscanf(NULL, arg2);
+}
+
+void test__vscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vscanf(x, arg2);
+}
+
+void test__std__vscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vscanf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vscanf__leakignore() {
+  char *p = strdup(str);
+  std::vscanf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__vscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vscanf(NULL, arg2);
+}
+
+void test__std__vscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vscanf(x, arg2);
+}
+
+void test__vwscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vwscanf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vwscanf__leakignore() {
+  char *p = strdup(str);
+  vwscanf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__vwscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vwscanf(NULL, arg2);
+}
+
+void test__std__vwscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vwscanf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vwscanf__leakignore() {
+  char *p = strdup(str);
+  std::vwscanf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__vwscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vwscanf(NULL, arg2);
+}
+
+void test__setbuf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setbuf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setbuf__leakignore() {
+  char *p = strdup(str);
+  setbuf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__setbuf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  setbuf(NULL, arg2);
+}
+
+void test__setbuf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  setbuf(x, arg2);
+}
+
+void test__setbuf__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  setbuf(arg1, !x);
+}
+
+void test__std__setbuf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::setbuf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__setbuf__leakignore() {
+  char *p = strdup(str);
+  std::setbuf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__setbuf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::setbuf(NULL, arg2);
+}
+
+void test__std__setbuf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::setbuf(x, arg2);
+}
+
+void test__std__setbuf__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::setbuf(arg1, !x);
+}
+
+void test__setvbuf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setvbuf(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setvbuf__leakignore() {
+  char *p = strdup(str);
+  setvbuf(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__setvbuf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  setvbuf(NULL, arg2, arg3, arg4);
+}
+
+void test__setvbuf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  setvbuf(x, arg2, arg3, arg4);
+}
+
+void test__setvbuf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setvbuf(arg1, x, arg3, arg4);
+}
+
+void test__setvbuf__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setvbuf(arg1, arg2, x, arg4);
+}
+
+void test__setvbuf__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setvbuf(arg1, arg2, arg3, x);
+}
+
+void test__std__setvbuf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::setvbuf(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__setvbuf__leakignore() {
+  char *p = strdup(str);
+  std::setvbuf(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__std__setvbuf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::setvbuf(NULL, arg2, arg3, arg4);
+}
+
+void test__std__setvbuf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::setvbuf(x, arg2, arg3, arg4);
+}
+
+void test__std__setvbuf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setvbuf(arg1, x, arg3, arg4);
+}
+
+void test__std__setvbuf__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setvbuf(arg1, arg2, x, arg4);
+}
+
+void test__std__setvbuf__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setvbuf(arg1, arg2, arg3, x);
+}
+
+void test__setjmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setjmp(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setjmp__leakignore() {
+  char *p = strdup(str);
+  setjmp(p);
+  // cppcheck-suppress memleak
+}
+
+void test__strcat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strcat(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strcat__leakignore() {
+  char *p = strdup(str);
+  strcat(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strcat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strcat(NULL, arg2);
+}
+
+void test__strcat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strcat(x, arg2);
+}
+
+void test__strcat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strcat(arg1, NULL);
+}
+
+void test__strcat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strcat(arg1, x);
+}
+
+void test__std__strcat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strcat(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strcat__leakignore() {
+  char *p = strdup(str);
+  std::strcat(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strcat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strcat(NULL, arg2);
+}
+
+void test__std__strcat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strcat(x, arg2);
+}
+
+void test__std__strcat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strcat(arg1, NULL);
+}
+
+void test__std__strcat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strcat(arg1, x);
+}
+
+void test__wcscat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcscat(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcscat__leakignore() {
+  char *p = strdup(str);
+  wcscat(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcscat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcscat(NULL, arg2);
+}
+
+void test__wcscat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcscat(arg1, NULL);
+}
+
+void test__wcscat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcscat(arg1, x);
+}
+
+void test__std__wcscat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wcscat(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcscat__leakignore() {
+  char *p = strdup(str);
+  std::wcscat(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcscat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcscat(NULL, arg2);
+}
+
+void test__std__wcscat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcscat(arg1, NULL);
+}
+
+void test__std__wcscat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcscat(arg1, x);
+}
+
+void test__wcrtomb__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcrtomb(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcrtomb__leakignore() {
+  char *p = strdup(str);
+  wcrtomb(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcrtomb__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcrtomb(arg1, x, arg3);
+}
+
+void test__std__wcrtomb__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wcrtomb(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcrtomb__leakignore() {
+  char *p = strdup(str);
+  std::wcrtomb(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcrtomb__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcrtomb(arg1, x, arg3);
+}
+
+void test__strchr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strchr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strchr(arg1, arg2);
+}
+
+void test__strchr__leakignore() {
+  char *p = strdup(str);
+  result = strchr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strchr(NULL, arg2);
+}
+
+void test__strchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strchr(x, arg2);
+}
+
+void test__strchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strchr(arg1, x);
+}
+
+void test__std__strchr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::strchr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strchr(arg1, arg2);
+}
+
+void test__std__strchr__leakignore() {
+  char *p = strdup(str);
+  result = std::strchr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strchr(NULL, arg2);
+}
+
+void test__std__strchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strchr(x, arg2);
+}
+
+void test__std__strchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::strchr(arg1, x);
+}
+
+void test__wcschr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcschr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcschr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcschr(arg1, arg2);
+}
+
+void test__wcschr__leakignore() {
+  char *p = strdup(str);
+  result = wcschr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcschr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcschr(NULL, arg2);
+}
+
+void test__wcschr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcschr(x, arg2);
+}
+
+void test__wcschr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcschr(arg1, x);
+}
+
+void test__std__wcschr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wcschr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcschr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcschr(arg1, arg2);
+}
+
+void test__std__wcschr__leakignore() {
+  char *p = strdup(str);
+  result = std::wcschr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcschr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcschr(NULL, arg2);
+}
+
+void test__std__wcschr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcschr(x, arg2);
+}
+
+void test__std__wcschr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wcschr(arg1, x);
+}
+
+void test__strcmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strcmp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strcmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strcmp(arg1, arg2);
+}
+
+void test__strcmp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strcmp(arg1, arg2) > 10) || (strcmp(arg1, arg2) < 100)) {}
+}
+
+void test__strcmp__leakignore() {
+  char *p = strdup(str);
+  result = strcmp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strcmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strcmp(NULL, arg2);
+}
+
+void test__strcmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strcmp(x, arg2);
+}
+
+void test__strcmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strcmp(arg1, NULL);
+}
+
+void test__strcmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strcmp(arg1, x);
+}
+
+void test__std__strcmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::strcmp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strcmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strcmp(arg1, arg2);
+}
+
+void test__std__strcmp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::strcmp(arg1, arg2) > 10) || (std::strcmp(arg1, arg2) < 100)) {}
+}
+
+void test__std__strcmp__leakignore() {
+  char *p = strdup(str);
+  result = std::strcmp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strcmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strcmp(NULL, arg2);
+}
+
+void test__std__strcmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strcmp(x, arg2);
+}
+
+void test__std__strcmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strcmp(arg1, NULL);
+}
+
+void test__std__strcmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strcmp(arg1, x);
+}
+
+void test__wcscmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcscmp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcscmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcscmp(arg1, arg2);
+}
+
+void test__wcscmp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wcscmp(arg1, arg2) > 10) || (wcscmp(arg1, arg2) < 100)) {}
+}
+
+void test__wcscmp__leakignore() {
+  char *p = strdup(str);
+  result = wcscmp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcscmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcscmp(NULL, arg2);
+}
+
+void test__wcscmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcscmp(x, arg2);
+}
+
+void test__wcscmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcscmp(arg1, NULL);
+}
+
+void test__wcscmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcscmp(arg1, x);
+}
+
+void test__std__wcscmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wcscmp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcscmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcscmp(arg1, arg2);
+}
+
+void test__std__wcscmp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wcscmp(arg1, arg2) > 10) || (std::wcscmp(arg1, arg2) < 100)) {}
+}
+
+void test__std__wcscmp__leakignore() {
+  char *p = strdup(str);
+  result = std::wcscmp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcscmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcscmp(NULL, arg2);
+}
+
+void test__std__wcscmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcscmp(x, arg2);
+}
+
+void test__std__wcscmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcscmp(arg1, NULL);
+}
+
+void test__std__wcscmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcscmp(arg1, x);
+}
+
+void test__strcpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strcpy(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strcpy__leakignore() {
+  char *p = strdup(str);
+  strcpy(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strcpy(NULL, arg2);
+}
+
+void test__strcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strcpy(arg1, NULL);
+}
+
+void test__strcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strcpy(arg1, x);
+}
+
+void test__std__strcpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strcpy(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strcpy__leakignore() {
+  char *p = strdup(str);
+  std::strcpy(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strcpy(NULL, arg2);
+}
+
+void test__std__strcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strcpy(arg1, NULL);
+}
+
+void test__std__strcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strcpy(arg1, x);
+}
+
+void test__wcscpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcscpy(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcscpy__leakignore() {
+  char *p = strdup(str);
+  wcscpy(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcscpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcscpy(NULL, arg2);
+}
+
+void test__wcscpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcscpy(arg1, NULL);
+}
+
+void test__wcscpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcscpy(arg1, x);
+}
+
+void test__std__wcscpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wcscpy(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcscpy__leakignore() {
+  char *p = strdup(str);
+  std::wcscpy(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcscpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcscpy(NULL, arg2);
+}
+
+void test__std__wcscpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcscpy(arg1, NULL);
+}
+
+void test__std__wcscpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcscpy(arg1, x);
+}
+
+void test__strftime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strftime(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strftime__leakignore() {
+  char *p = strdup(str);
+  strftime(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__strftime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strftime(NULL, arg2, arg3, arg4);
+}
+
+void test__strftime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strftime(arg1, x, arg3, arg4);
+}
+
+void test__strftime__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  strftime(arg1, arg2, NULL, arg4);
+}
+
+void test__strftime__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strftime(arg1, arg2, x, arg4);
+}
+
+void test__strftime__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  strftime(arg1, arg2, arg3, NULL);
+}
+
+void test__strftime__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strftime(arg1, arg2, arg3, x);
+}
+
+void test__std__strftime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strftime(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strftime__leakignore() {
+  char *p = strdup(str);
+  std::strftime(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strftime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strftime(NULL, arg2, arg3, arg4);
+}
+
+void test__std__strftime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strftime(arg1, x, arg3, arg4);
+}
+
+void test__std__strftime__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strftime(arg1, arg2, NULL, arg4);
+}
+
+void test__std__strftime__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strftime(arg1, arg2, x, arg4);
+}
+
+void test__std__strftime__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strftime(arg1, arg2, arg3, NULL);
+}
+
+void test__std__strftime__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strftime(arg1, arg2, arg3, x);
+}
+
+void test__strfxtime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strfxtime(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strfxtime__leakignore() {
+  char *p = strdup(str);
+  strfxtime(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__strfxtime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strfxtime(NULL, arg2, arg3, arg4);
+}
+
+void test__strfxtime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strfxtime(arg1, x, arg3, arg4);
+}
+
+void test__strfxtime__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  strfxtime(arg1, arg2, NULL, arg4);
+}
+
+void test__strfxtime__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strfxtime(arg1, arg2, x, arg4);
+}
+
+void test__strfxtime__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  strfxtime(arg1, arg2, arg3, NULL);
+}
+
+void test__strfxtime__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strfxtime(arg1, arg2, arg3, x);
+}
+
+void test__strlen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strlen(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strlen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strlen(arg1);
+}
+
+void test__strlen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strlen(arg1) > 10) || (strlen(arg1) < 100)) {}
+}
+
+void test__strlen__leakignore() {
+  char *p = strdup(str);
+  result = strlen(p);
+  // cppcheck-suppress memleak
+}
+
+void test__strlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strlen(NULL);
+}
+
+void test__strlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strlen(x);
+}
+
+void test__std__strlen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::strlen(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strlen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strlen(arg1);
+}
+
+void test__std__strlen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::strlen(arg1) > 10) || (std::strlen(arg1) < 100)) {}
+}
+
+void test__std__strlen__leakignore() {
+  char *p = strdup(str);
+  result = std::strlen(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strlen(NULL);
+}
+
+void test__std__strlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strlen(x);
+}
+
+void test__wcslen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcslen(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcslen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcslen(arg1);
+}
+
+void test__wcslen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wcslen(arg1) > 10) || (wcslen(arg1) < 100)) {}
+}
+
+void test__wcslen__leakignore() {
+  char *p = strdup(str);
+  result = wcslen(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wcslen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcslen(NULL);
+}
+
+void test__wcslen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcslen(x);
+}
+
+void test__std__wcslen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wcslen(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcslen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcslen(arg1);
+}
+
+void test__std__wcslen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wcslen(arg1) > 10) || (std::wcslen(arg1) < 100)) {}
+}
+
+void test__std__wcslen__leakignore() {
+  char *p = strdup(str);
+  result = std::wcslen(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcslen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcslen(NULL);
+}
+
+void test__std__wcslen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcslen(x);
+}
+
+void test__strncpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strncpy(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strncpy__leakignore() {
+  char *p = strdup(str);
+  strncpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__strncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strncpy(NULL, arg2, arg3);
+}
+
+void test__strncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strncpy(arg1, NULL, arg3);
+}
+
+void test__strncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strncpy(arg1, x, arg3);
+}
+
+void test__strncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  strncpy(arg1, arg2, !x);
+}
+
+void test__strncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strncpy(arg1, arg2, x);
+}
+
+void test__std__strncpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strncpy(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strncpy__leakignore() {
+  char *p = strdup(str);
+  std::strncpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strncpy(NULL, arg2, arg3);
+}
+
+void test__std__strncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strncpy(arg1, NULL, arg3);
+}
+
+void test__std__strncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strncpy(arg1, x, arg3);
+}
+
+void test__std__strncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::strncpy(arg1, arg2, !x);
+}
+
+void test__std__strncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strncpy(arg1, arg2, x);
+}
+
+void test__strpbrk__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strpbrk(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strpbrk__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strpbrk(arg1, arg2);
+}
+
+void test__strpbrk__leakignore() {
+  char *p = strdup(str);
+  result = strpbrk(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strpbrk__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strpbrk(NULL, arg2);
+}
+
+void test__strpbrk__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strpbrk(x, arg2);
+}
+
+void test__strpbrk__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strpbrk(arg1, NULL);
+}
+
+void test__strpbrk__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strpbrk(arg1, x);
+}
+
+void test__std__strpbrk__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::strpbrk(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strpbrk__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strpbrk(arg1, arg2);
+}
+
+void test__std__strpbrk__leakignore() {
+  char *p = strdup(str);
+  result = std::strpbrk(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strpbrk__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strpbrk(NULL, arg2);
+}
+
+void test__std__strpbrk__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strpbrk(x, arg2);
+}
+
+void test__std__strpbrk__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strpbrk(arg1, NULL);
+}
+
+void test__std__strpbrk__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strpbrk(arg1, x);
+}
+
+void test__strncat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strncat(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strncat__leakignore() {
+  char *p = strdup(str);
+  strncat(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__strncat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strncat(NULL, arg2, arg3);
+}
+
+void test__strncat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strncat(x, arg2, arg3);
+}
+
+void test__strncat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strncat(arg1, NULL, arg3);
+}
+
+void test__strncat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strncat(arg1, x, arg3);
+}
+
+void test__strncat__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  strncat(arg1, arg2, !x);
+}
+
+void test__strncat__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strncat(arg1, arg2, x);
+}
+
+void test__std__strncat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strncat(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strncat__leakignore() {
+  char *p = strdup(str);
+  std::strncat(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strncat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strncat(NULL, arg2, arg3);
+}
+
+void test__std__strncat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strncat(x, arg2, arg3);
+}
+
+void test__std__strncat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strncat(arg1, NULL, arg3);
+}
+
+void test__std__strncat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strncat(arg1, x, arg3);
+}
+
+void test__std__strncat__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::strncat(arg1, arg2, !x);
+}
+
+void test__std__strncat__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strncat(arg1, arg2, x);
+}
+
+void test__wcsncat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcsncat(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcsncat__leakignore() {
+  char *p = strdup(str);
+  wcsncat(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcsncat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsncat(NULL, arg2, arg3);
+}
+
+void test__wcsncat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsncat(x, arg2, arg3);
+}
+
+void test__wcsncat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsncat(arg1, NULL, arg3);
+}
+
+void test__wcsncat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsncat(arg1, x, arg3);
+}
+
+void test__wcsncat__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wcsncat(arg1, arg2, !x);
+}
+
+void test__wcsncat__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcsncat(arg1, arg2, x);
+}
+
+void test__std__wcsncat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wcsncat(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcsncat__leakignore() {
+  char *p = strdup(str);
+  std::wcsncat(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcsncat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsncat(NULL, arg2, arg3);
+}
+
+void test__std__wcsncat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcsncat(x, arg2, arg3);
+}
+
+void test__std__wcsncat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsncat(arg1, NULL, arg3);
+}
+
+void test__std__wcsncat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcsncat(arg1, x, arg3);
+}
+
+void test__std__wcsncat__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::wcsncat(arg1, arg2, !x);
+}
+
+void test__std__wcsncat__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcsncat(arg1, arg2, x);
+}
+
+void test__strncmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strncmp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strncmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strncmp(arg1, arg2, arg3);
+}
+
+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__strncmp__leakignore() {
+  char *p = strdup(str);
+  result = strncmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__strncmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strncmp(NULL, arg2, arg3);
+}
+
+void test__strncmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strncmp(x, arg2, arg3);
+}
+
+void test__strncmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strncmp(arg1, NULL, arg3);
+}
+
+void test__strncmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strncmp(arg1, x, arg3);
+}
+
+void test__strncmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = strncmp(arg1, arg2, !x);
+}
+
+void test__strncmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strncmp(arg1, arg2, x);
+}
+
+void test__std__strncmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::strncmp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strncmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strncmp(arg1, arg2, arg3);
+}
+
+void test__std__strncmp__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::strncmp(arg1, arg2, arg3) > 10) || (std::strncmp(arg1, arg2, arg3) < 100)) {}
+}
+
+void test__std__strncmp__leakignore() {
+  char *p = strdup(str);
+  result = std::strncmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strncmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strncmp(NULL, arg2, arg3);
+}
+
+void test__std__strncmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strncmp(x, arg2, arg3);
+}
+
+void test__std__strncmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strncmp(arg1, NULL, arg3);
+}
+
+void test__std__strncmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strncmp(arg1, x, arg3);
+}
+
+void test__std__strncmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::strncmp(arg1, arg2, !x);
+}
+
+void test__std__strncmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::strncmp(arg1, arg2, x);
+}
+
+void test__wcsncmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcsncmp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcsncmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcsncmp(arg1, arg2, arg3);
+}
+
+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__wcsncmp__leakignore() {
+  char *p = strdup(str);
+  result = wcsncmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcsncmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsncmp(NULL, arg2, arg3);
+}
+
+void test__wcsncmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsncmp(x, arg2, arg3);
+}
+
+void test__wcsncmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsncmp(arg1, NULL, arg3);
+}
+
+void test__wcsncmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsncmp(arg1, x, arg3);
+}
+
+void test__wcsncmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = wcsncmp(arg1, arg2, !x);
+}
+
+void test__wcsncmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcsncmp(arg1, arg2, x);
+}
+
+void test__std__wcsncmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wcsncmp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcsncmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcsncmp(arg1, arg2, arg3);
+}
+
+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__wcsncmp__leakignore() {
+  char *p = strdup(str);
+  result = std::wcsncmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcsncmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcsncmp(NULL, arg2, arg3);
+}
+
+void test__std__wcsncmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcsncmp(x, arg2, arg3);
+}
+
+void test__std__wcsncmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcsncmp(arg1, NULL, arg3);
+}
+
+void test__std__wcsncmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcsncmp(arg1, x, arg3);
+}
+
+void test__std__wcsncmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = std::wcsncmp(arg1, arg2, !x);
+}
+
+void test__std__wcsncmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wcsncmp(arg1, arg2, x);
+}
+
+void test__strstr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strstr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strstr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strstr(arg1, arg2);
+}
+
+void test__strstr__leakignore() {
+  char *p = strdup(str);
+  result = strstr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strstr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strstr(NULL, arg2);
+}
+
+void test__strstr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strstr(x, arg2);
+}
+
+void test__strstr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strstr(arg1, NULL);
+}
+
+void test__strstr__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strstr(arg1, x);
+}
+
+void test__std__strstr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::strstr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strstr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strstr(arg1, arg2);
+}
+
+void test__std__strstr__leakignore() {
+  char *p = strdup(str);
+  result = std::strstr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strstr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strstr(NULL, arg2);
+}
+
+void test__std__strstr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strstr(x, arg2);
+}
+
+void test__std__strstr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strstr(arg1, NULL);
+}
+
+void test__std__strstr__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strstr(arg1, x);
+}
+
+void test__wcsstr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcsstr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcsstr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcsstr(arg1, arg2);
+}
+
+void test__wcsstr__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wcsstr(arg1, arg2) > 10) || (wcsstr(arg1, arg2) < 100)) {}
+}
+
+void test__wcsstr__leakignore() {
+  char *p = strdup(str);
+  result = wcsstr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcsstr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsstr(NULL, arg2);
+}
+
+void test__wcsstr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsstr(x, arg2);
+}
+
+void test__wcsstr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsstr(arg1, NULL);
+}
+
+void test__wcsstr__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsstr(arg1, x);
+}
+
+void test__std__wcsstr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wcsstr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcsstr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcsstr(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__wcsstr__leakignore() {
+  char *p = strdup(str);
+  result = std::wcsstr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcsstr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcsstr(NULL, arg2);
+}
+
+void test__std__wcsstr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcsstr(x, arg2);
+}
+
+void test__std__wcsstr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcsstr(arg1, NULL);
+}
+
+void test__std__wcsstr__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcsstr(arg1, x);
+}
+
+void test__strspn__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strspn(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strspn(arg1, arg2);
+}
+
+void test__strspn__leakignore() {
+  char *p = strdup(str);
+  result = strspn(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strspn(NULL, arg2);
+}
+
+void test__strspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strspn(x, arg2);
+}
+
+void test__strspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strspn(arg1, NULL);
+}
+
+void test__strspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strspn(arg1, x);
+}
+
+void test__std__strspn__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::strspn(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strspn(arg1, arg2);
+}
+
+void test__std__strspn__leakignore() {
+  char *p = strdup(str);
+  result = std::strspn(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strspn(NULL, arg2);
+}
+
+void test__std__strspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strspn(x, arg2);
+}
+
+void test__std__strspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strspn(arg1, NULL);
+}
+
+void test__std__strspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strspn(arg1, x);
+}
+
+void test__strxfrm__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strxfrm(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strxfrm__leakignore() {
+  char *p = strdup(str);
+  strxfrm(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__strxfrm__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strxfrm(arg1, NULL, arg3);
+}
+
+void test__strxfrm__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strxfrm(arg1, x, arg3);
+}
+
+void test__strxfrm__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strxfrm(arg1, arg2, x);
+}
+
+void test__std__strxfrm__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strxfrm(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strxfrm__leakignore() {
+  char *p = strdup(str);
+  std::strxfrm(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strxfrm__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strxfrm(arg1, NULL, arg3);
+}
+
+void test__std__strxfrm__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strxfrm(arg1, x, arg3);
+}
+
+void test__std__strxfrm__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strxfrm(arg1, arg2, x);
+}
+
+void test__wcsxfrm__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcsxfrm(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcsxfrm__leakignore() {
+  char *p = strdup(str);
+  wcsxfrm(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcsxfrm__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsxfrm(arg1, NULL, arg3);
+}
+
+void test__wcsxfrm__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsxfrm(arg1, x, arg3);
+}
+
+void test__wcsxfrm__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcsxfrm(arg1, arg2, x);
+}
+
+void test__std__wcsxfrm__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wcsxfrm(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcsxfrm__leakignore() {
+  char *p = strdup(str);
+  std::wcsxfrm(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcsxfrm__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsxfrm(arg1, NULL, arg3);
+}
+
+void test__std__wcsxfrm__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcsxfrm(arg1, x, arg3);
+}
+
+void test__std__wcsxfrm__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcsxfrm(arg1, arg2, x);
+}
+
+void test__wcsspn__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcsspn(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcsspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcsspn(arg1, arg2);
+}
+
+void test__wcsspn__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wcsspn(arg1, arg2) > 10) || (wcsspn(arg1, arg2) < 100)) {}
+}
+
+void test__wcsspn__leakignore() {
+  char *p = strdup(str);
+  result = wcsspn(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcsspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsspn(NULL, arg2);
+}
+
+void test__wcsspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsspn(x, arg2);
+}
+
+void test__wcsspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsspn(arg1, NULL);
+}
+
+void test__wcsspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsspn(arg1, x);
+}
+
+void test__std__wcsspn__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wcsspn(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcsspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcsspn(arg1, arg2);
+}
+
+void test__std__wcsspn__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::wcsspn(arg1, arg2) > 10) || (std::wcsspn(arg1, arg2) < 100)) {}
+}
+
+void test__std__wcsspn__leakignore() {
+  char *p = strdup(str);
+  result = std::wcsspn(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcsspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcsspn(NULL, arg2);
+}
+
+void test__std__wcsspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcsspn(x, arg2);
+}
+
+void test__std__wcsspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcsspn(arg1, NULL);
+}
+
+void test__std__wcsspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcsspn(arg1, x);
+}
+
+void test__localeconv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = localeconv();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__localeconv__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  localeconv();
+}
+
+void test__localeconv__leakignore() {
+  char *p = strdup(str);
+  result = localeconv();
+  // cppcheck-suppress memleak
+}
+
+void test__std__localeconv__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::localeconv();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__localeconv__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::localeconv();
+}
+
+void test__std__localeconv__leakignore() {
+  char *p = strdup(str);
+  result = std::localeconv();
+  // cppcheck-suppress memleak
+}
+
+void test__std__locale__global__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::locale::global(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__locale__global__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::locale::global(arg1);
+}
+
+void test__std__locale__global__leakignore() {
+  char *p = strdup(str);
+  result = std::locale::global(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__locale__global__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::locale::global(x);
+}
+
+void test__std__locale__classic__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::locale::classic();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__locale__classic__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::locale::classic();
+}
+
+void test__std__locale__classic__leakignore() {
+  char *p = strdup(str);
+  result = std::locale::classic();
+  // cppcheck-suppress memleak
+}
+
+void test__setlocale__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setlocale(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setlocale__leakignore() {
+  char *p = strdup(str);
+  setlocale(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__setlocale__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setlocale(x, arg2);
+}
+
+void test__setlocale__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setlocale(arg1, x);
+}
+
+void test__std__setlocale__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::setlocale(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__setlocale__leakignore() {
+  char *p = strdup(str);
+  std::setlocale(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__setlocale__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setlocale(x, arg2);
+}
+
+void test__std__setlocale__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setlocale(arg1, x);
+}
+
+void test__strerror__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strerror(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strerror__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strerror(arg1);
+}
+
+void test__strerror__leakignore() {
+  char *p = strdup(str);
+  result = strerror(p);
+  // cppcheck-suppress memleak
+}
+
+void test__strerror__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strerror(x);
+}
+
+void test__std__strerror__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::strerror(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strerror__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strerror(arg1);
+}
+
+void test__std__strerror__leakignore() {
+  char *p = strdup(str);
+  result = std::strerror(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strerror__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::strerror(x);
+}
+
+void test__strcspn__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strcspn(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strcspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strcspn(arg1, arg2);
+}
+
+void test__strcspn__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strcspn(arg1, arg2) > 10) || (strcspn(arg1, arg2) < 100)) {}
+}
+
+void test__strcspn__leakignore() {
+  char *p = strdup(str);
+  result = strcspn(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strcspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strcspn(NULL, arg2);
+}
+
+void test__strcspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strcspn(x, arg2);
+}
+
+void test__strcspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strcspn(arg1, NULL);
+}
+
+void test__strcspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strcspn(arg1, x);
+}
+
+void test__std__strcspn__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::strcspn(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strcspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strcspn(arg1, arg2);
+}
+
+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__strcspn__leakignore() {
+  char *p = strdup(str);
+  result = std::strcspn(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strcspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strcspn(NULL, arg2);
+}
+
+void test__std__strcspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strcspn(x, arg2);
+}
+
+void test__std__strcspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strcspn(arg1, NULL);
+}
+
+void test__std__strcspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strcspn(arg1, x);
+}
+
+void test__wcscspn__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcscspn(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcscspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcscspn(arg1, arg2);
+}
+
+void test__wcscspn__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wcscspn(arg1, arg2) > 10) || (wcscspn(arg1, arg2) < 100)) {}
+}
+
+void test__wcscspn__leakignore() {
+  char *p = strdup(str);
+  result = wcscspn(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcscspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcscspn(NULL, arg2);
+}
+
+void test__wcscspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcscspn(x, arg2);
+}
+
+void test__wcscspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcscspn(arg1, NULL);
+}
+
+void test__wcscspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcscspn(arg1, x);
+}
+
+void test__std__wcscspn__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wcscspn(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcscspn__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcscspn(arg1, arg2);
+}
+
+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__wcscspn__leakignore() {
+  char *p = strdup(str);
+  result = std::wcscspn(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcscspn__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcscspn(NULL, arg2);
+}
+
+void test__std__wcscspn__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcscspn(x, arg2);
+}
+
+void test__std__wcscspn__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcscspn(arg1, NULL);
+}
+
+void test__std__wcscspn__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcscspn(arg1, x);
+}
+
+void test__wcspbrk__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcspbrk(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcspbrk__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcspbrk(arg1, arg2);
+}
+
+void test__wcspbrk__leakignore() {
+  char *p = strdup(str);
+  result = wcspbrk(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcspbrk__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcspbrk(NULL, arg2);
+}
+
+void test__wcspbrk__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcspbrk(x, arg2);
+}
+
+void test__wcspbrk__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcspbrk(arg1, x);
+}
+
+void test__std__wcspbrk__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wcspbrk(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcspbrk__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcspbrk(arg1, arg2);
+}
+
+void test__std__wcspbrk__leakignore() {
+  char *p = strdup(str);
+  result = std::wcspbrk(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcspbrk__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcspbrk(NULL, arg2);
+}
+
+void test__std__wcspbrk__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcspbrk(x, arg2);
+}
+
+void test__std__wcspbrk__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wcspbrk(arg1, x);
+}
+
+void test__wcsncpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcsncpy(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcsncpy__leakignore() {
+  char *p = strdup(str);
+  wcsncpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcsncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsncpy(NULL, arg2, arg3);
+}
+
+void test__wcsncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsncpy(arg1, NULL, arg3);
+}
+
+void test__wcsncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsncpy(arg1, x, arg3);
+}
+
+void test__wcsncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wcsncpy(arg1, arg2, !x);
+}
+
+void test__wcsncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcsncpy(arg1, arg2, x);
+}
+
+void test__std__wcsncpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wcsncpy(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcsncpy__leakignore() {
+  char *p = strdup(str);
+  std::wcsncpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcsncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsncpy(NULL, arg2, arg3);
+}
+
+void test__std__wcsncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsncpy(arg1, NULL, arg3);
+}
+
+void test__std__wcsncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcsncpy(arg1, x, arg3);
+}
+
+void test__std__wcsncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  std::wcsncpy(arg1, arg2, !x);
+}
+
+void test__std__wcsncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcsncpy(arg1, arg2, x);
+}
+
+void test__strcoll__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strcoll(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strcoll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strcoll(arg1, arg2);
+}
+
+void test__strcoll__leakignore() {
+  char *p = strdup(str);
+  result = strcoll(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strcoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strcoll(NULL, arg2);
+}
+
+void test__strcoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strcoll(x, arg2);
+}
+
+void test__strcoll__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strcoll(arg1, NULL);
+}
+
+void test__strcoll__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strcoll(arg1, x);
+}
+
+void test__std__strcoll__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::strcoll(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strcoll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strcoll(arg1, arg2);
+}
+
+void test__std__strcoll__leakignore() {
+  char *p = strdup(str);
+  result = std::strcoll(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strcoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strcoll(NULL, arg2);
+}
+
+void test__std__strcoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strcoll(x, arg2);
+}
+
+void test__std__strcoll__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strcoll(arg1, NULL);
+}
+
+void test__std__strcoll__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strcoll(arg1, x);
+}
+
+void test__wcscoll__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcscoll(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcscoll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcscoll(arg1, arg2);
+}
+
+void test__wcscoll__leakignore() {
+  char *p = strdup(str);
+  result = wcscoll(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcscoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcscoll(NULL, arg2);
+}
+
+void test__wcscoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcscoll(x, arg2);
+}
+
+void test__wcscoll__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcscoll(arg1, NULL);
+}
+
+void test__wcscoll__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcscoll(arg1, x);
+}
+
+void test__std__wcscoll__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wcscoll(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcscoll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcscoll(arg1, arg2);
+}
+
+void test__std__wcscoll__leakignore() {
+  char *p = strdup(str);
+  result = std::wcscoll(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcscoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcscoll(NULL, arg2);
+}
+
+void test__std__wcscoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcscoll(x, arg2);
+}
+
+void test__std__wcscoll__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcscoll(arg1, NULL);
+}
+
+void test__std__wcscoll__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcscoll(arg1, x);
+}
+
+void test__strrchr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strrchr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strrchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strrchr(arg1, arg2);
+}
+
+void test__strrchr__leakignore() {
+  char *p = strdup(str);
+  result = strrchr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strrchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strrchr(NULL, arg2);
+}
+
+void test__strrchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strrchr(x, arg2);
+}
+
+void test__strrchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strrchr(arg1, x);
+}
+
+void test__std__strrchr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::strrchr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strrchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::strrchr(arg1, arg2);
+}
+
+void test__std__strrchr__leakignore() {
+  char *p = strdup(str);
+  result = std::strrchr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strrchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::strrchr(NULL, arg2);
+}
+
+void test__std__strrchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::strrchr(x, arg2);
+}
+
+void test__std__strrchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::strrchr(arg1, x);
+}
+
+void test__wcsrchr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcsrchr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcsrchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcsrchr(arg1, arg2);
+}
+
+void test__wcsrchr__leakignore() {
+  char *p = strdup(str);
+  result = wcsrchr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcsrchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsrchr(NULL, arg2);
+}
+
+void test__wcsrchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsrchr(x, arg2);
+}
+
+void test__wcsrchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcsrchr(arg1, x);
+}
+
+void test__std__wcsrchr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wcsrchr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcsrchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcsrchr(arg1, arg2);
+}
+
+void test__std__wcsrchr__leakignore() {
+  char *p = strdup(str);
+  result = std::wcsrchr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcsrchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcsrchr(NULL, arg2);
+}
+
+void test__std__wcsrchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcsrchr(x, arg2);
+}
+
+void test__std__wcsrchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wcsrchr(arg1, x);
+}
+
+void test__wcsrtombs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcsrtombs(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcsrtombs__leakignore() {
+  char *p = strdup(str);
+  wcsrtombs(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__wcsrtombs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsrtombs(arg1, NULL, arg3, arg4);
+}
+
+void test__wcsrtombs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsrtombs(arg1, x, arg3, arg4);
+}
+
+void test__wcsrtombs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcsrtombs(arg1, arg2, x, arg4);
+}
+
+void test__wcsrtombs__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsrtombs(arg1, arg2, arg3, NULL);
+}
+
+void test__std__wcsrtombs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wcsrtombs(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcsrtombs__leakignore() {
+  char *p = strdup(str);
+  std::wcsrtombs(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcsrtombs__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsrtombs(arg1, NULL, arg3, arg4);
+}
+
+void test__std__wcsrtombs__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcsrtombs(arg1, x, arg3, arg4);
+}
+
+void test__std__wcsrtombs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcsrtombs(arg1, arg2, x, arg4);
+}
+
+void test__std__wcsrtombs__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcsrtombs(arg1, arg2, arg3, NULL);
+}
+
+void test__strtok__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strtok(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strtok__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strtok(arg1, arg2) > 10) || (strtok(arg1, arg2) < 100)) {}
+}
+
+void test__strtok__leakignore() {
+  char *p = strdup(str);
+  strtok(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strtok__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtok(x, arg2);
+}
+
+void test__strtok__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strtok(arg1, NULL);
+}
+
+void test__strtok__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtok(arg1, x);
+}
+
+void test__std__strtok__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strtok(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strtok__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((std::strtok(arg1, arg2) > 10) || (std::strtok(arg1, arg2) < 100)) {}
+}
+
+void test__std__strtok__leakignore() {
+  char *p = strdup(str);
+  std::strtok(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strtok__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strtok(x, arg2);
+}
+
+void test__std__strtok__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtok(arg1, NULL);
+}
+
+void test__std__strtok__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtok(arg1, x);
+}
+
+void test__strtof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strtof(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strtof__leakignore() {
+  char *p = strdup(str);
+  strtof(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strtof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtof(NULL, arg2);
+}
+
+void test__strtof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtof(x, arg2);
+}
+
+void test__std__strtof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strtof(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strtof__leakignore() {
+  char *p = strdup(str);
+  std::strtof(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strtof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtof(NULL, arg2);
+}
+
+void test__std__strtof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtof(x, arg2);
+}
+
+void test__strtod__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strtod(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strtod__leakignore() {
+  char *p = strdup(str);
+  strtod(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strtod__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtod(NULL, arg2);
+}
+
+void test__strtod__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtod(x, arg2);
+}
+
+void test__std__strtod__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strtod(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strtod__leakignore() {
+  char *p = strdup(str);
+  std::strtod(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strtod__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtod(NULL, arg2);
+}
+
+void test__std__strtod__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtod(x, arg2);
+}
+
+void test__strtold__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strtold(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strtold__leakignore() {
+  char *p = strdup(str);
+  strtold(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strtold__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtold(NULL, arg2);
+}
+
+void test__strtold__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtold(x, arg2);
+}
+
+void test__std__strtold__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strtold(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strtold__leakignore() {
+  char *p = strdup(str);
+  std::strtold(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strtold__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtold(NULL, arg2);
+}
+
+void test__std__strtold__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtold(x, arg2);
+}
+
+void test__strtol__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strtol(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strtol__leakignore() {
+  char *p = strdup(str);
+  strtol(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__strtol__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtol(NULL, arg2, arg3);
+}
+
+void test__strtol__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtol(x, arg2, arg3);
+}
+
+void test__strtol__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtol(arg1, arg2, x);
+}
+
+void test__std__strtol__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strtol(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strtol__leakignore() {
+  char *p = strdup(str);
+  std::strtol(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strtol__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtol(NULL, arg2, arg3);
+}
+
+void test__std__strtol__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtol(x, arg2, arg3);
+}
+
+void test__std__strtol__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strtol(arg1, arg2, x);
+}
+
+void test__strtoul__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strtoul(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strtoul__leakignore() {
+  char *p = strdup(str);
+  strtoul(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__strtoul__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtoul(NULL, arg2, arg3);
+}
+
+void test__strtoul__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtoul(x, arg2, arg3);
+}
+
+void test__strtoul__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtoul(arg1, arg2, x);
+}
+
+void test__std__strtoul__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strtoul(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strtoul__leakignore() {
+  char *p = strdup(str);
+  std::strtoul(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strtoul__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtoul(NULL, arg2, arg3);
+}
+
+void test__std__strtoul__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtoul(x, arg2, arg3);
+}
+
+void test__std__strtoul__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strtoul(arg1, arg2, x);
+}
+
+void test__strtoll__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strtoll(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strtoll__leakignore() {
+  char *p = strdup(str);
+  strtoll(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__strtoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtoll(NULL, arg2, arg3);
+}
+
+void test__strtoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtoll(x, arg2, arg3);
+}
+
+void test__strtoll__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtoll(arg1, arg2, x);
+}
+
+void test__std__strtoll__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strtoll(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strtoll__leakignore() {
+  char *p = strdup(str);
+  std::strtoll(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strtoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtoll(NULL, arg2, arg3);
+}
+
+void test__std__strtoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtoll(x, arg2, arg3);
+}
+
+void test__std__strtoll__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strtoll(arg1, arg2, x);
+}
+
+void test__strtoull__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strtoull(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strtoull__leakignore() {
+  char *p = strdup(str);
+  strtoull(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__strtoull__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtoull(NULL, arg2, arg3);
+}
+
+void test__strtoull__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtoull(x, arg2, arg3);
+}
+
+void test__strtoull__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtoull(arg1, arg2, x);
+}
+
+void test__std__strtoull__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strtoull(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strtoull__leakignore() {
+  char *p = strdup(str);
+  std::strtoull(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strtoull__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtoull(NULL, arg2, arg3);
+}
+
+void test__std__strtoull__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtoull(x, arg2, arg3);
+}
+
+void test__std__strtoull__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strtoull(arg1, arg2, x);
+}
+
+void test__strtoimax__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strtoimax(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strtoimax__leakignore() {
+  char *p = strdup(str);
+  strtoimax(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__strtoimax__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtoimax(NULL, arg2, arg3);
+}
+
+void test__strtoimax__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtoimax(x, arg2, arg3);
+}
+
+void test__strtoimax__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtoimax(arg1, arg2, x);
+}
+
+void test__std__strtoimax__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strtoimax(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strtoimax__leakignore() {
+  char *p = strdup(str);
+  std::strtoimax(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__strtoimax__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::strtoimax(NULL, arg2, arg3);
+}
+
+void test__std__strtoimax__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::strtoimax(x, arg2, arg3);
+}
+
+void test__std__strtoimax__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::strtoimax(arg1, arg2, x);
+}
+
+void test__strtoumax__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strtoumax(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strtoumax__leakignore() {
+  char *p = strdup(str);
+  strtoumax(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__strtoumax__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strtoumax(NULL, arg2, arg3);
+}
+
+void test__strtoumax__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtoumax(x, arg2, arg3);
+}
+
+void test__strtoumax__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtoumax(arg1, arg2, x);
+}
+
+void test__std__strtoumax__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::strtoumax(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__strtoumax__leakignore() {
+  char *p = strdup(str);
+  std::strtoumax(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else time(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__time__leakignore() {
+  char *p = strdup(str);
+  time(p);
+  // cppcheck-suppress memleak
+}
+
+void test__time__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  time(x);
+}
+
+void test__std__time__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::time(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__time__leakignore() {
+  char *p = strdup(str);
+  std::time(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__time__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::time(x);
+}
+
+void test__tmpnam__noreturn() {
+  int x = 100;
+  if (cond) x=1; else tmpnam(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tmpnam__leakignore() {
+  char *p = strdup(str);
+  tmpnam(p);
+  // cppcheck-suppress memleak
+}
+
+void test__tmpnam__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  tmpnam(x);
+}
+
+void test__std__tmpnam__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::tmpnam(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__tmpnam__leakignore() {
+  char *p = strdup(str);
+  std::tmpnam(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__tmpnam__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::tmpnam(x);
+}
+
+void test__tmpnam_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else tmpnam_s(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tmpnam_s__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else result = tmpfile();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tmpfile__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tmpfile();
+}
+
+void test__tolower__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = tolower(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__tolower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  tolower(arg1);
+}
+
+void test__tolower__leakignore() {
+  char *p = strdup(str);
+  result = tolower(p);
+  // cppcheck-suppress memleak
+}
+
+void test__tolower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = tolower(x);
+}
+
+void test__std__tolower__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::tolower(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__tolower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::tolower(arg1);
+}
+
+void test__std__tolower__leakignore() {
+  char *p = strdup(str);
+  result = std::tolower(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__tolower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::tolower(x);
+}
+
+void test__toupper__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = toupper(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__toupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  toupper(arg1);
+}
+
+void test__toupper__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::toupper(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__toupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::toupper(x);
+}
+
+void test__typeid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else va_arg(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__va_arg__leakignore() {
+  char *p = strdup(str);
+  va_arg(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__va_copy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else va_copy(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__va_copy__leakignore() {
+  char *p = strdup(str);
+  va_copy(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__va_end__noreturn() {
+  int x = 100;
+  if (cond) x=1; else va_end(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__va_end__leakignore() {
+  char *p = strdup(str);
+  va_end(p);
+  // cppcheck-suppress memleak
+}
+
+void test__va_start__noreturn() {
+  int x = 100;
+  if (cond) x=1; else va_start(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__va_start__leakignore() {
+  char *p = strdup(str);
+  va_start(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcstof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcstof(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcstof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcstof(arg1, arg2);
+}
+
+void test__wcstof__leakignore() {
+  char *p = strdup(str);
+  result = wcstof(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcstof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcstof(NULL, arg2);
+}
+
+void test__wcstof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcstof(x, arg2);
+}
+
+void test__std__wcstof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wcstof(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcstof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcstof(arg1, arg2);
+}
+
+void test__std__wcstof__leakignore() {
+  char *p = strdup(str);
+  result = std::wcstof(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcstof__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcstof(NULL, arg2);
+}
+
+void test__std__wcstof__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcstof(x, arg2);
+}
+
+void test__wcstod__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcstod(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcstod__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcstod(arg1, arg2);
+}
+
+void test__wcstod__leakignore() {
+  char *p = strdup(str);
+  result = wcstod(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcstod__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcstod(NULL, arg2);
+}
+
+void test__wcstod__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcstod(x, arg2);
+}
+
+void test__std__wcstod__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wcstod(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcstod__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcstod(arg1, arg2);
+}
+
+void test__std__wcstod__leakignore() {
+  char *p = strdup(str);
+  result = std::wcstod(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcstod__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcstod(NULL, arg2);
+}
+
+void test__std__wcstod__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcstod(x, arg2);
+}
+
+void test__wcstold__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcstold(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcstold__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcstold(arg1, arg2);
+}
+
+void test__wcstold__leakignore() {
+  char *p = strdup(str);
+  result = wcstold(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcstold__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcstold(NULL, arg2);
+}
+
+void test__wcstold__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcstold(x, arg2);
+}
+
+void test__std__wcstold__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wcstold(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcstold__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcstold(arg1, arg2);
+}
+
+void test__std__wcstold__leakignore() {
+  char *p = strdup(str);
+  result = std::wcstold(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcstold__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcstold(NULL, arg2);
+}
+
+void test__std__wcstold__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcstold(x, arg2);
+}
+
+void test__stof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = stof(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__stof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stof(arg1, arg2);
+}
+
+void test__stof__leakignore() {
+  char *p = strdup(str);
+  result = stof(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__stof__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stof(x, arg2);
+}
+
+void test__stof__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stof(arg1, x);
+}
+
+void test__std__stof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::stof(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__stof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stof(arg1, arg2);
+}
+
+void test__std__stof__leakignore() {
+  char *p = strdup(str);
+  result = std::stof(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__stof__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stof(x, arg2);
+}
+
+void test__std__stof__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stof(arg1, x);
+}
+
+void test__stod__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = stod(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__stod__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stod(arg1, arg2);
+}
+
+void test__stod__leakignore() {
+  char *p = strdup(str);
+  result = stod(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__stod__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stod(x, arg2);
+}
+
+void test__stod__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stod(arg1, x);
+}
+
+void test__std__stod__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::stod(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__stod__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stod(arg1, arg2);
+}
+
+void test__std__stod__leakignore() {
+  char *p = strdup(str);
+  result = std::stod(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__stod__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stod(x, arg2);
+}
+
+void test__std__stod__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stod(arg1, x);
+}
+
+void test__stold__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = stold(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__stold__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stold(arg1, arg2);
+}
+
+void test__stold__leakignore() {
+  char *p = strdup(str);
+  result = stold(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__stold__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stold(x, arg2);
+}
+
+void test__stold__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stold(arg1, x);
+}
+
+void test__std__stold__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::stold(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__stold__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stold(arg1, arg2);
+}
+
+void test__std__stold__leakignore() {
+  char *p = strdup(str);
+  result = std::stold(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__stold__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stold(x, arg2);
+}
+
+void test__std__stold__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stold(arg1, x);
+}
+
+void test__stoi__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = stoi(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__stoi__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stoi(arg1, arg2, arg3);
+}
+
+void test__stoi__leakignore() {
+  char *p = strdup(str);
+  result = stoi(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__stoi__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoi(x, arg2, arg3);
+}
+
+void test__stoi__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoi(arg1, x, arg3);
+}
+
+void test__stoi__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoi(arg1, arg2, x);
+}
+
+void test__std__stoi__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::stoi(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__stoi__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stoi(arg1, arg2, arg3);
+}
+
+void test__std__stoi__leakignore() {
+  char *p = strdup(str);
+  result = std::stoi(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__stoi__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoi(x, arg2, arg3);
+}
+
+void test__std__stoi__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoi(arg1, x, arg3);
+}
+
+void test__std__stoi__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoi(arg1, arg2, x);
+}
+
+void test__stol__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = stol(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__stol__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stol(arg1, arg2, arg3);
+}
+
+void test__stol__leakignore() {
+  char *p = strdup(str);
+  result = stol(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__stol__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stol(x, arg2, arg3);
+}
+
+void test__stol__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stol(arg1, x, arg3);
+}
+
+void test__stol__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stol(arg1, arg2, x);
+}
+
+void test__std__stol__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::stol(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__stol__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stol(arg1, arg2, arg3);
+}
+
+void test__std__stol__leakignore() {
+  char *p = strdup(str);
+  result = std::stol(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__stol__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stol(x, arg2, arg3);
+}
+
+void test__std__stol__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stol(arg1, x, arg3);
+}
+
+void test__std__stol__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stol(arg1, arg2, x);
+}
+
+void test__stoll__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = stoll(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__stoll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stoll(arg1, arg2, arg3);
+}
+
+void test__stoll__leakignore() {
+  char *p = strdup(str);
+  result = stoll(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__stoll__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoll(x, arg2, arg3);
+}
+
+void test__stoll__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoll(arg1, x, arg3);
+}
+
+void test__stoll__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoll(arg1, arg2, x);
+}
+
+void test__std__stoll__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::stoll(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__stoll__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stoll(arg1, arg2, arg3);
+}
+
+void test__std__stoll__leakignore() {
+  char *p = strdup(str);
+  result = std::stoll(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__stoll__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoll(x, arg2, arg3);
+}
+
+void test__std__stoll__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoll(arg1, x, arg3);
+}
+
+void test__std__stoll__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoll(arg1, arg2, x);
+}
+
+void test__stoul__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = stoul(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__stoul__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stoul(arg1, arg2, arg3);
+}
+
+void test__stoul__leakignore() {
+  char *p = strdup(str);
+  result = stoul(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__stoul__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoul(x, arg2, arg3);
+}
+
+void test__stoul__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoul(arg1, x, arg3);
+}
+
+void test__stoul__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoul(arg1, arg2, x);
+}
+
+void test__std__stoul__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::stoul(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__stoul__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stoul(arg1, arg2, arg3);
+}
+
+void test__std__stoul__leakignore() {
+  char *p = strdup(str);
+  result = std::stoul(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__stoul__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoul(x, arg2, arg3);
+}
+
+void test__std__stoul__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoul(arg1, x, arg3);
+}
+
+void test__std__stoul__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoul(arg1, arg2, x);
+}
+
+void test__stoull__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = stoull(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__stoull__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  stoull(arg1, arg2, arg3);
+}
+
+void test__stoull__leakignore() {
+  char *p = strdup(str);
+  result = stoull(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__stoull__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoull(x, arg2, arg3);
+}
+
+void test__stoull__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoull(arg1, x, arg3);
+}
+
+void test__stoull__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = stoull(arg1, arg2, x);
+}
+
+void test__std__stoull__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::stoull(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__stoull__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::stoull(arg1, arg2, arg3);
+}
+
+void test__std__stoull__leakignore() {
+  char *p = strdup(str);
+  result = std::stoull(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__stoull__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoull(x, arg2, arg3);
+}
+
+void test__std__stoull__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoull(arg1, x, arg3);
+}
+
+void test__std__stoull__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::stoull(arg1, arg2, x);
+}
+
+void test__std__to_string__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::to_string(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__to_string__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::to_string(arg1);
+}
+
+void test__std__to_string__leakignore() {
+  char *p = strdup(str);
+  result = std::to_string(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__to_string__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::to_string(x);
+}
+
+void test__std__string__resize__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::string::resize(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__string__resize__leakignore() {
+  char *p = strdup(str);
+  std::string::resize(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__string__resize__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::string::resize(x, arg2);
+}
+
+void test__std__string__resize__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::string::resize(arg1, x);
+}
+
+void test__std__wstring__resize__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wstring::resize(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wstring__resize__leakignore() {
+  char *p = strdup(str);
+  std::wstring::resize(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wstring__resize__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wstring::resize(x, arg2);
+}
+
+void test__std__wstring__resize__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wstring::resize(arg1, x);
+}
+
+void test__std__to_wstring__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::to_wstring(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__to_wstring__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::to_wstring(arg1);
+}
+
+void test__std__to_wstring__leakignore() {
+  char *p = strdup(str);
+  result = std::to_wstring(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__to_wstring__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::to_wstring(x);
+}
+
+void test__mbrtowc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mbrtowc(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mbrtowc__leakignore() {
+  char *p = strdup(str);
+  mbrtowc(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__mbrtowc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrtowc(arg1, x, arg3, arg4);
+}
+
+void test__mbrtowc__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrtowc(arg1, arg2, x, arg4);
+}
+
+void test__mbrtowc__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrtowc(arg1, arg2, arg3, x);
+}
+
+void test__std__mbrtowc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::mbrtowc(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__mbrtowc__leakignore() {
+  char *p = strdup(str);
+  std::mbrtowc(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__std__mbrtowc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbrtowc(arg1, x, arg3, arg4);
+}
+
+void test__std__mbrtowc__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbrtowc(arg1, arg2, x, arg4);
+}
+
+void test__std__mbrtowc__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::mbrtowc(arg1, arg2, arg3, x);
+}
+
+void test__wcstok__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcstok(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcstok__leakignore() {
+  char *p = strdup(str);
+  wcstok(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcstok__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcstok(x, arg2, arg3);
+}
+
+void test__wcstok__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstok(arg1, NULL, arg3);
+}
+
+void test__wcstok__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcstok(arg1, x, arg3);
+}
+
+void test__wcstok__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstok(arg1, arg2, NULL);
+}
+
+void test__std__wcstok__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wcstok(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcstok__leakignore() {
+  char *p = strdup(str);
+  std::wcstok(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcstok__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcstok(x, arg2, arg3);
+}
+
+void test__std__wcstok__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcstok(arg1, NULL, arg3);
+}
+
+void test__std__wcstok__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcstok(arg1, x, arg3);
+}
+
+void test__std__wcstok__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcstok(arg1, arg2, NULL);
+}
+
+void test__wcstoimax__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcstoimax(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcstoimax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcstoimax(arg1, arg2, arg3);
+}
+
+void test__wcstoimax__leakignore() {
+  char *p = strdup(str);
+  result = wcstoimax(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcstoimax__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcstoimax(NULL, arg2, arg3);
+}
+
+void test__wcstoimax__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcstoimax(x, arg2, arg3);
+}
+
+void test__wcstoimax__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcstoimax(arg1, arg2, x);
+}
+
+void test__std__wcstoimax__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wcstoimax(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcstoimax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcstoimax(arg1, arg2, arg3);
+}
+
+void test__std__wcstoimax__leakignore() {
+  char *p = strdup(str);
+  result = std::wcstoimax(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcstoimax__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcstoimax(NULL, arg2, arg3);
+}
+
+void test__std__wcstoimax__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcstoimax(x, arg2, arg3);
+}
+
+void test__std__wcstoimax__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wcstoimax(arg1, arg2, x);
+}
+
+void test__wcstoumax__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcstoumax(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcstoumax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcstoumax(arg1, arg2, arg3);
+}
+
+void test__wcstoumax__leakignore() {
+  char *p = strdup(str);
+  result = wcstoumax(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcstoumax__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcstoumax(NULL, arg2, arg3);
+}
+
+void test__wcstoumax__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcstoumax(x, arg2, arg3);
+}
+
+void test__wcstoumax__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcstoumax(arg1, arg2, x);
+}
+
+void test__std__wcstoumax__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wcstoumax(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcstoumax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wcstoumax(arg1, arg2, arg3);
+}
+
+void test__std__wcstoumax__leakignore() {
+  char *p = strdup(str);
+  result = std::wcstoumax(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcstoumax__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wcstoumax(NULL, arg2, arg3);
+}
+
+void test__std__wcstoumax__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wcstoumax(x, arg2, arg3);
+}
+
+void test__std__wcstoumax__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wcstoumax(arg1, arg2, x);
+}
+
+void test__wcstol__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcstol(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcstol__leakignore() {
+  char *p = strdup(str);
+  wcstol(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcstol__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstol(NULL, arg2, arg3);
+}
+
+void test__wcstol__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcstol(x, arg2, arg3);
+}
+
+void test__wcstol__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcstol(arg1, arg2, x);
+}
+
+void test__std__wcstol__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wcstol(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcstol__leakignore() {
+  char *p = strdup(str);
+  std::wcstol(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcstol__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcstol(NULL, arg2, arg3);
+}
+
+void test__std__wcstol__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcstol(x, arg2, arg3);
+}
+
+void test__std__wcstol__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcstol(arg1, arg2, x);
+}
+
+void test__wcstoll__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcstoll(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcstoll__leakignore() {
+  char *p = strdup(str);
+  wcstoll(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcstoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstoll(NULL, arg2, arg3);
+}
+
+void test__wcstoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcstoll(x, arg2, arg3);
+}
+
+void test__wcstoll__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcstoll(arg1, arg2, x);
+}
+
+void test__std__wcstoll__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wcstoll(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcstoll__leakignore() {
+  char *p = strdup(str);
+  std::wcstoll(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcstoll__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcstoll(NULL, arg2, arg3);
+}
+
+void test__std__wcstoll__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcstoll(x, arg2, arg3);
+}
+
+void test__std__wcstoll__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcstoll(arg1, arg2, x);
+}
+
+void test__wcstoul__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcstoul(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcstoul__leakignore() {
+  char *p = strdup(str);
+  wcstoul(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcstoul__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstoul(NULL, arg2, arg3);
+}
+
+void test__wcstoul__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcstoul(x, arg2, arg3);
+}
+
+void test__wcstoul__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcstoul(arg1, arg2, x);
+}
+
+void test__std__wcstoul__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wcstoul(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcstoul__leakignore() {
+  char *p = strdup(str);
+  std::wcstoul(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcstoul__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcstoul(NULL, arg2, arg3);
+}
+
+void test__std__wcstoul__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcstoul(x, arg2, arg3);
+}
+
+void test__std__wcstoul__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcstoul(arg1, arg2, x);
+}
+
+void test__wcstoull__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcstoull(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcstoull__leakignore() {
+  char *p = strdup(str);
+  wcstoull(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcstoull__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstoull(NULL, arg2, arg3);
+}
+
+void test__wcstoull__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcstoull(x, arg2, arg3);
+}
+
+void test__wcstoull__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcstoull(arg1, arg2, x);
+}
+
+void test__std__wcstoull__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wcstoull(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wcstoull__leakignore() {
+  char *p = strdup(str);
+  std::wcstoull(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wcstoull__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wcstoull(NULL, arg2, arg3);
+}
+
+void test__std__wcstoull__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wcstoull(x, arg2, arg3);
+}
+
+void test__std__wcstoull__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::wcstoull(arg1, arg2, x);
+}
+
+void test__wprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wprintf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wprintf__leakignore() {
+  char *p = strdup(str);
+  wprintf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wprintf(NULL);
+}
+
+void test__std__wprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wprintf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wprintf__leakignore() {
+  char *p = strdup(str);
+  std::wprintf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wprintf(NULL);
+}
+
+void test__sprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sprintf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sprintf__leakignore() {
+  char *p = strdup(str);
+  sprintf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__sprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sprintf(x, arg2);
+}
+
+void test__sprintf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  sprintf(arg1, NULL);
+}
+
+void test__sprintf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  sprintf(arg1, x);
+}
+
+void test__std__sprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::sprintf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__sprintf__leakignore() {
+  char *p = strdup(str);
+  std::sprintf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__sprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::sprintf(x, arg2);
+}
+
+void test__std__sprintf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::sprintf(arg1, NULL);
+}
+
+void test__std__sprintf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::sprintf(arg1, x);
+}
+
+void test__swprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else swprintf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__swprintf__leakignore() {
+  char *p = strdup(str);
+  swprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__swprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  swprintf(x, arg2, arg3);
+}
+
+void test__swprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  swprintf(arg1, x, arg3);
+}
+
+void test__swprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  swprintf(arg1, arg2, NULL);
+}
+
+void test__swprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  swprintf(arg1, arg2, x);
+}
+
+void test__std__swprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::swprintf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__swprintf__leakignore() {
+  char *p = strdup(str);
+  std::swprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__swprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::swprintf(x, arg2, arg3);
+}
+
+void test__std__swprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::swprintf(arg1, x, arg3);
+}
+
+void test__std__swprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::swprintf(arg1, arg2, NULL);
+}
+
+void test__std__swprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::swprintf(arg1, arg2, x);
+}
+
+void test__vsprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vsprintf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vsprintf__leakignore() {
+  char *p = strdup(str);
+  vsprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__vsprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vsprintf(NULL, arg2, arg3);
+}
+
+void test__vsprintf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  vsprintf(arg1, NULL, arg3);
+}
+
+void test__vsprintf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vsprintf(arg1, x, arg3);
+}
+
+void test__std__vsprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vsprintf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vsprintf__leakignore() {
+  char *p = strdup(str);
+  std::vsprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__vsprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vsprintf(NULL, arg2, arg3);
+}
+
+void test__std__vsprintf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vsprintf(arg1, NULL, arg3);
+}
+
+void test__std__vsprintf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vsprintf(arg1, x, arg3);
+}
+
+void test__vswprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vswprintf(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vswprintf__leakignore() {
+  char *p = strdup(str);
+  vswprintf(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__vswprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  vswprintf(NULL, arg2, arg3, arg4);
+}
+
+void test__vswprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vswprintf(arg1, x, arg3, arg4);
+}
+
+void test__vswprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  vswprintf(arg1, arg2, NULL, arg4);
+}
+
+void test__vswprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vswprintf(arg1, arg2, x, arg4);
+}
+
+void test__std__vswprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vswprintf(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vswprintf__leakignore() {
+  char *p = strdup(str);
+  std::vswprintf(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__std__vswprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vswprintf(NULL, arg2, arg3, arg4);
+}
+
+void test__std__vswprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vswprintf(arg1, x, arg3, arg4);
+}
+
+void test__std__vswprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vswprintf(arg1, arg2, NULL, arg4);
+}
+
+void test__std__vswprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vswprintf(arg1, arg2, x, arg4);
+}
+
+void test__fwprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fwprintf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fwprintf__leakignore() {
+  char *p = strdup(str);
+  fwprintf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fwprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  fwprintf(NULL, arg2);
+}
+
+void test__fwprintf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fwprintf(arg1, NULL);
+}
+
+void test__fwprintf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fwprintf(arg1, x);
+}
+
+void test__std__fwprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fwprintf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fwprintf__leakignore() {
+  char *p = strdup(str);
+  std::fwprintf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fwprintf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fwprintf(NULL, arg2);
+}
+
+void test__std__fwprintf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::fwprintf(arg1, NULL);
+}
+
+void test__std__fwprintf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::fwprintf(arg1, x);
+}
+
+void test__snprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else snprintf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__snprintf__leakignore() {
+  char *p = strdup(str);
+  snprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__snprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  snprintf(arg1, x, arg3);
+}
+
+void test__snprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  snprintf(arg1, arg2, NULL);
+}
+
+void test__snprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  snprintf(arg1, arg2, x);
+}
+
+void test__std__snprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::snprintf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__snprintf__leakignore() {
+  char *p = strdup(str);
+  std::snprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__snprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::snprintf(arg1, x, arg3);
+}
+
+void test__std__snprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::snprintf(arg1, arg2, NULL);
+}
+
+void test__std__snprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::snprintf(arg1, arg2, x);
+}
+
+void test__vsnprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vsnprintf(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vsnprintf__leakignore() {
+  char *p = strdup(str);
+  vsnprintf(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__vsnprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vsnprintf(x, arg2, arg3, arg4);
+}
+
+void test__vsnprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vsnprintf(arg1, x, arg3, arg4);
+}
+
+void test__vsnprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  vsnprintf(arg1, arg2, NULL, arg4);
+}
+
+void test__vsnprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vsnprintf(arg1, arg2, x, arg4);
+}
+
+void test__std__vsnprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vsnprintf(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vsnprintf__leakignore() {
+  char *p = strdup(str);
+  std::vsnprintf(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__std__vsnprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vsnprintf(x, arg2, arg3, arg4);
+}
+
+void test__std__vsnprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::vsnprintf(arg1, x, arg3, arg4);
+}
+
+void test__std__vsnprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  std::vsnprintf(arg1, arg2, NULL, arg4);
+}
+
+void test__std__vsnprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::vsnprintf(arg1, arg2, x, arg4);
+}
+
+void test__wscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wscanf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wscanf__leakignore() {
+  char *p = strdup(str);
+  wscanf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wscanf(NULL);
+}
+
+void test__wscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wscanf(x);
+}
+
+void test__std__wscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wscanf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wscanf__leakignore() {
+  char *p = strdup(str);
+  std::wscanf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wscanf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::wscanf(NULL);
+}
+
+void test__std__wscanf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::wscanf(x);
+}
+
+void test__sscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sscanf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sscanf__leakignore() {
+  char *p = strdup(str);
+  sscanf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__sscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sscanf(x, arg2);
+}
+
+void test__sscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  sscanf(arg1, NULL);
+}
+
+void test__sscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  sscanf(arg1, x);
+}
+
+void test__std__sscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::sscanf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__sscanf__leakignore() {
+  char *p = strdup(str);
+  std::sscanf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__sscanf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::sscanf(x, arg2);
+}
+
+void test__std__sscanf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  std::sscanf(arg1, NULL);
+}
+
+void test__std__sscanf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  std::sscanf(arg1, x);
+}
+
+void test__fwscanf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fwscanf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fwscanf__leakignore() {
+  char *p = strdup(str);
+  fwscanf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else std::fwscanf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fwscanf__leakignore() {
+  char *p = strdup(str);
+  std::fwscanf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else swscanf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__swscanf__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else std::swscanf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__swscanf__leakignore() {
+  char *p = strdup(str);
+  std::swscanf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else system(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__system__leakignore() {
+  char *p = strdup(str);
+  system(p);
+  // cppcheck-suppress memleak
+}
+
+void test__system__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  system(x);
+}
+
+void test__std__system__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::system(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__system__leakignore() {
+  char *p = strdup(str);
+  std::system(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__system__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::system(x);
+}
+
+void test__setw__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setw(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setw__leakignore() {
+  char *p = strdup(str);
+  setw(p);
+  // cppcheck-suppress memleak
+}
+
+void test__setw__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setw(x);
+}
+
+void test__std__setw__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::setw(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__setw__leakignore() {
+  char *p = strdup(str);
+  std::setw(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__setw__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setw(x);
+}
+
+void test__min__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = min(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__min__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  min(arg1, arg2);
+}
+
+void test__min__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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__min__leakignore() {
+  char *p = strdup(str);
+  result = std::min(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__min__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::min(x, arg2);
+}
+
+void test__std__min__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::min(arg1, x);
+}
+
+void test__max__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = max(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__max__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  max(arg1, arg2);
+}
+
+void test__max__leakignore() {
+  char *p = strdup(str);
+  result = max(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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__max__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = std::max(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else setiosflags(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setiosflags__leakignore() {
+  char *p = strdup(str);
+  setiosflags(p);
+  // cppcheck-suppress memleak
+}
+
+void test__setiosflags__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setiosflags(x);
+}
+
+void test__std__setiosflags__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::setiosflags(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__setiosflags__leakignore() {
+  char *p = strdup(str);
+  std::setiosflags(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__setiosflags__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setiosflags(x);
+}
+
+void test__resetiosflags__noreturn() {
+  int x = 100;
+  if (cond) x=1; else resetiosflags(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__resetiosflags__leakignore() {
+  char *p = strdup(str);
+  resetiosflags(p);
+  // cppcheck-suppress memleak
+}
+
+void test__resetiosflags__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  resetiosflags(x);
+}
+
+void test__std__resetiosflags__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::resetiosflags(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__resetiosflags__leakignore() {
+  char *p = strdup(str);
+  std::resetiosflags(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__resetiosflags__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::resetiosflags(x);
+}
+
+void test__setfill__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setfill(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setfill__leakignore() {
+  char *p = strdup(str);
+  setfill(p);
+  // cppcheck-suppress memleak
+}
+
+void test__setfill__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setfill(x);
+}
+
+void test__std__setfill__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::setfill(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__setfill__leakignore() {
+  char *p = strdup(str);
+  std::setfill(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__setfill__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setfill(x);
+}
+
+void test__setprecision__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setprecision(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setprecision__leakignore() {
+  char *p = strdup(str);
+  setprecision(p);
+  // cppcheck-suppress memleak
+}
+
+void test__setprecision__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setprecision(x);
+}
+
+void test__std__setprecision__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::setprecision(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__setprecision__leakignore() {
+  char *p = strdup(str);
+  std::setprecision(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__setprecision__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setprecision(x);
+}
+
+void test__setbase__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setbase(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setbase__leakignore() {
+  char *p = strdup(str);
+  setbase(p);
+  // cppcheck-suppress memleak
+}
+
+void test__setbase__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setbase(x);
+}
+
+void test__std__setbase__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::setbase(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__setbase__leakignore() {
+  char *p = strdup(str);
+  std::setbase(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__setbase__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::setbase(x);
+}
+
+void test__zonetime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = zonetime(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__zonetime__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  zonetime(arg1, arg2);
+}
+
+void test__zonetime__leakignore() {
+  char *p = strdup(str);
+  result = zonetime(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__zonetime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = zonetime(NULL, arg2);
+}
+
+void test__zonetime__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = zonetime(x, arg2);
+}
+
+void test__zonetime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = zonetime(arg1, x);
+}
+
+void test__c16rtomb__noreturn() {
+  int x = 100;
+  if (cond) x=1; else c16rtomb(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__c16rtomb__leakignore() {
+  char *p = strdup(str);
+  c16rtomb(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__c16rtomb__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  c16rtomb(arg1, x, arg3);
+}
+
+void test__c16rtomb__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  c16rtomb(arg1, arg2, NULL);
+}
+
+void test__c16rtomb__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  c16rtomb(arg1, arg2, x);
+}
+
+void test__c32rtomb__noreturn() {
+  int x = 100;
+  if (cond) x=1; else c32rtomb(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__c32rtomb__leakignore() {
+  char *p = strdup(str);
+  c32rtomb(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__c32rtomb__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  c32rtomb(arg1, x, arg3);
+}
+
+void test__c32rtomb__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  c32rtomb(arg1, arg2, NULL);
+}
+
+void test__c32rtomb__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  c32rtomb(arg1, arg2, x);
+}
+
+void test__mbrtoc16__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mbrtoc16(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mbrtoc16__leakignore() {
+  char *p = strdup(str);
+  mbrtoc16(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__mbrtoc16__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrtoc16(arg1, x, arg3, arg4);
+}
+
+void test__mbrtoc16__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrtoc16(arg1, arg2, x, arg4);
+}
+
+void test__mbrtoc16__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  mbrtoc16(arg1, arg2, arg3, NULL);
+}
+
+void test__mbrtoc16__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mbrtoc16(arg1, arg2, arg3, x);
+}
+
+void test__mbrtoc32__noreturn() {
+  int x = 100;
+  if (cond) x=1; else mbrtoc32(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__mbrtoc32__leakignore() {
+  char *p = strdup(str);
+  mbrtoc32(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__mbrtoc32__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrtoc32(arg1, x, arg3, arg4);
+}
+
+void test__mbrtoc32__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  mbrtoc32(arg1, arg2, x, arg4);
+}
+
+void test__mbrtoc32__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  mbrtoc32(arg1, arg2, arg3, NULL);
+}
+
+void test__mbrtoc32__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  mbrtoc32(arg1, arg2, arg3, x);
+}
+
+void test__std__swap__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::swap(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__swap__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::swap(x, arg2);
+}
+
+void test__std__swap__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::swap(arg1, x);
+}
+
+void test__std__ostringstream__str__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else std::array::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__deque__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::deque::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__list__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::list::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__forward_list__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::forward_list::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__map__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::map::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__unordered_map__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::unordered_map::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__queue__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::queue::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__set__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::set::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__unordered_set__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::unordered_set::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__stack__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::stack::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__string__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::string::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wstring__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wstring::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__basic_string__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::basic_string::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vector__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vector::clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__array__empty__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else std::deque::emplace_back();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__deque__emplace_front__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::deque::emplace_front();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__list__emplace_back__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::list::emplace_back();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__list__emplace_front__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::list::emplace_front();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__forward_list__emplace_front__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::forward_list::emplace_front();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__queue__emplace__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::queue::emplace();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__stack__emplace__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::stack::emplace();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vector__emplace_back__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vector::emplace_back();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vector__emplace_front__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vector::emplace_front();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__list__find__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else std::list::pop_back();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__list__pop_front__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::list::pop_front();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__forward_list__pop_front__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::forward_list::pop_front();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__vector__pop_back__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::vector::pop_back();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__stack__pop__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::stack::pop();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__queue__pop__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::queue::pop();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__stack__top__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else std::string::swap(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__string__c_str__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else result = std::string::data();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__string__data__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::data();
+}
+
+void test__std__string__front__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::string::front();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__string__front__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::front();
+}
+
+void test__std__basic_string__find_last_not_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::basic_string::find_last_not_of(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__basic_string__find_last_not_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::find_last_not_of(arg1, arg2, arg3);
+}
+
+void test__std__basic_string__find_last_not_of__leakignore() {
+  char *p = strdup(str);
+  result = std::basic_string::find_last_not_of(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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__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_last_not_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_last_not_of(arg1, x, arg3);
+}
+
+void test__std__basic_string__find_last_not_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_last_not_of(arg1, arg2, x);
+}
+
+void test__std__string__find_last_not_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::string::find_last_not_of(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << 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__string__find_last_not_of__leakignore() {
+  char *p = strdup(str);
+  result = std::string::find_last_not_of(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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__string__find_last_not_of__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::string::find_last_not_of(x, arg2, arg3);
+}
+
+void test__std__string__find_last_not_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_last_not_of(arg1, x, arg3);
+}
+
+void test__std__string__find_last_not_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_last_not_of(arg1, arg2, x);
+}
+
+void test__std__wstring__find_last_not_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wstring::find_last_not_of(arg1, arg2, arg3);
+  // 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__wstring__find_last_not_of__leakignore() {
+  char *p = strdup(str);
+  result = std::wstring::find_last_not_of(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wstring__find_last_not_of__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wstring::find_last_not_of(NULL, arg2, arg3);
+}
+
+void test__std__wstring__find_last_not_of__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_last_not_of(x, arg2, arg3);
+}
+
+void test__std__wstring__find_last_not_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_last_not_of(arg1, x, arg3);
+}
+
+void test__std__wstring__find_last_not_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_last_not_of(arg1, arg2, x);
+}
+
+void test__std__basic_string__find_first_not_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::basic_string::find_first_not_of(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__basic_string__find_first_not_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::find_first_not_of(arg1, arg2, arg3);
+}
+
+void test__std__basic_string__find_first_not_of__leakignore() {
+  char *p = strdup(str);
+  result = std::basic_string::find_first_not_of(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__basic_string__find_first_not_of__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::basic_string::find_first_not_of(NULL, arg2, arg3);
+}
+
+void test__std__basic_string__find_first_not_of__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_first_not_of(x, arg2, arg3);
+}
+
+void test__std__basic_string__find_first_not_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_first_not_of(arg1, x, arg3);
+}
+
+void test__std__basic_string__find_first_not_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_first_not_of(arg1, arg2, x);
+}
+
+void test__std__string__find_first_not_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::string::find_first_not_of(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__string__find_first_not_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::find_first_not_of(arg1, arg2, arg3);
+}
+
+void test__std__string__find_first_not_of__leakignore() {
+  char *p = strdup(str);
+  result = std::string::find_first_not_of(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__string__find_first_not_of__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::string::find_first_not_of(NULL, arg2, arg3);
+}
+
+void test__std__string__find_first_not_of__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::string::find_first_not_of(x, arg2, arg3);
+}
+
+void test__std__string__find_first_not_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_first_not_of(arg1, x, arg3);
+}
+
+void test__std__string__find_first_not_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_first_not_of(arg1, arg2, x);
+}
+
+void test__std__wstring__find_first_not_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wstring::find_first_not_of(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wstring__find_first_not_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::find_first_not_of(arg1, arg2, arg3);
+}
+
+void test__std__wstring__find_first_not_of__leakignore() {
+  char *p = strdup(str);
+  result = std::wstring::find_first_not_of(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wstring__find_first_not_of__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wstring::find_first_not_of(NULL, arg2, arg3);
+}
+
+void test__std__wstring__find_first_not_of__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_first_not_of(x, arg2, arg3);
+}
+
+void test__std__wstring__find_first_not_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_first_not_of(arg1, x, arg3);
+}
+
+void test__std__wstring__find_first_not_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_first_not_of(arg1, arg2, x);
+}
+
+void test__std__string__find__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::string::find(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__string__find__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::find(arg1, arg2, arg3);
+}
+
+void test__std__string__find__leakignore() {
+  char *p = strdup(str);
+  result = std::string::find(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__string__find__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::string::find(NULL, arg2, arg3);
+}
+
+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__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find(arg1, x, arg3);
+}
+
+void test__std__string__find__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find(arg1, arg2, x);
+}
+
+void test__std__string__rfind__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::string::rfind(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__string__rfind__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::rfind(arg1, arg2, arg3);
+}
+
+void test__std__string__rfind__leakignore() {
+  char *p = strdup(str);
+  result = std::string::rfind(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__string__rfind__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::string::rfind(NULL, arg2, arg3);
+}
+
+void test__std__string__rfind__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::string::rfind(x, arg2, arg3);
+}
+
+void test__std__string__rfind__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::rfind(arg1, x, 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__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wstring::find(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wstring__find__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::find(arg1, arg2, arg3);
+}
+
+void test__std__wstring__find__leakignore() {
+  char *p = strdup(str);
+  result = std::wstring::find(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wstring__find__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wstring::find(NULL, arg2, arg3);
+}
+
+void test__std__wstring__find__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find(x, arg2, arg3);
+}
+
+void test__std__wstring__find__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find(arg1, x, arg3);
+}
+
+void test__std__wstring__find__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find(arg1, arg2, x);
+}
+
+void test__std__wstring__rfind__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wstring::rfind(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wstring__rfind__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::rfind(arg1, arg2, arg3);
+}
+
+void test__std__wstring__rfind__leakignore() {
+  char *p = strdup(str);
+  result = std::wstring::rfind(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wstring__rfind__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wstring::rfind(NULL, arg2, arg3);
+}
+
+void test__std__wstring__rfind__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wstring::rfind(x, arg2, arg3);
+}
+
+void test__std__wstring__rfind__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::rfind(arg1, x, arg3);
+}
+
+void test__std__wstring__rfind__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::rfind(arg1, arg2, x);
+}
+
+void test__std__basic_string__find__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::basic_string::find(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__basic_string__find__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::find(arg1, arg2, arg3);
+}
+
+void test__std__basic_string__find__leakignore() {
+  char *p = strdup(str);
+  result = std::basic_string::find(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__basic_string__find__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::basic_string::find(NULL, arg2, arg3);
+}
+
+void test__std__basic_string__find__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find(x, arg2, arg3);
+}
+
+void test__std__basic_string__find__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find(arg1, x, arg3);
+}
+
+void test__std__basic_string__find__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find(arg1, arg2, x);
+}
+
+void test__std__basic_string__rfind__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::basic_string::rfind(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__basic_string__rfind__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::rfind(arg1, arg2, arg3);
+}
+
+void test__std__basic_string__rfind__leakignore() {
+  char *p = strdup(str);
+  result = std::basic_string::rfind(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__basic_string__rfind__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::basic_string::rfind(NULL, arg2, arg3);
+}
+
+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__rfind__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::rfind(arg1, x, 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__string__find_first_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::string::find_first_of(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__string__find_first_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::find_first_of(arg1, arg2, arg3);
+}
+
+void test__std__string__find_first_of__leakignore() {
+  char *p = strdup(str);
+  result = std::string::find_first_of(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__string__find_first_of__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::string::find_first_of(NULL, arg2, arg3);
+}
+
+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_first_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_first_of(arg1, x, 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__wstring__find_first_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wstring::find_first_of(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wstring__find_first_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::find_first_of(arg1, arg2, arg3);
+}
+
+void test__std__wstring__find_first_of__leakignore() {
+  char *p = strdup(str);
+  result = std::wstring::find_first_of(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wstring__find_first_of__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wstring::find_first_of(NULL, arg2, arg3);
+}
+
+void test__std__wstring__find_first_of__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_first_of(x, arg2, arg3);
+}
+
+void test__std__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_first_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_first_of(arg1, arg2, x);
+}
+
+void test__std__basic_string__find_first_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::basic_string::find_first_of(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__basic_string__find_first_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::find_first_of(arg1, arg2, arg3);
+}
+
+void test__std__basic_string__find_first_of__leakignore() {
+  char *p = strdup(str);
+  result = std::basic_string::find_first_of(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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__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_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_first_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::basic_string::find_first_of(arg1, arg2, x);
+}
+
+void test__std__string__find_last_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::string::find_last_of(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__string__find_last_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::find_last_of(arg1, arg2, arg3);
+}
+
+void test__std__string__find_last_of__leakignore() {
+  char *p = strdup(str);
+  result = std::string::find_last_of(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__string__find_last_of__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::string::find_last_of(NULL, arg2, arg3);
+}
+
+void test__std__string__find_last_of__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = std::string::find_last_of(x, arg2, arg3);
+}
+
+void test__std__string__find_last_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::find_last_of(arg1, x, 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_last_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wstring::find_last_of(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wstring__find_last_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::find_last_of(arg1, arg2, arg3);
+}
+
+void test__std__wstring__find_last_of__leakignore() {
+  char *p = strdup(str);
+  result = std::wstring::find_last_of(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__wstring__find_last_of__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = std::wstring::find_last_of(NULL, arg2, arg3);
+}
+
+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__wstring__find_last_of__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_last_of(arg1, x, arg3);
+}
+
+void test__std__wstring__find_last_of__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::find_last_of(arg1, arg2, x);
+}
+
+void test__std__basic_string__find_last_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::basic_string::find_last_of(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__basic_string__find_last_of__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::find_last_of(arg1, arg2, arg3);
+}
+
+void test__std__basic_string__find_last_of__leakignore() {
+  char *p = strdup(str);
+  result = std::basic_string::find_last_of(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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__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__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__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__length__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::string::length();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__string__length__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::length();
+}
+
+void test__std__wstring__length__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wstring::length();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wstring__length__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::wstring::length();
+}
+
+void test__std__basic_string__size__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::basic_string::size();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__basic_string__size__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::size();
+}
+
+void test__std__basic_string__length__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::basic_string::length();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__basic_string__length__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::basic_string::length();
+}
+
+void test__std__string__substr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::string::substr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__string__substr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::string::substr(arg1, arg2);
+}
+
+void test__std__string__substr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::substr(x, arg2);
+}
+
+void test__std__string__substr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::string::substr(arg1, x);
+}
+
+void test__std__wstring__substr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::wstring::substr(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__wstring__substr__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::substr(x, arg2);
+}
+
+void test__std__wstring__substr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::wstring::substr(arg1, x);
+}
+
+void test__std__basic_string__substr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::basic_string::substr(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__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__ios__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::ios::clear(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ios__clear__leakignore() {
+  char *p = strdup(str);
+  std::ios::clear(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ios__clear__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ios::clear(x);
+}
+
+void test__std__fstream__clear__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::fstream::clear(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__fstream__clear__leakignore() {
+  char *p = strdup(str);
+  std::fstream::clear(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__fstream__clear__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::fstream::clear(x);
+}
+
+void test__std__istream__read__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::istream::read(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__istream__read__leakignore() {
+  char *p = strdup(str);
+  std::istream::read(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__istream__read__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::istream::read(NULL, arg2);
+}
+
+void test__std__istream__read__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::istream::read(arg1, x);
+}
+
+void test__std__ifstream__read__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::ifstream::read(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ifstream__read__leakignore() {
+  char *p = strdup(str);
+  std::ifstream::read(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ifstream__read__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::ifstream::read(NULL, arg2);
+}
+
+void test__std__ifstream__read__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ifstream::read(arg1, x);
+}
+
+void test__std__istream__readsome__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::istream::readsome(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__istream__readsome__leakignore() {
+  char *p = strdup(str);
+  std::istream::readsome(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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__readsome__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::ifstream::readsome(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ifstream__readsome__leakignore() {
+  char *p = strdup(str);
+  std::ifstream::readsome(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ifstream__readsome__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::ifstream::readsome(NULL, arg2);
+}
+
+void test__std__ifstream__readsome__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ifstream::readsome(arg1, x);
+}
+
+void test__std__istream__getline__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::istream::getline(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__istream__getline__leakignore() {
+  char *p = strdup(str);
+  std::istream::getline(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__istream__getline__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::istream::getline(NULL, arg2, arg3);
+}
+
+void test__std__istream__getline__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::istream::getline(arg1, x, arg3);
+}
+
+void test__std__istream__getline__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::istream::getline(arg1, arg2, x);
+}
+
+void test__std__ifstream__getline__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::ifstream::getline(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ifstream__getline__leakignore() {
+  char *p = strdup(str);
+  std::ifstream::getline(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ifstream__getline__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::ifstream::getline(NULL, arg2, arg3);
+}
+
+void test__std__ifstream__getline__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ifstream::getline(arg1, x, arg3);
+}
+
+void test__std__ifstream__getline__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ifstream::getline(arg1, arg2, x);
+}
+
+void test__std__istream__get__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::istream::get(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__istream__get__leakignore() {
+  char *p = strdup(str);
+  std::istream::get(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__istream__get__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::istream::get(NULL, arg2, arg3);
+}
+
+void test__std__istream__get__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::istream::get(arg1, x, arg3);
+}
+
+void test__std__istream__get__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::istream::get(arg1, arg2, x);
+}
+
+void test__std__ifstream__get__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::ifstream::get(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__ifstream__get__leakignore() {
+  char *p = strdup(str);
+  std::ifstream::get(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__std__ifstream__get__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  std::ifstream::get(NULL, arg2, arg3);
+}
+
+void test__std__ifstream__get__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ifstream::get(arg1, x, arg3);
+}
+
+void test__std__ifstream__get__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::ifstream::get(arg1, arg2, x);
+}
+
+void test__itoa__noreturn() {
+  int x = 100;
+  if (cond) x=1; else itoa(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__itoa__leakignore() {
+  char *p = strdup(str);
+  itoa(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__itoa__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  itoa(x, arg2, arg3);
+}
+
+void test__itoa__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  itoa(arg1, NULL, arg3);
+}
+
+void test__itoa__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  itoa(arg1, arg2, x);
+}
+
+void test__std__string__erase__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::string::erase(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__string__erase__leakignore() {
+  char *p = strdup(str);
+  std::string::erase(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else std::wstring::erase(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wstring__erase__leakignore() {
+  char *p = strdup(str);
+  std::wstring::erase(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else std::basic_string::erase(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__basic_string__erase__leakignore() {
+  char *p = strdup(str);
+  std::basic_string::erase(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__std__basic_string__erase__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::basic_string::erase(x, arg2);
+}
+
+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 = 100;
+  if (cond) x=1; else std::string::reserve(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__string__reserve__leakignore() {
+  char *p = strdup(str);
+  std::string::reserve(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__string__reserve__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::string::reserve(x);
+}
+
+void test__std__wstring__reserve__noreturn() {
+  int x = 100;
+  if (cond) x=1; else std::wstring::reserve(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__wstring__reserve__leakignore() {
+  char *p = strdup(str);
+  std::wstring::reserve(p);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else std::basic_string::reserve(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__basic_string__reserve__leakignore() {
+  char *p = strdup(str);
+  std::basic_string::reserve(p);
+  // cppcheck-suppress memleak
+}
+
+void test__std__basic_string__reserve__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  std::basic_string::reserve(x);
+}
+
+void test__std__adjacent_find__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = std::adjacent_find(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__std__adjacent_find__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  std::adjacent_find(arg1, arg2, arg3);
+}
+
+void test__std__adjacent_find__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__find__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find(arg1, arg2, x);
+}
+
+void test__std__find_if__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_if(arg1, arg2, x);
+}
+
+void test__std__find_if_not__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::find_if_not(arg1, arg2, x);
+}
+
+void test__std__copy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__all_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::all_of(arg1, arg2, x);
+}
+
+void test__std__any_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::any_of(arg1, arg2, x);
+}
+
+void test__std__none_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::none_of(arg1, arg2, x);
+}
+
+void test__std__count__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::count(arg1, arg2, x);
+}
+
+void test__std__count_if__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::count_if(arg1, arg2, x);
+}
+
+void test__std__for_each__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__search_n__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__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__find_end__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__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__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_first_of__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__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__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__search__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__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__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__inplace_merge__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__equal__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::equal(arg1, arg2, x);
+}
+
+void test__std__is_permutation__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::is_permutation(arg1, arg2, x);
+}
+
+void test__std__mismatch__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = std::mismatch(arg1, arg2, x);
+}
+
+void test__offsetof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = offsetof(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__offsetof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  offsetof(arg1, arg2);
+}
+
+void test__offsetof__leakignore() {
+  char *p = strdup(str);
+  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
new file mode 100644
index 000000000..717562fe8
--- /dev/null
+++ b/test/cfg/generated-cfg-tests-windows.cpp
@@ -0,0 +1,14109 @@
+// auto generated tests from cfg/windows.cfg
+//
+// Generated by command:
+// ./generate_cfg_tests cfg/windows.cfg > generated-cfg-tests-windows.cpp
+//
+// Recommended cppcheck command line:
+// $ cppcheck --enable=warning,information --inline-suppr generated-cfg-tests-windows.cpp
+// => 'unmatched suppression' warnings are false negatives.
+//
+
+void test__RtlCompareMemory__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = RtlCompareMemory(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__RtlCompareMemory__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = RtlCompareMemory(NULL, arg2, arg3);
+}
+
+void test__RtlCompareMemory__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = RtlCompareMemory(x, arg2, arg3);
+}
+
+void test__RtlCompareMemory__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = RtlCompareMemory(arg1, NULL, arg3);
+}
+
+void test__RtlCompareMemory__arg2__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__RtlCopyBytes__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RtlCopyBytes(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RtlCopyBytes__leakignore() {
+  char *p = strdup(str);
+  RtlCopyBytes(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__RtlCopyBytes__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  RtlCopyBytes(NULL, arg2, arg3);
+}
+
+void test__RtlCopyBytes__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  RtlCopyBytes(arg1, NULL, arg3);
+}
+
+void test__RtlCopyBytes__arg2__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__RtlFillBytes__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RtlFillBytes(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RtlFillBytes__leakignore() {
+  char *p = strdup(str);
+  RtlFillBytes(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RtlFillBytes(arg1, arg2, x);
+}
+
+void test__RtlSecureZeroMemory__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RtlSecureZeroMemory(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RtlSecureZeroMemory__leakignore() {
+  char *p = strdup(str);
+  RtlSecureZeroMemory(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__RtlSecureZeroMemory__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  RtlSecureZeroMemory(NULL, arg2);
+}
+
+void test__RtlSecureZeroMemory__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  RtlSecureZeroMemory(arg1, !x);
+}
+
+void test__RtlZeroBytes__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RtlZeroBytes(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RtlZeroBytes__leakignore() {
+  char *p = strdup(str);
+  RtlZeroBytes(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__RtlZeroBytes__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  RtlZeroBytes(NULL, arg2);
+}
+
+void test__RtlZeroBytes__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  RtlZeroBytes(arg1, !x);
+}
+
+void test__KeBugCheck__noreturn() {
+  int x = 100;
+  if (cond) x=1; else KeBugCheck();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__KeBugCheckEx__noreturn() {
+  int x = 100;
+  if (cond) x=1; else KeBugCheckEx();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CString__Format__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CString::Format(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CString__Format__leakignore() {
+  char *p = strdup(str);
+  CString::Format(p);
+  // cppcheck-suppress memleak
+}
+
+void test__CString__Format__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CString::Format(x);
+}
+
+void test__CString__AppendFormat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CString::AppendFormat(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CString__AppendFormat__leakignore() {
+  char *p = strdup(str);
+  CString::AppendFormat(p);
+  // cppcheck-suppress memleak
+}
+
+void test__CString__AppendFormat__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CString::AppendFormat(x);
+}
+
+void test__printf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else printf_s(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__printf_s__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else wprintf_s(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wprintf_s__leakignore() {
+  char *p = strdup(str);
+  wprintf_s(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wprintf_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wprintf_s(NULL);
+}
+
+void test__wprintf_s__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wprintf_s(x);
+}
+
+void test__fprintf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fprintf_s(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fprintf_s__leakignore() {
+  char *p = strdup(str);
+  fprintf_s(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fprintf_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fprintf_s(arg1, NULL);
+}
+
+void test__fprintf_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fprintf_s(arg1, x);
+}
+
+void test__fwprintf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fwprintf_s(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fwprintf_s__leakignore() {
+  char *p = strdup(str);
+  fwprintf_s(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__fwprintf_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fwprintf_s(arg1, NULL);
+}
+
+void test__fwprintf_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fwprintf_s(arg1, x);
+}
+
+void test___snprintf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _snprintf_s(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___snprintf_s__leakignore() {
+  char *p = strdup(str);
+  _snprintf_s(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___snprintf_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _snprintf_s(arg1, arg2, arg3, NULL);
+}
+
+void test___snprintf_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _snprintf_s(arg1, arg2, arg3, x);
+}
+
+void test___snwprintf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _snwprintf_s(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___snwprintf_s__leakignore() {
+  char *p = strdup(str);
+  _snwprintf_s(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___snwprintf_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _snwprintf_s(arg1, arg2, arg3, NULL);
+}
+
+void test___snwprintf_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _snwprintf_s(arg1, arg2, arg3, x);
+}
+
+void test__DbgPrint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else DbgPrint(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__DbgPrint__leakignore() {
+  char *p = strdup(str);
+  DbgPrint(p);
+  // cppcheck-suppress memleak
+}
+
+void test__DbgPrint__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DbgPrint(NULL);
+}
+
+void test__DbgPrint__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DbgPrint(x);
+}
+
+void test__DbgPrintEx__noreturn() {
+  int x = 100;
+  if (cond) x=1; else DbgPrintEx(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__DbgPrintEx__leakignore() {
+  char *p = strdup(str);
+  DbgPrintEx(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__DbgPrintEx__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  DbgPrintEx(arg1, arg2, NULL);
+}
+
+void test__DbgPrintEx__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DbgPrintEx(arg1, arg2, x);
+}
+
+void test__vDbgPrintEx__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vDbgPrintEx(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vDbgPrintEx__leakignore() {
+  char *p = strdup(str);
+  vDbgPrintEx(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__vDbgPrintEx__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  vDbgPrintEx(arg1, arg2, NULL);
+}
+
+void test__vDbgPrintEx__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vDbgPrintEx(arg1, arg2, x);
+}
+
+void test__vDbgPrintExWithPrefix__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vDbgPrintExWithPrefix(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vDbgPrintExWithPrefix__leakignore() {
+  char *p = strdup(str);
+  vDbgPrintExWithPrefix(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__vDbgPrintExWithPrefix__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  vDbgPrintExWithPrefix(arg1, arg2, arg3, NULL);
+}
+
+void test__vDbgPrintExWithPrefix__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vDbgPrintExWithPrefix(arg1, arg2, arg3, x);
+}
+
+void test__scanf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else scanf_s(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__scanf_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  scanf_s(NULL);
+}
+
+void test__scanf_s__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  scanf_s(x);
+}
+
+void test__wscanf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wscanf_s(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wscanf_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wscanf_s(NULL);
+}
+
+void test__wscanf_s__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wscanf_s(x);
+}
+
+void test__sscanf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sscanf_s(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sscanf_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  sscanf_s(arg1, NULL);
+}
+
+void test__sscanf_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  sscanf_s(arg1, x);
+}
+
+void test__fscanf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fscanf_s(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fscanf_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fscanf_s(arg1, NULL);
+}
+
+void test__fscanf_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fscanf_s(arg1, x);
+}
+
+void test__fwscanf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else fwscanf_s(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__fwscanf_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  fwscanf_s(arg1, NULL);
+}
+
+void test__fwscanf_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  fwscanf_s(arg1, x);
+}
+
+void test__swscanf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else swscanf_s(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 = 100;
+  if (cond) x=1; else CloseHandle(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CloseHandle__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CloseHandle(x);
+}
+
+void test__OpenFile__noreturn() {
+  int x = 100;
+  if (cond) x=1; else OpenFile(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__OpenFile__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenFile(NULL, arg2, arg3);
+}
+
+void test__OpenFile__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenFile(x, arg2, arg3);
+}
+
+void test__OpenFile__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenFile(arg1, arg2, x);
+}
+
+void test__BuildCommDCB__noreturn() {
+  int x = 100;
+  if (cond) x=1; else BuildCommDCB(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__BuildCommDCB__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  BuildCommDCB(x, arg2);
+}
+
+void test__BuildCommDCBAndTimeouts__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__WriteFile__noreturn() {
+  int x = 100;
+  if (cond) x=1; else WriteFile(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__WriteFile__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WriteFile(x, arg2, arg3, arg4, arg5);
+}
+
+void test__WriteFile__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WriteFile(arg1, x, arg3, arg4, arg5);
+}
+
+void test__WriteFile__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WriteFile(arg1, arg2, x, arg4, arg5);
+}
+
+void test__ReadFile__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ReadFile(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ReadFile__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ReadFile(x, arg2, arg3, arg4, arg5);
+}
+
+void test__ReadFile__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  ReadFile(arg1, NULL, arg3, arg4, arg5);
+}
+
+void test__ReadFile__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ReadFile(arg1, arg2, x, arg4, arg5);
+}
+
+void test__CreateFile__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateFile(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateFile__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateFile(x, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+
+void test__CreateFile__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateFile(arg1, x, arg3, arg4, arg5, arg6, arg7);
+}
+
+void test__CreateFile__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateFile(arg1, arg2, x, arg4, arg5, arg6, arg7);
+}
+
+void test__CreateFile__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateFile(arg1, arg2, arg3, x, arg5, arg6, arg7);
+}
+
+void test__CreateFile__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateFile(arg1, arg2, arg3, arg4, x, arg6, arg7);
+}
+
+void test__CreateFile__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateFile(arg1, arg2, arg3, arg4, arg5, x, arg7);
+}
+
+void test__CreateFile__arg7__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateFile(arg1, arg2, arg3, arg4, arg5, arg6, x);
+}
+
+void test__SetCommTimeouts__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetCommTimeouts(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetCommTimeouts__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetCommTimeouts(x, arg2);
+}
+
+void test__SetCommTimeouts__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetCommTimeouts(arg1, x);
+}
+
+void test__SetCommState__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetCommState(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetCommState__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetCommState(x, arg2);
+}
+
+void test__SetCommState__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetCommState(arg1, x);
+}
+
+void test___mbstok__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _mbstok(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___mbstok__leakignore() {
+  char *p = strdup(str);
+  _mbstok(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___mbstok__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbstok(x, arg2);
+}
+
+void test___mbstok__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbstok(arg1, NULL);
+}
+
+void test___mbstok__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbstok(arg1, x);
+}
+
+void test___tcstok__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tcstok(arg1, arg2);
+  // 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__leakignore() {
+  char *p = strdup(str);
+  _tcstok(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___tcstok__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcstok(x, arg2);
+}
+
+void test___tcstok__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcstok(arg1, NULL);
+}
+
+void test___tcstok__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcstok(arg1, x);
+}
+
+void test___mbstok_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _mbstok_l(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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___mbstok_l__leakignore() {
+  char *p = strdup(str);
+  _mbstok_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___mbstok_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbstok_l(x, arg2, arg3);
+}
+
+void test___mbstok_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbstok_l(arg1, NULL, arg3);
+}
+
+void test___mbstok_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbstok_l(arg1, x, arg3);
+}
+
+void test___mbstok_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbstok_l(arg1, arg2, x);
+}
+
+void test___strtok_s_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _strtok_s_l(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+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_l__leakignore() {
+  char *p = strdup(str);
+  _strtok_s_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___strtok_s_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strtok_s_l(x, arg2, arg3, arg4);
+}
+
+void test___strtok_s_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _strtok_s_l(arg1, NULL, arg3, arg4);
+}
+
+void test___strtok_s_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _strtok_s_l(arg1, x, arg3, arg4);
+}
+
+void test___strtok_s_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _strtok_s_l(arg1, arg2, NULL, arg4);
+}
+
+void test___strtok_s_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strtok_s_l(arg1, arg2, arg3, x);
+}
+
+void test___wcstok_s_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wcstok_s_l(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wcstok_s_l__pure(int arg1,int arg2,int arg3,int arg4) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_wcstok_s_l(arg1, arg2, arg3, arg4) > 10) || (_wcstok_s_l(arg1, arg2, arg3, arg4) < 100)) {}
+}
+
+void test___wcstok_s_l__leakignore() {
+  char *p = strdup(str);
+  _wcstok_s_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___wcstok_s_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcstok_s_l(x, arg2, arg3, arg4);
+}
+
+void test___wcstok_s_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcstok_s_l(arg1, NULL, arg3, arg4);
+}
+
+void test___wcstok_s_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcstok_s_l(arg1, x, arg3, arg4);
+}
+
+void test___wcstok_s_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcstok_s_l(arg1, arg2, NULL, arg4);
+}
+
+void test___wcstok_s_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcstok_s_l(arg1, arg2, arg3, x);
+}
+
+void test___mbstok_s_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _mbstok_s_l(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbstok_s_l__pure(int arg1,int arg2,int arg3,int arg4) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_mbstok_s_l(arg1, arg2, arg3, arg4) > 10) || (_mbstok_s_l(arg1, arg2, arg3, arg4) < 100)) {}
+}
+
+void test___mbstok_s_l__leakignore() {
+  char *p = strdup(str);
+  _mbstok_s_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___mbstok_s_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbstok_s_l(x, arg2, arg3, arg4);
+}
+
+void test___mbstok_s_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbstok_s_l(arg1, NULL, arg3, arg4);
+}
+
+void test___mbstok_s_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbstok_s_l(arg1, x, arg3, arg4);
+}
+
+void test___mbstok_s_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbstok_s_l(arg1, arg2, NULL, arg4);
+}
+
+void test___mbstok_s_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbstok_s_l(arg1, arg2, arg3, x);
+}
+
+void test___tcstok_s_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tcstok_s_l(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcstok_s_l__pure(int arg1,int arg2,int arg3,int arg4) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_tcstok_s_l(arg1, arg2, arg3, arg4) > 10) || (_tcstok_s_l(arg1, arg2, arg3, arg4) < 100)) {}
+}
+
+void test___tcstok_s_l__leakignore() {
+  char *p = strdup(str);
+  _tcstok_s_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___tcstok_s_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcstok_s_l(x, arg2, arg3, arg4);
+}
+
+void test___tcstok_s_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcstok_s_l(arg1, NULL, arg3, arg4);
+}
+
+void test___tcstok_s_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcstok_s_l(arg1, x, arg3, arg4);
+}
+
+void test___tcstok_s_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcstok_s_l(arg1, arg2, NULL, arg4);
+}
+
+void test___tcstok_s_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcstok_s_l(arg1, arg2, arg3, x);
+}
+
+void test__strtok_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strtok_s(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strtok_s__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((strtok_s(arg1, arg2, arg3) > 10) || (strtok_s(arg1, arg2, arg3) < 100)) {}
+}
+
+void test__strtok_s__leakignore() {
+  char *p = strdup(str);
+  strtok_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__strtok_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strtok_s(x, arg2, arg3);
+}
+
+void test__strtok_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  strtok_s(arg1, NULL, arg3);
+}
+
+void test__strtok_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strtok_s(arg1, x, arg3);
+}
+
+void test__strtok_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  strtok_s(arg1, arg2, NULL);
+}
+
+void test__wcstok_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcstok_s(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcstok_s__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((wcstok_s(arg1, arg2, arg3) > 10) || (wcstok_s(arg1, arg2, arg3) < 100)) {}
+}
+
+void test__wcstok_s__leakignore() {
+  char *p = strdup(str);
+  wcstok_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcstok_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcstok_s(x, arg2, arg3);
+}
+
+void test__wcstok_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstok_s(arg1, NULL, arg3);
+}
+
+void test__wcstok_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcstok_s(arg1, x, arg3);
+}
+
+void test__wcstok_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  wcstok_s(arg1, arg2, NULL);
+}
+
+void test___mbstok_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _mbstok_s(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbstok_s__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_mbstok_s(arg1, arg2, arg3) > 10) || (_mbstok_s(arg1, arg2, arg3) < 100)) {}
+}
+
+void test___mbstok_s__leakignore() {
+  char *p = strdup(str);
+  _mbstok_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___mbstok_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbstok_s(x, arg2, arg3);
+}
+
+void test___mbstok_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbstok_s(arg1, NULL, arg3);
+}
+
+void test___mbstok_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbstok_s(arg1, x, arg3);
+}
+
+void test___mbstok_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbstok_s(arg1, arg2, NULL);
+}
+
+void test___tcstok_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tcstok_s(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcstok_s__pure(int arg1,int arg2,int arg3) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_tcstok_s(arg1, arg2, arg3) > 10) || (_tcstok_s(arg1, arg2, arg3) < 100)) {}
+}
+
+void test___tcstok_s__leakignore() {
+  char *p = strdup(str);
+  _tcstok_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___tcstok_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcstok_s(x, arg2, arg3);
+}
+
+void test___tcstok_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcstok_s(arg1, NULL, arg3);
+}
+
+void test___tcstok_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcstok_s(arg1, x, arg3);
+}
+
+void test___tcstok_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcstok_s(arg1, arg2, NULL);
+}
+
+void test___getcwd__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _getcwd(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___getcwd__leakignore() {
+  char *p = strdup(str);
+  _getcwd(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___getcwd__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _getcwd(x, arg2);
+}
+
+void test___getcwd__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _getcwd(arg1, x);
+}
+
+void test___wgetcwd__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wgetcwd(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wgetcwd__leakignore() {
+  char *p = strdup(str);
+  _wgetcwd(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___wgetcwd__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wgetcwd(x, arg2);
+}
+
+void test___wgetcwd__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wgetcwd(arg1, x);
+}
+
+void test__SHGetFolderPath__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SHGetFolderPath(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SHGetFolderPath__leakignore() {
+  char *p = strdup(str);
+  SHGetFolderPath(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__SHGetFolderPath__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPath(x, arg2, arg3, arg4, arg5);
+}
+
+void test__SHGetFolderPath__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPath(arg1, x, arg3, arg4, arg5);
+}
+
+void test__SHGetFolderPath__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPath(arg1, arg2, x, arg4, arg5);
+}
+
+void test__SHGetFolderPath__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPath(arg1, arg2, arg3, x, arg5);
+}
+
+void test__SHGetFolderPath__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  SHGetFolderPath(arg1, arg2, arg3, arg4, NULL);
+}
+
+void test__SHGetFolderPathA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SHGetFolderPathA(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SHGetFolderPathA__leakignore() {
+  char *p = strdup(str);
+  SHGetFolderPathA(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__SHGetFolderPathA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathA(x, arg2, arg3, arg4, arg5);
+}
+
+void test__SHGetFolderPathA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathA(arg1, x, arg3, arg4, arg5);
+}
+
+void test__SHGetFolderPathA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathA(arg1, arg2, x, arg4, arg5);
+}
+
+void test__SHGetFolderPathA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathA(arg1, arg2, arg3, x, arg5);
+}
+
+void test__SHGetFolderPathA__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  SHGetFolderPathA(arg1, arg2, arg3, arg4, NULL);
+}
+
+void test__SHGetFolderPathW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SHGetFolderPathW(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SHGetFolderPathW__leakignore() {
+  char *p = strdup(str);
+  SHGetFolderPathW(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__SHGetFolderPathW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathW(x, arg2, arg3, arg4, arg5);
+}
+
+void test__SHGetFolderPathW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathW(arg1, x, arg3, arg4, arg5);
+}
+
+void test__SHGetFolderPathW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathW(arg1, arg2, x, arg4, arg5);
+}
+
+void test__SHGetFolderPathW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SHGetFolderPathW(arg1, arg2, arg3, x, arg5);
+}
+
+void test__SHGetFolderPathW__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  SHGetFolderPathW(arg1, arg2, arg3, arg4, NULL);
+}
+
+void test__RegQueryValueEx__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RegQueryValueEx(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RegQueryValueEx__leakignore() {
+  char *p = strdup(str);
+  RegQueryValueEx(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__RegQueryValueEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueEx(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__RegQueryValueEx__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueEx(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__RegQueryValueEx__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueEx(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__RegQueryValueExA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RegQueryValueExA(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RegQueryValueExA__leakignore() {
+  char *p = strdup(str);
+  RegQueryValueExA(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__RegQueryValueExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueExA(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__RegQueryValueExA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueExA(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__RegQueryValueExA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueExA(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__RegQueryValueExW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RegQueryValueExW(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RegQueryValueExW__leakignore() {
+  char *p = strdup(str);
+  RegQueryValueExW(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__RegQueryValueExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueExW(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__RegQueryValueExW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueExW(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__RegQueryValueExW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegQueryValueExW(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__RegCloseKey__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RegCloseKey(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RegCloseKey__leakignore() {
+  char *p = strdup(str);
+  RegCloseKey(p);
+  // cppcheck-suppress memleak
+}
+
+void test__RegCloseKey__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegCloseKey(x);
+}
+
+void test___stricmp_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _stricmp_l(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___stricmp_l__leakignore() {
+  char *p = strdup(str);
+  _stricmp_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___stricmp_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stricmp_l(NULL, arg2, arg3);
+}
+
+void test___stricmp_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stricmp_l(x, arg2, arg3);
+}
+
+void test___stricmp_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stricmp_l(arg1, NULL, arg3);
+}
+
+void test___stricmp_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stricmp_l(arg1, x, arg3);
+}
+
+void test___stricmp_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _stricmp_l(arg1, arg2, x);
+}
+
+void test___wcsicmp_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wcsicmp_l(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wcsicmp_l__leakignore() {
+  char *p = strdup(str);
+  _wcsicmp_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___wcsicmp_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsicmp_l(NULL, arg2, arg3);
+}
+
+void test___wcsicmp_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsicmp_l(x, arg2, arg3);
+}
+
+void test___wcsicmp_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsicmp_l(arg1, NULL, arg3);
+}
+
+void test___wcsicmp_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsicmp_l(arg1, x, arg3);
+}
+
+void test___wcsicmp_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsicmp_l(arg1, arg2, x);
+}
+
+void test___mbsicmp_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _mbsicmp_l(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbsicmp_l__leakignore() {
+  char *p = strdup(str);
+  _mbsicmp_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___mbsicmp_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsicmp_l(NULL, arg2, arg3);
+}
+
+void test___mbsicmp_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsicmp_l(x, arg2, arg3);
+}
+
+void test___mbsicmp_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsicmp_l(arg1, NULL, arg3);
+}
+
+void test___mbsicmp_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsicmp_l(arg1, x, arg3);
+}
+
+void test___mbsicmp_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbsicmp_l(arg1, arg2, x);
+}
+
+void test__stricmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else stricmp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__stricmp__leakignore() {
+  char *p = strdup(str);
+  stricmp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__stricmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  stricmp(NULL, arg2);
+}
+
+void test__stricmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  stricmp(x, arg2);
+}
+
+void test__stricmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  stricmp(arg1, NULL);
+}
+
+void test__stricmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  stricmp(arg1, x);
+}
+
+void test___stricmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _stricmp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___stricmp__leakignore() {
+  char *p = strdup(str);
+  _stricmp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___stricmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stricmp(NULL, arg2);
+}
+
+void test___stricmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stricmp(x, arg2);
+}
+
+void test___stricmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stricmp(arg1, NULL);
+}
+
+void test___stricmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stricmp(arg1, x);
+}
+
+void test__wcsicmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcsicmp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcsicmp__leakignore() {
+  char *p = strdup(str);
+  wcsicmp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcsicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsicmp(NULL, arg2);
+}
+
+void test__wcsicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsicmp(x, arg2);
+}
+
+void test__wcsicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wcsicmp(arg1, NULL);
+}
+
+void test__wcsicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcsicmp(arg1, x);
+}
+
+void test___wcsicmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wcsicmp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wcsicmp__leakignore() {
+  char *p = strdup(str);
+  _wcsicmp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___wcsicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsicmp(NULL, arg2);
+}
+
+void test___wcsicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsicmp(x, arg2);
+}
+
+void test___wcsicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsicmp(arg1, NULL);
+}
+
+void test___wcsicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsicmp(arg1, x);
+}
+
+void test___mbsicmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _mbsicmp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbsicmp__leakignore() {
+  char *p = strdup(str);
+  _mbsicmp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___mbsicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsicmp(NULL, arg2);
+}
+
+void test___mbsicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsicmp(x, arg2);
+}
+
+void test___mbsicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsicmp(arg1, NULL);
+}
+
+void test___mbsicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsicmp(arg1, x);
+}
+
+void test___tcsicmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tcsicmp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcsicmp__leakignore() {
+  char *p = strdup(str);
+  _tcsicmp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___tcsicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsicmp(NULL, arg2);
+}
+
+void test___tcsicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsicmp(x, arg2);
+}
+
+void test___tcsicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsicmp(arg1, NULL);
+}
+
+void test___tcsicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsicmp(arg1, x);
+}
+
+void test__GetFileAttributes__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetFileAttributes(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetFileAttributes__leakignore() {
+  char *p = strdup(str);
+  GetFileAttributes(p);
+  // cppcheck-suppress memleak
+}
+
+void test__GetFileAttributes__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetFileAttributes(x);
+}
+
+void test__GetFileAttributesA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetFileAttributesA(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetFileAttributesA__leakignore() {
+  char *p = strdup(str);
+  GetFileAttributesA(p);
+  // cppcheck-suppress memleak
+}
+
+void test__GetFileAttributesA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetFileAttributesA(x);
+}
+
+void test__GetFileAttributesW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetFileAttributesW(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetFileAttributesW__leakignore() {
+  char *p = strdup(str);
+  GetFileAttributesW(p);
+  // cppcheck-suppress memleak
+}
+
+void test__GetFileAttributesW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetFileAttributesW(x);
+}
+
+void test__RegOpenKeyEx__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RegOpenKeyEx(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RegOpenKeyEx__leakignore() {
+  char *p = strdup(str);
+  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__RegOpenKeyEx__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyEx(arg1, arg2, arg3, x, arg5);
+}
+
+void test__RegOpenKeyExA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RegOpenKeyExA(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RegOpenKeyExA__leakignore() {
+  char *p = strdup(str);
+  RegOpenKeyExA(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__RegOpenKeyExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyExA(x, arg2, arg3, arg4, arg5);
+}
+
+void test__RegOpenKeyExA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyExA(arg1, arg2, x, arg4, arg5);
+}
+
+void test__RegOpenKeyExA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyExA(arg1, arg2, arg3, x, arg5);
+}
+
+void test__RegOpenKeyExW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RegOpenKeyExW(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RegOpenKeyExW__leakignore() {
+  char *p = strdup(str);
+  RegOpenKeyExW(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__RegOpenKeyExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyExW(x, arg2, arg3, arg4, arg5);
+}
+
+void test__RegOpenKeyExW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyExW(arg1, arg2, x, arg4, arg5);
+}
+
+void test__RegOpenKeyExW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegOpenKeyExW(arg1, arg2, arg3, x, arg5);
+}
+
+void test__wsprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wsprintf(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wsprintf__leakignore() {
+  char *p = strdup(str);
+  wsprintf(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wsprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wsprintf(x, arg2);
+}
+
+void test__wsprintf__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wsprintf(arg1, NULL);
+}
+
+void test__wsprintf__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wsprintf(arg1, x);
+}
+
+void test__wsprintfA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wsprintfA(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wsprintfA__leakignore() {
+  char *p = strdup(str);
+  wsprintfA(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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__wsprintfA__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wsprintfA(arg1, x);
+}
+
+void test__wsprintfW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wsprintfW(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wsprintfW__leakignore() {
+  char *p = strdup(str);
+  wsprintfW(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wsprintfW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wsprintfW(x, arg2);
+}
+
+void test__wsprintfW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wsprintfW(arg1, NULL);
+}
+
+void test__wsprintfW__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wsprintfW(arg1, x);
+}
+
+void test__sprintf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sprintf_s();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sprintf_s__leakignore() {
+  char *p = strdup(str);
+  sprintf_s();
+  // cppcheck-suppress memleak
+}
+
+void test__swprintf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else swprintf_s();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__swprintf_s__leakignore() {
+  char *p = strdup(str);
+  swprintf_s();
+  // cppcheck-suppress memleak
+}
+
+void test___sprintf_s_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _sprintf_s_l(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___sprintf_s_l__leakignore() {
+  char *p = strdup(str);
+  _sprintf_s_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___sprintf_s_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _sprintf_s_l(arg1, x, arg3, arg4);
+}
+
+void test___sprintf_s_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _sprintf_s_l(arg1, arg2, NULL, arg4);
+}
+
+void test___sprintf_s_l__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _sprintf_s_l(arg1, arg2, x, arg4);
+}
+
+void test___sprintf_s_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _sprintf_s_l(arg1, arg2, arg3, x);
+}
+
+void test___swprintf_s_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _swprintf_s_l(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___swprintf_s_l__leakignore() {
+  char *p = strdup(str);
+  _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___swprintf_s_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _swprintf_s_l(arg1, arg2, NULL, arg4);
+}
+
+void test___swprintf_s_l__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _swprintf_s_l(arg1, arg2, x, arg4);
+}
+
+void test___swprintf_s_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _swprintf_s_l(arg1, arg2, arg3, x);
+}
+
+void test__RegEnumKeyEx__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RegEnumKeyEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RegEnumKeyEx__leakignore() {
+  char *p = strdup(str);
+  RegEnumKeyEx(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+  // cppcheck-suppress memleak
+}
+
+void test__RegEnumKeyEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegEnumKeyEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+}
+
+void test__RegEnumKeyEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegEnumKeyEx(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
+}
+
+void test__RegEnumKeyExA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RegEnumKeyExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RegEnumKeyExA__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else RegEnumKeyExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RegEnumKeyExW__leakignore() {
+  char *p = strdup(str);
+  RegEnumKeyExW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+  // cppcheck-suppress memleak
+}
+
+void test__RegEnumKeyExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RegEnumKeyExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+}
+
+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 = 100;
+  if (cond) x=1; else CreateFont(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CaptureStackBackTrace__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CaptureStackBackTrace(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CaptureStackBackTrace__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CaptureStackBackTrace(x, arg2, arg3, arg4);
+}
+
+void test__CaptureStackBackTrace__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CaptureStackBackTrace(arg1, x, arg3, arg4);
+}
+
+void test___vsnprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _vsnprintf(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___vsnprintf__leakignore() {
+  char *p = strdup(str);
+  _vsnprintf(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___vsnprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf(x, arg2, arg3, arg4);
+}
+
+void test___vsnprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf(arg1, x, arg3, arg4);
+}
+
+void test___vsnprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnprintf(arg1, arg2, NULL, arg4);
+}
+
+void test___vsnprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vsnprintf(arg1, arg2, x, arg4);
+}
+
+void test___vsnwprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _vsnwprintf(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___vsnwprintf__leakignore() {
+  char *p = strdup(str);
+  _vsnwprintf(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___vsnwprintf__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf(x, arg2, arg3, arg4);
+}
+
+void test___vsnwprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf(arg1, x, arg3, arg4);
+}
+
+void test___vsnwprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnwprintf(arg1, arg2, NULL, arg4);
+}
+
+void test___vsnwprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vsnwprintf(arg1, arg2, x, arg4);
+}
+
+void test___vsnprintf_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _vsnprintf_l(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___vsnprintf_l__leakignore() {
+  char *p = strdup(str);
+  _vsnprintf_l(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test___vsnprintf_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_l(x, arg2, arg3, arg4, arg5);
+}
+
+void test___vsnprintf_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_l(arg1, x, arg3, arg4, arg5);
+}
+
+void test___vsnprintf_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnprintf_l(arg1, arg2, NULL, arg4, arg5);
+}
+
+void test___vsnprintf_l__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vsnprintf_l(arg1, arg2, x, arg4, arg5);
+}
+
+void test___vsnprintf_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_l(arg1, arg2, arg3, x, arg5);
+}
+
+void test___vsnwprintf_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _vsnwprintf_l(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___vsnwprintf_l__leakignore() {
+  char *p = strdup(str);
+  _vsnwprintf_l(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test___vsnwprintf_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_l(x, arg2, arg3, arg4, arg5);
+}
+
+void test___vsnwprintf_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_l(arg1, x, arg3, arg4, arg5);
+}
+
+void test___vsnwprintf_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnwprintf_l(arg1, arg2, NULL, arg4, arg5);
+}
+
+void test___vsnwprintf_l__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_l(arg1, arg2, x, arg4, arg5);
+}
+
+void test___vsnwprintf_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_l(arg1, arg2, arg3, x, arg5);
+}
+
+void test___vswprintf_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _vswprintf_l(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___vswprintf_l__leakignore() {
+  char *p = strdup(str);
+  _vswprintf_l(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test___vswprintf_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vswprintf_l(x, arg2, arg3, arg4, arg5);
+}
+
+void test___vswprintf_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vswprintf_l(arg1, x, arg3, arg4, arg5);
+}
+
+void test___vswprintf_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _vswprintf_l(arg1, arg2, NULL, arg4, arg5);
+}
+
+void test___vswprintf_l__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vswprintf_l(arg1, arg2, x, arg4, arg5);
+}
+
+void test___vswprintf_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vswprintf_l(arg1, arg2, arg3, x, arg5);
+}
+
+void test__vsnprintf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else vsnprintf_s(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__vsnprintf_s__leakignore() {
+  char *p = strdup(str);
+  vsnprintf_s(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__vsnprintf_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vsnprintf_s(x, arg2, arg3, arg4, arg5);
+}
+
+void test__vsnprintf_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vsnprintf_s(arg1, x, arg3, arg4, arg5);
+}
+
+void test__vsnprintf_s__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  vsnprintf_s(arg1, arg2, x, arg4, arg5);
+}
+
+void test__vsnprintf_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  vsnprintf_s(arg1, arg2, arg3, NULL, arg5);
+}
+
+void test__vsnprintf_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  vsnprintf_s(arg1, arg2, arg3, x, arg5);
+}
+
+void test___vsnprintf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _vsnprintf_s(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___vsnprintf_s__leakignore() {
+  char *p = strdup(str);
+  _vsnprintf_s(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test___vsnprintf_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_s(x, arg2, arg3, arg4, arg5);
+}
+
+void test___vsnprintf_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_s(arg1, x, arg3, arg4, arg5);
+}
+
+void test___vsnprintf_s__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_s(arg1, arg2, x, arg4, arg5);
+}
+
+void test___vsnprintf_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnprintf_s(arg1, arg2, arg3, NULL, arg5);
+}
+
+void test___vsnprintf_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vsnprintf_s(arg1, arg2, arg3, x, arg5);
+}
+
+void test___vsnwprintf_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _vsnwprintf_s(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___vsnwprintf_s__leakignore() {
+  char *p = strdup(str);
+  _vsnwprintf_s(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test___vsnwprintf_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s(x, arg2, arg3, arg4, arg5);
+}
+
+void test___vsnwprintf_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s(arg1, x, arg3, arg4, arg5);
+}
+
+void test___vsnwprintf_s__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s(arg1, arg2, x, arg4, arg5);
+}
+
+void test___vsnwprintf_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnwprintf_s(arg1, arg2, arg3, NULL, arg5);
+}
+
+void test___vsnwprintf_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s(arg1, arg2, arg3, x, arg5);
+}
+
+void test___vsnprintf_s_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _vsnprintf_s_l(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___vsnprintf_s_l__leakignore() {
+  char *p = strdup(str);
+  _vsnprintf_s_l(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+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_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_s_l(arg1, x, arg3, arg4, arg5, arg6);
+}
+
+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_l__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnprintf_s_l(arg1, arg2, arg3, NULL, arg5, arg6);
+}
+
+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_l__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnprintf_s_l(arg1, arg2, arg3, arg4, x, arg6);
+}
+
+void test___vsnwprintf_s_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _vsnwprintf_s_l(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___vsnwprintf_s_l__leakignore() {
+  char *p = strdup(str);
+  _vsnwprintf_s_l(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test___vsnwprintf_s_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s_l(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test___vsnwprintf_s_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s_l(arg1, x, arg3, arg4, arg5, arg6);
+}
+
+void test___vsnwprintf_s_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s_l(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test___vsnwprintf_s_l__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsnwprintf_s_l(arg1, arg2, arg3, NULL, arg5, arg6);
+}
+
+void test___vsnwprintf_s_l__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s_l(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test___vsnwprintf_s_l__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsnwprintf_s_l(arg1, arg2, arg3, arg4, x, arg6);
+}
+
+void test___vsprintf_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _vsprintf_l(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___vsprintf_l__leakignore() {
+  char *p = strdup(str);
+  _vsprintf_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___vsprintf_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsprintf_l(NULL, arg2, arg3, arg4);
+}
+
+void test___vsprintf_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _vsprintf_l(arg1, NULL, arg3, arg4);
+}
+
+void test___vsprintf_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _vsprintf_l(arg1, arg2, x, arg4);
+}
+
+void test____vswprintf_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else __vswprintf_l(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test____vswprintf_l__leakignore() {
+  char *p = strdup(str);
+  __vswprintf_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test____vswprintf_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  __vswprintf_l(NULL, arg2, arg3, arg4);
+}
+
+void test____vswprintf_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  __vswprintf_l(arg1, NULL, arg3, arg4);
+}
+
+void test____vswprintf_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  __vswprintf_l(arg1, arg2, x, arg4);
+}
+
+void test___strdup__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _strdup(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___strdup__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _strdup(NULL);
+}
+
+void test___strdup__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _strdup(x);
+}
+
+void test___wcsdup__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wcsdup(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wcsdup__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsdup(NULL);
+}
+
+void test___wcsdup__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsdup(x);
+}
+
+void test___mbsdup__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _mbsdup(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbsdup__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsdup(NULL);
+}
+
+void test___mbsdup__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsdup(x);
+}
+
+void test___tcsdup__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tcsdup(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcsdup__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsdup(NULL);
+}
+
+void test___tcsdup__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsdup(x);
+}
+
+void test___strdup_dbg__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _strdup_dbg(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___strdup_dbg__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _strdup_dbg(NULL, arg2, arg3, arg4);
+}
+
+void test___strdup_dbg__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _strdup_dbg(x, arg2, arg3, arg4);
+}
+
+void test___strdup_dbg__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strdup_dbg(arg1, x, arg3, arg4);
+}
+
+void test___strdup_dbg__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strdup_dbg(arg1, arg2, x, arg4);
+}
+
+void test___strdup_dbg__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strdup_dbg(arg1, arg2, arg3, x);
+}
+
+void test___wcsdup_dbg__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wcsdup_dbg(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wcsdup_dbg__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsdup_dbg(NULL, arg2, arg3, arg4);
+}
+
+void test___wcsdup_dbg__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsdup_dbg(x, arg2, arg3, arg4);
+}
+
+void test___wcsdup_dbg__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsdup_dbg(arg1, x, arg3, arg4);
+}
+
+void test___wcsdup_dbg__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsdup_dbg(arg1, arg2, x, arg4);
+}
+
+void test___wcsdup_dbg__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsdup_dbg(arg1, arg2, arg3, x);
+}
+
+void test___tcsdup_dbg__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tcsdup_dbg(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcsdup_dbg__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsdup_dbg(NULL, arg2, arg3, arg4);
+}
+
+void test___tcsdup_dbg__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsdup_dbg(x, arg2, arg3, arg4);
+}
+
+void test___tcsdup_dbg__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcsdup_dbg(arg1, x, arg3, arg4);
+}
+
+void test___tcsdup_dbg__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcsdup_dbg(arg1, arg2, x, arg4);
+}
+
+void test___tcsdup_dbg__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcsdup_dbg(arg1, arg2, arg3, x);
+}
+
+void test___mbscmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mbscmp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbscmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbscmp(arg1, arg2);
+}
+
+void test___mbscmp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_mbscmp(arg1, arg2) > 10) || (_mbscmp(arg1, arg2) < 100)) {}
+}
+
+void test___mbscmp__leakignore() {
+  char *p = strdup(str);
+  result = _mbscmp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___mbscmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbscmp(NULL, arg2);
+}
+
+void test___mbscmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbscmp(x, arg2);
+}
+
+void test___mbscmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbscmp(arg1, NULL);
+}
+
+void test___mbscmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbscmp(arg1, x);
+}
+
+void test___tcscmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _tcscmp(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcscmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcscmp(arg1, arg2);
+}
+
+void test___tcscmp__pure(int arg1,int arg2) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_tcscmp(arg1, arg2) > 10) || (_tcscmp(arg1, arg2) < 100)) {}
+}
+
+void test___tcscmp__leakignore() {
+  char *p = strdup(str);
+  result = _tcscmp(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___tcscmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcscmp(NULL, arg2);
+}
+
+void test___tcscmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcscmp(x, arg2);
+}
+
+void test___tcscmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcscmp(arg1, NULL);
+}
+
+void test___tcscmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcscmp(arg1, x);
+}
+
+void test___snprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _snprintf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___snprintf__leakignore() {
+  char *p = strdup(str);
+  _snprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___snprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _snprintf(arg1, x, arg3);
+}
+
+void test___snprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _snprintf(arg1, arg2, NULL);
+}
+
+void test___snprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _snprintf(arg1, arg2, x);
+}
+
+void test___snwprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _snwprintf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___snwprintf__leakignore() {
+  char *p = strdup(str);
+  _snwprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___snwprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _snwprintf(arg1, x, arg3);
+}
+
+void test___snwprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _snwprintf(arg1, arg2, NULL);
+}
+
+void test___snwprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _snwprintf(arg1, arg2, x);
+}
+
+void test___sntprintf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _sntprintf(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___sntprintf__leakignore() {
+  char *p = strdup(str);
+  _sntprintf(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___sntprintf__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _sntprintf(arg1, x, arg3);
+}
+
+void test___sntprintf__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _sntprintf(arg1, arg2, NULL);
+}
+
+void test___sntprintf__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _sntprintf(arg1, arg2, x);
+}
+
+void test__strcpy_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strcpy_s(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strcpy_s__leakignore() {
+  char *p = strdup(str);
+  strcpy_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__strcpy_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strcpy_s(NULL, arg2, arg3);
+}
+
+void test__strcpy_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  strcpy_s(arg1, x, arg3);
+}
+
+void test__strcpy_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  strcpy_s(arg1, arg2, NULL);
+}
+
+void test__strcpy_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strcpy_s(arg1, arg2, x);
+}
+
+void test__wcscpy_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wcscpy_s(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcscpy_s__leakignore() {
+  char *p = strdup(str);
+  wcscpy_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__wcscpy_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wcscpy_s(NULL, arg2, arg3);
+}
+
+void test__wcscpy_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wcscpy_s(arg1, x, arg3);
+}
+
+void test__wcscpy_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  wcscpy_s(arg1, arg2, NULL);
+}
+
+void test__wcscpy_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wcscpy_s(arg1, arg2, x);
+}
+
+void test___mbscpy_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _mbscpy_s(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbscpy_s__leakignore() {
+  char *p = strdup(str);
+  _mbscpy_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___mbscpy_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbscpy_s(NULL, arg2, arg3);
+}
+
+void test___mbscpy_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbscpy_s(arg1, x, arg3);
+}
+
+void test___mbscpy_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbscpy_s(arg1, arg2, NULL);
+}
+
+void test___mbscpy_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbscpy_s(arg1, arg2, x);
+}
+
+void test___tcscpy_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tcscpy_s(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcscpy_s__leakignore() {
+  char *p = strdup(str);
+  _tcscpy_s(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___tcscpy_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcscpy_s(NULL, arg2, arg3);
+}
+
+void test___tcscpy_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcscpy_s(arg1, x, arg3);
+}
+
+void test___tcscpy_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcscpy_s(arg1, arg2, NULL);
+}
+
+void test___tcscpy_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcscpy_s(arg1, arg2, x);
+}
+
+void test___CrtSetDbgFlag__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _CrtSetDbgFlag(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___CrtSetDbgFlag__leakignore() {
+  char *p = strdup(str);
+  _CrtSetDbgFlag(p);
+  // cppcheck-suppress memleak
+}
+
+void test___CrtSetDbgFlag__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _CrtSetDbgFlag(x);
+}
+
+void test___stat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _stat(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___stat__leakignore() {
+  char *p = strdup(str);
+  _stat(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___stat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat(NULL, arg2);
+}
+
+void test___stat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stat(x, arg2);
+}
+
+void test___stat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat(arg1, NULL);
+}
+
+void test___tstat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tstat(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tstat__leakignore() {
+  char *p = strdup(str);
+  _tstat(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___tstat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat(NULL, arg2);
+}
+
+void test___tstat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tstat(x, arg2);
+}
+
+void test___tstat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat(arg1, NULL);
+}
+
+void test___stat32__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _stat32(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___stat32__leakignore() {
+  char *p = strdup(str);
+  _stat32(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___stat32__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat32(NULL, arg2);
+}
+
+void test___stat32__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stat32(x, arg2);
+}
+
+void test___stat32__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat32(arg1, NULL);
+}
+
+void test___stat64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _stat64(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___stat64__leakignore() {
+  char *p = strdup(str);
+  _stat64(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___stat64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat64(NULL, arg2);
+}
+
+void test___stat64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stat64(x, arg2);
+}
+
+void test___stat64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat64(arg1, NULL);
+}
+
+void test___tstat64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tstat64(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tstat64__leakignore() {
+  char *p = strdup(str);
+  _tstat64(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___tstat64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat64(NULL, arg2);
+}
+
+void test___tstat64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tstat64(x, arg2);
+}
+
+void test___tstat64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat64(arg1, NULL);
+}
+
+void test___stati64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _stati64(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___stati64__leakignore() {
+  char *p = strdup(str);
+  _stati64(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___stati64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stati64(NULL, arg2);
+}
+
+void test___stati64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stati64(x, arg2);
+}
+
+void test___stati64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stati64(arg1, NULL);
+}
+
+void test___tstati64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tstati64(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tstati64__leakignore() {
+  char *p = strdup(str);
+  _tstati64(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___tstati64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstati64(NULL, arg2);
+}
+
+void test___tstati64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tstati64(x, arg2);
+}
+
+void test___tstati64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstati64(arg1, NULL);
+}
+
+void test___stat32i64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _stat32i64(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___stat32i64__leakignore() {
+  char *p = strdup(str);
+  _stat32i64(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___stat32i64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat32i64(NULL, arg2);
+}
+
+void test___stat32i64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stat32i64(x, arg2);
+}
+
+void test___stat32i64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat32i64(arg1, NULL);
+}
+
+void test___tstat32i64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tstat32i64(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tstat32i64__leakignore() {
+  char *p = strdup(str);
+  _tstat32i64(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___tstat32i64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat32i64(NULL, arg2);
+}
+
+void test___tstat32i64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tstat32i64(x, arg2);
+}
+
+void test___tstat32i64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat32i64(arg1, NULL);
+}
+
+void test___stat64i32__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _stat64i32(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___stat64i32__leakignore() {
+  char *p = strdup(str);
+  _stat64i32(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___stat64i32__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat64i32(NULL, arg2);
+}
+
+void test___stat64i32__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _stat64i32(x, arg2);
+}
+
+void test___stat64i32__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _stat64i32(arg1, NULL);
+}
+
+void test___tstat64i32__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tstat64i32(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tstat64i32__leakignore() {
+  char *p = strdup(str);
+  _tstat64i32(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___tstat64i32__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat64i32(NULL, arg2);
+}
+
+void test___tstat64i32__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tstat64i32(x, arg2);
+}
+
+void test___tstat64i32__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tstat64i32(arg1, NULL);
+}
+
+void test___wstat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wstat(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wstat__leakignore() {
+  char *p = strdup(str);
+  _wstat(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___wstat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat(NULL, arg2);
+}
+
+void test___wstat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wstat(x, arg2);
+}
+
+void test___wstat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat(arg1, NULL);
+}
+
+void test___wstat32__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wstat32(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wstat32__leakignore() {
+  char *p = strdup(str);
+  _wstat32(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___wstat32__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat32(NULL, arg2);
+}
+
+void test___wstat32__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wstat32(x, arg2);
+}
+
+void test___wstat32__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat32(arg1, NULL);
+}
+
+void test___wstat64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wstat64(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wstat64__leakignore() {
+  char *p = strdup(str);
+  _wstat64(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___wstat64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat64(NULL, arg2);
+}
+
+void test___wstat64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wstat64(x, arg2);
+}
+
+void test___wstat64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat64(arg1, NULL);
+}
+
+void test___wstati64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wstati64(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wstati64__leakignore() {
+  char *p = strdup(str);
+  _wstati64(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___wstati64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstati64(NULL, arg2);
+}
+
+void test___wstati64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wstati64(x, arg2);
+}
+
+void test___wstati64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstati64(arg1, NULL);
+}
+
+void test___wstat32i64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wstat32i64(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wstat32i64__leakignore() {
+  char *p = strdup(str);
+  _wstat32i64(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___wstat32i64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat32i64(NULL, arg2);
+}
+
+void test___wstat32i64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wstat32i64(x, arg2);
+}
+
+void test___wstat32i64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat32i64(arg1, NULL);
+}
+
+void test___wstat64i32__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wstat64i32(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wstat64i32__leakignore() {
+  char *p = strdup(str);
+  _wstat64i32(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___wstat64i32__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat64i32(NULL, arg2);
+}
+
+void test___wstat64i32__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wstat64i32(x, arg2);
+}
+
+void test___wstat64i32__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wstat64i32(arg1, NULL);
+}
+
+void test___fstat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _fstat(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___fstat__leakignore() {
+  char *p = strdup(str);
+  _fstat(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___fstat__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fstat(x, arg2);
+}
+
+void test___fstat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _fstat(arg1, NULL);
+}
+
+void test___fstat32__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _fstat32(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___fstat32__leakignore() {
+  char *p = strdup(str);
+  _fstat32(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___fstat32__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fstat32(x, arg2);
+}
+
+void test___fstat32__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _fstat32(arg1, NULL);
+}
+
+void test___fstat64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _fstat64(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___fstat64__leakignore() {
+  char *p = strdup(str);
+  _fstat64(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___fstat64__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fstat64(x, arg2);
+}
+
+void test___fstat64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _fstat64(arg1, NULL);
+}
+
+void test___fstati64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _fstati64(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___fstati64__leakignore() {
+  char *p = strdup(str);
+  _fstati64(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___fstati64__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fstati64(x, arg2);
+}
+
+void test___fstati64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _fstati64(arg1, NULL);
+}
+
+void test___fstat32i64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _fstat32i64(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___fstat32i64__leakignore() {
+  char *p = strdup(str);
+  _fstat32i64(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___fstat32i64__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fstat32i64(x, arg2);
+}
+
+void test___fstat32i64__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _fstat32i64(arg1, NULL);
+}
+
+void test___fstat64i32__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _fstat64i32(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___fstat64i32__leakignore() {
+  char *p = strdup(str);
+  _fstat64i32(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___fstat64i32__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fstat64i32(x, arg2);
+}
+
+void test___fstat64i32__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _fstat64i32(arg1, NULL);
+}
+
+void test___fseeki64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _fseeki64(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___fseeki64__leakignore() {
+  char *p = strdup(str);
+  _fseeki64(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___fseeki64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _fseeki64(NULL, arg2, arg3);
+}
+
+void test___fseeki64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _fseeki64(x, arg2, arg3);
+}
+
+void test___fseeki64__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fseeki64(arg1, x, arg3);
+}
+
+void test___fseeki64__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _fseeki64(arg1, arg2, x);
+}
+
+void test___ftelli64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _ftelli64(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___ftelli64__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _ftelli64(arg1);
+}
+
+void test___ftelli64__leakignore() {
+  char *p = strdup(str);
+  result = _ftelli64(p);
+  // cppcheck-suppress memleak
+}
+
+void test___ftelli64__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _ftelli64(NULL);
+}
+
+void test___ftelli64__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _ftelli64(x);
+}
+
+void test___ftell_nolock__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _ftell_nolock(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___ftell_nolock__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _ftell_nolock(arg1);
+}
+
+void test___ftell_nolock__leakignore() {
+  char *p = strdup(str);
+  result = _ftell_nolock(p);
+  // cppcheck-suppress memleak
+}
+
+void test___ftell_nolock__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _ftell_nolock(NULL);
+}
+
+void test___ftell_nolock__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _ftell_nolock(x);
+}
+
+void test___ftelli64_nolock__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _ftelli64_nolock(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___ftelli64_nolock__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _ftelli64_nolock(arg1);
+}
+
+void test___ftelli64_nolock__leakignore() {
+  char *p = strdup(str);
+  result = _ftelli64_nolock(p);
+  // cppcheck-suppress memleak
+}
+
+void test___ftelli64_nolock__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _ftelli64_nolock(NULL);
+}
+
+void test___ftelli64_nolock__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _ftelli64_nolock(x);
+}
+
+void test___wfopen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _wfopen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wfopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _wfopen(arg1, arg2);
+}
+
+void test___wfopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wfopen(NULL, arg2);
+}
+
+void test___wfopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wfopen(x, arg2);
+}
+
+void test___wfopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wfopen(arg1, NULL);
+}
+
+void test___wfopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wfopen(arg1, x);
+}
+
+void test___tfopen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _tfopen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tfopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tfopen(arg1, arg2);
+}
+
+void test___tfopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tfopen(NULL, arg2);
+}
+
+void test___tfopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tfopen(x, arg2);
+}
+
+void test___tfopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tfopen(arg1, NULL);
+}
+
+void test___tfopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tfopen(arg1, x);
+}
+
+void test__strnlen_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = strnlen_s(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strnlen_s__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  strnlen_s(arg1, arg2);
+}
+
+void test__strnlen_s__leakignore() {
+  char *p = strdup(str);
+  result = strnlen_s(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__strnlen_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = strnlen_s(NULL, arg2);
+}
+
+void test__strnlen_s__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = strnlen_s(x, arg2);
+}
+
+void test__strnlen_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = strnlen_s(arg1, x);
+}
+
+void test__wcsnlen_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wcsnlen_s(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wcsnlen_s__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wcsnlen_s(arg1, arg2);
+}
+
+void test__wcsnlen_s__leakignore() {
+  char *p = strdup(str);
+  result = wcsnlen_s(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wcsnlen_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = wcsnlen_s(NULL, arg2);
+}
+
+void test__wcsnlen_s__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = wcsnlen_s(x, arg2);
+}
+
+void test__wcsnlen_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wcsnlen_s(arg1, x);
+}
+
+void test___mbsnlen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mbsnlen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbsnlen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsnlen(arg1, arg2);
+}
+
+void test___mbsnlen__leakignore() {
+  char *p = strdup(str);
+  result = _mbsnlen(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___mbsnlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsnlen(NULL, arg2);
+}
+
+void test___mbsnlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsnlen(x, arg2);
+}
+
+void test___mbsnlen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsnlen(arg1, x);
+}
+
+void test___mbstrnlen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mbstrnlen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbstrnlen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbstrnlen(arg1, arg2);
+}
+
+void test___mbstrnlen__leakignore() {
+  char *p = strdup(str);
+  result = _mbstrnlen(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___mbstrnlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbstrnlen(NULL, arg2);
+}
+
+void test___mbstrnlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbstrnlen(x, arg2);
+}
+
+void test___mbstrnlen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbstrnlen(arg1, x);
+}
+
+void test___mbsnlen_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mbsnlen_l(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbsnlen_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsnlen_l(arg1, arg2, arg3);
+}
+
+void test___mbsnlen_l__leakignore() {
+  char *p = strdup(str);
+  result = _mbsnlen_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___mbsnlen_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsnlen_l(NULL, arg2, arg3);
+}
+
+void test___mbsnlen_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsnlen_l(x, arg2, arg3);
+}
+
+void test___mbsnlen_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsnlen_l(arg1, x, arg3);
+}
+
+void test___mbsnlen_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsnlen_l(arg1, arg2, x);
+}
+
+void test___mbstrnlen_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mbstrnlen_l(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbstrnlen_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbstrnlen_l(arg1, arg2, arg3);
+}
+
+void test___mbstrnlen_l__leakignore() {
+  char *p = strdup(str);
+  result = _mbstrnlen_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___mbstrnlen_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbstrnlen_l(NULL, arg2, arg3);
+}
+
+void test___mbstrnlen_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbstrnlen_l(x, arg2, arg3);
+}
+
+void test___mbstrnlen_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbstrnlen_l(arg1, x, arg3);
+}
+
+void test___mbstrnlen_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbstrnlen_l(arg1, arg2, x);
+}
+
+void test__WideCharToMultiByte__noreturn() {
+  int x = 100;
+  if (cond) x=1; else WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__WideCharToMultiByte__leakignore() {
+  char *p = strdup(str);
+  WideCharToMultiByte(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+  // cppcheck-suppress memleak
+}
+
+void test__WideCharToMultiByte__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WideCharToMultiByte(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+}
+
+void test__WideCharToMultiByte__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WideCharToMultiByte(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
+}
+
+void test__WideCharToMultiByte__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WideCharToMultiByte(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8);
+}
+
+void test__WideCharToMultiByte__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WideCharToMultiByte(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8);
+}
+
+void test__WideCharToMultiByte__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8);
+}
+
+void test__WideCharToMultiByte__arg7__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8);
+}
+
+void test__PathIsDirectory__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = PathIsDirectory(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__PathIsDirectory__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  PathIsDirectory(arg1);
+}
+
+void test__PathIsDirectory__leakignore() {
+  char *p = strdup(str);
+  result = PathIsDirectory(p);
+  // cppcheck-suppress memleak
+}
+
+void test__PathIsDirectory__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = PathIsDirectory(x);
+}
+
+void test__PathIsDirectoryA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = PathIsDirectoryA(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__PathIsDirectoryA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  PathIsDirectoryA(arg1);
+}
+
+void test__PathIsDirectoryA__leakignore() {
+  char *p = strdup(str);
+  result = PathIsDirectoryA(p);
+  // cppcheck-suppress memleak
+}
+
+void test__PathIsDirectoryA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = PathIsDirectoryA(x);
+}
+
+void test__PathIsDirectoryW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = PathIsDirectoryW(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__PathIsDirectoryW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  PathIsDirectoryW(arg1);
+}
+
+void test__PathIsDirectoryW__leakignore() {
+  char *p = strdup(str);
+  result = PathIsDirectoryW(p);
+  // cppcheck-suppress memleak
+}
+
+void test__PathIsDirectoryW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = PathIsDirectoryW(x);
+}
+
+void test__SetConsoleTextAttribute__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetConsoleTextAttribute(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetConsoleTextAttribute__leakignore() {
+  char *p = strdup(str);
+  SetConsoleTextAttribute(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__SetConsoleTextAttribute__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetConsoleTextAttribute(x, arg2);
+}
+
+void test__SetConsoleTextAttribute__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetConsoleTextAttribute(arg1, x);
+}
+
+void test___wfopen_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wfopen_s(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wfopen_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wfopen_s(NULL, arg2, arg3);
+}
+
+void test___wfopen_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wfopen_s(arg1, NULL, arg3);
+}
+
+void test___wfopen_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wfopen_s(arg1, x, arg3);
+}
+
+void test___wfopen_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _wfopen_s(arg1, arg2, NULL);
+}
+
+void test___wfopen_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wfopen_s(arg1, arg2, x);
+}
+
+void test___tfopen_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tfopen_s(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tfopen_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tfopen_s(NULL, arg2, arg3);
+}
+
+void test___tfopen_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tfopen_s(arg1, NULL, arg3);
+}
+
+void test___tfopen_s__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tfopen_s(arg1, x, arg3);
+}
+
+void test___tfopen_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _tfopen_s(arg1, arg2, NULL);
+}
+
+void test___tfopen_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tfopen_s(arg1, arg2, x);
+}
+
+void test__DeleteFile__noreturn() {
+  int x = 100;
+  if (cond) x=1; else DeleteFile(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__DeleteFile__leakignore() {
+  char *p = strdup(str);
+  DeleteFile(p);
+  // cppcheck-suppress memleak
+}
+
+void test__DeleteFile__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DeleteFile(x);
+}
+
+void test__DeleteFileA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else DeleteFileA(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__DeleteFileA__leakignore() {
+  char *p = strdup(str);
+  DeleteFileA(p);
+  // cppcheck-suppress memleak
+}
+
+void test__DeleteFileA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DeleteFileA(x);
+}
+
+void test__DeleteFileW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else DeleteFileW(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__DeleteFileW__leakignore() {
+  char *p = strdup(str);
+  DeleteFileW(p);
+  // cppcheck-suppress memleak
+}
+
+void test__DeleteFileW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DeleteFileW(x);
+}
+
+void test__GetStdHandle__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = GetStdHandle(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetStdHandle__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetStdHandle(arg1);
+}
+
+void test__GetStdHandle__leakignore() {
+  char *p = strdup(str);
+  result = GetStdHandle(p);
+  // cppcheck-suppress memleak
+}
+
+void test__GetStdHandle__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetStdHandle(x);
+}
+
+void test__SetStdHandle__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetStdHandle(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetStdHandle__leakignore() {
+  char *p = strdup(str);
+  SetStdHandle(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__SetStdHandle__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetStdHandle(x, arg2);
+}
+
+void test__SetStdHandle__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetStdHandle(arg1, x);
+}
+
+void test___access__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _access(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___access__leakignore() {
+  char *p = strdup(str);
+  _access(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___access__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _access(NULL, arg2);
+}
+
+void test___access__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _access(x, arg2);
+}
+
+void test___access__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _access(arg1, x);
+}
+
+void test___waccess__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _waccess(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___waccess__leakignore() {
+  char *p = strdup(str);
+  _waccess(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___waccess__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _waccess(NULL, arg2);
+}
+
+void test___waccess__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _waccess(x, arg2);
+}
+
+void test___waccess__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _waccess(arg1, x);
+}
+
+void test___taccess__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _taccess(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___taccess__leakignore() {
+  char *p = strdup(str);
+  _taccess(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___taccess__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _taccess(NULL, arg2);
+}
+
+void test___taccess__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _taccess(x, arg2);
+}
+
+void test___taccess__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _taccess(arg1, x);
+}
+
+void test__PeekMessage__noreturn() {
+  int x = 100;
+  if (cond) x=1; else PeekMessage(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__PeekMessage__leakignore() {
+  char *p = strdup(str);
+  PeekMessage(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__PeekMessage__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  PeekMessage(NULL, arg2, arg3, arg4, arg5);
+}
+
+void test__PeekMessage__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessage(arg1, x, arg3, arg4, arg5);
+}
+
+void test__PeekMessage__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessage(arg1, arg2, x, arg4, arg5);
+}
+
+void test__PeekMessage__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessage(arg1, arg2, arg3, x, arg5);
+}
+
+void test__PeekMessage__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessage(arg1, arg2, arg3, arg4, x);
+}
+
+void test__PeekMessageA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else PeekMessageA(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__PeekMessageA__leakignore() {
+  char *p = strdup(str);
+  PeekMessageA(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__PeekMessageA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  PeekMessageA(NULL, arg2, arg3, arg4, arg5);
+}
+
+void test__PeekMessageA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageA(arg1, x, arg3, arg4, arg5);
+}
+
+void test__PeekMessageA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageA(arg1, arg2, x, arg4, arg5);
+}
+
+void test__PeekMessageA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageA(arg1, arg2, arg3, x, arg5);
+}
+
+void test__PeekMessageA__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageA(arg1, arg2, arg3, arg4, x);
+}
+
+void test__PeekMessageW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else PeekMessageW(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__PeekMessageW__leakignore() {
+  char *p = strdup(str);
+  PeekMessageW(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__PeekMessageW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  PeekMessageW(NULL, arg2, arg3, arg4, arg5);
+}
+
+void test__PeekMessageW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageW(arg1, x, arg3, arg4, arg5);
+}
+
+void test__PeekMessageW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageW(arg1, arg2, x, arg4, arg5);
+}
+
+void test__PeekMessageW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageW(arg1, arg2, arg3, x, arg5);
+}
+
+void test__PeekMessageW__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PeekMessageW(arg1, arg2, arg3, arg4, x);
+}
+
+void test__GetMessage__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetMessage(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetMessage__leakignore() {
+  char *p = strdup(str);
+  GetMessage(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__GetMessage__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetMessage(NULL, arg2, arg3, arg4);
+}
+
+void test__GetMessage__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessage(arg1, x, arg3, arg4);
+}
+
+void test__GetMessage__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessage(arg1, arg2, x, arg4);
+}
+
+void test__GetMessage__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessage(arg1, arg2, arg3, x);
+}
+
+void test__GetMessageA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetMessageA(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetMessageA__leakignore() {
+  char *p = strdup(str);
+  GetMessageA(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__GetMessageA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetMessageA(NULL, arg2, arg3, arg4);
+}
+
+void test__GetMessageA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessageA(arg1, x, arg3, arg4);
+}
+
+void test__GetMessageA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessageA(arg1, arg2, x, arg4);
+}
+
+void test__GetMessageA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessageA(arg1, arg2, arg3, x);
+}
+
+void test__GetMessageW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetMessageW(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetMessageW__leakignore() {
+  char *p = strdup(str);
+  GetMessageW(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__GetMessageW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetMessageW(NULL, arg2, arg3, arg4);
+}
+
+void test__GetMessageW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessageW(arg1, x, arg3, arg4);
+}
+
+void test__GetMessageW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessageW(arg1, arg2, x, arg4);
+}
+
+void test__GetMessageW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetMessageW(arg1, arg2, arg3, x);
+}
+
+void test__TranslateMessage__noreturn() {
+  int x = 100;
+  if (cond) x=1; else TranslateMessage(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__TranslateMessage__leakignore() {
+  char *p = strdup(str);
+  TranslateMessage(p);
+  // cppcheck-suppress memleak
+}
+
+void test__TranslateMessage__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  TranslateMessage(NULL);
+}
+
+void test__TranslateMessage__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  TranslateMessage(x);
+}
+
+void test__DispatchMessage__noreturn() {
+  int x = 100;
+  if (cond) x=1; else DispatchMessage(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__DispatchMessage__leakignore() {
+  char *p = strdup(str);
+  DispatchMessage(p);
+  // cppcheck-suppress memleak
+}
+
+void test__DispatchMessage__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DispatchMessage(NULL);
+}
+
+void test__DispatchMessage__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DispatchMessage(x);
+}
+
+void test__DispatchMessageA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else DispatchMessageA(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__DispatchMessageA__leakignore() {
+  char *p = strdup(str);
+  DispatchMessageA(p);
+  // cppcheck-suppress memleak
+}
+
+void test__DispatchMessageA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DispatchMessageA(NULL);
+}
+
+void test__DispatchMessageA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DispatchMessageA(x);
+}
+
+void test__DispatchMessageW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else DispatchMessageW(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__DispatchMessageW__leakignore() {
+  char *p = strdup(str);
+  DispatchMessageW(p);
+  // cppcheck-suppress memleak
+}
+
+void test__DispatchMessageW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DispatchMessageW(NULL);
+}
+
+void test__DispatchMessageW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DispatchMessageW(x);
+}
+
+void test__SendMessage__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SendMessage(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SendMessage__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SendMessage(NULL, arg2, arg3, arg4);
+}
+
+void test__SendMessage__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SendMessage(x, arg2, arg3, arg4);
+}
+
+void test__SendMessage__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessage(arg1, x, arg3, arg4);
+}
+
+void test__SendMessage__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessage(arg1, arg2, x, arg4);
+}
+
+void test__SendMessage__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessage(arg1, arg2, arg3, x);
+}
+
+void test__SendMessageA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SendMessageA(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SendMessageA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SendMessageA(NULL, arg2, arg3, arg4);
+}
+
+void test__SendMessageA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SendMessageA(x, arg2, arg3, arg4);
+}
+
+void test__SendMessageA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessageA(arg1, x, arg3, arg4);
+}
+
+void test__SendMessageA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessageA(arg1, arg2, x, arg4);
+}
+
+void test__SendMessageA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessageA(arg1, arg2, arg3, x);
+}
+
+void test__SendMessageW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SendMessageW(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SendMessageW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SendMessageW(NULL, arg2, arg3, arg4);
+}
+
+void test__SendMessageW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SendMessageW(x, arg2, arg3, arg4);
+}
+
+void test__SendMessageW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessageW(arg1, x, arg3, arg4);
+}
+
+void test__SendMessageW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessageW(arg1, arg2, x, arg4);
+}
+
+void test__SendMessageW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SendMessageW(arg1, arg2, arg3, x);
+}
+
+void test__PostMessage__noreturn() {
+  int x = 100;
+  if (cond) x=1; else PostMessage(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__PostMessage__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  PostMessage(NULL, arg2, arg3, arg4);
+}
+
+void test__PostMessage__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  PostMessage(x, arg2, arg3, arg4);
+}
+
+void test__PostMessage__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessage(arg1, x, arg3, arg4);
+}
+
+void test__PostMessage__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessage(arg1, arg2, x, arg4);
+}
+
+void test__PostMessage__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessage(arg1, arg2, arg3, x);
+}
+
+void test__PostMessageA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else PostMessageA(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__PostMessageA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  PostMessageA(NULL, arg2, arg3, arg4);
+}
+
+void test__PostMessageA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  PostMessageA(x, arg2, arg3, arg4);
+}
+
+void test__PostMessageA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessageA(arg1, x, arg3, arg4);
+}
+
+void test__PostMessageA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessageA(arg1, arg2, x, arg4);
+}
+
+void test__PostMessageA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessageA(arg1, arg2, arg3, x);
+}
+
+void test__PostMessageW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else PostMessageW(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__PostMessageW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  PostMessageW(NULL, arg2, arg3, arg4);
+}
+
+void test__PostMessageW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  PostMessageW(x, arg2, arg3, arg4);
+}
+
+void test__PostMessageW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessageW(arg1, x, arg3, arg4);
+}
+
+void test__PostMessageW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessageW(arg1, arg2, x, arg4);
+}
+
+void test__PostMessageW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostMessageW(arg1, arg2, arg3, x);
+}
+
+void test__PostQuitMessage__noreturn() {
+  int x = 100;
+  if (cond) x=1; else PostQuitMessage(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__PostQuitMessage__leakignore() {
+  char *p = strdup(str);
+  PostQuitMessage(p);
+  // cppcheck-suppress memleak
+}
+
+void test__PostQuitMessage__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  PostQuitMessage(x);
+}
+
+void test__DefWindowProc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else DefWindowProc(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__DefWindowProc__leakignore() {
+  char *p = strdup(str);
+  DefWindowProc(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__DefWindowProc__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DefWindowProc(NULL, arg2, arg3, arg4);
+}
+
+void test__DefWindowProc__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DefWindowProc(x, arg2, arg3, arg4);
+}
+
+void test__DefWindowProc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProc(arg1, x, arg3, arg4);
+}
+
+void test__DefWindowProc__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProc(arg1, arg2, x, arg4);
+}
+
+void test__DefWindowProc__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProc(arg1, arg2, arg3, x);
+}
+
+void test__DefWindowProcA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else DefWindowProcA(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__DefWindowProcA__leakignore() {
+  char *p = strdup(str);
+  DefWindowProcA(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__DefWindowProcA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DefWindowProcA(NULL, arg2, arg3, arg4);
+}
+
+void test__DefWindowProcA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DefWindowProcA(x, arg2, arg3, arg4);
+}
+
+void test__DefWindowProcA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProcA(arg1, x, arg3, arg4);
+}
+
+void test__DefWindowProcA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProcA(arg1, arg2, x, arg4);
+}
+
+void test__DefWindowProcA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProcA(arg1, arg2, arg3, x);
+}
+
+void test__DefWindowProcW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else DefWindowProcW(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__DefWindowProcW__leakignore() {
+  char *p = strdup(str);
+  DefWindowProcW(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__DefWindowProcW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DefWindowProcW(NULL, arg2, arg3, arg4);
+}
+
+void test__DefWindowProcW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DefWindowProcW(x, arg2, arg3, arg4);
+}
+
+void test__DefWindowProcW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProcW(arg1, x, arg3, arg4);
+}
+
+void test__DefWindowProcW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProcW(arg1, arg2, x, arg4);
+}
+
+void test__DefWindowProcW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  DefWindowProcW(arg1, arg2, arg3, x);
+}
+
+void test__GetPrivateProfileInt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = GetPrivateProfileInt(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetPrivateProfileInt__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetPrivateProfileInt(arg1, arg2, arg3, arg4);
+}
+
+void test__GetPrivateProfileInt__leakignore() {
+  char *p = strdup(str);
+  result = GetPrivateProfileInt(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__GetPrivateProfileInt__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileInt(NULL, arg2, arg3, arg4);
+}
+
+void test__GetPrivateProfileInt__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileInt(x, arg2, arg3, arg4);
+}
+
+void test__GetPrivateProfileInt__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileInt(arg1, NULL, arg3, arg4);
+}
+
+void test__GetPrivateProfileInt__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileInt(arg1, x, arg3, arg4);
+}
+
+void test__GetPrivateProfileInt__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileInt(arg1, arg2, x, arg4);
+}
+
+void test__GetPrivateProfileInt__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileInt(arg1, arg2, arg3, NULL);
+}
+
+void test__GetPrivateProfileInt__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileInt(arg1, arg2, arg3, x);
+}
+
+void test__GetPrivateProfileIntA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = GetPrivateProfileIntA(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetPrivateProfileIntA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetPrivateProfileIntA(arg1, arg2, arg3, arg4);
+}
+
+void test__GetPrivateProfileIntA__leakignore() {
+  char *p = strdup(str);
+  result = GetPrivateProfileIntA(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__GetPrivateProfileIntA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileIntA(NULL, arg2, arg3, arg4);
+}
+
+void test__GetPrivateProfileIntA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntA(x, arg2, arg3, arg4);
+}
+
+void test__GetPrivateProfileIntA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileIntA(arg1, NULL, arg3, arg4);
+}
+
+void test__GetPrivateProfileIntA__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntA(arg1, x, arg3, arg4);
+}
+
+void test__GetPrivateProfileIntA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntA(arg1, arg2, x, arg4);
+}
+
+void test__GetPrivateProfileIntA__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileIntA(arg1, arg2, arg3, NULL);
+}
+
+void test__GetPrivateProfileIntA__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntA(arg1, arg2, arg3, x);
+}
+
+void test__GetPrivateProfileIntW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = GetPrivateProfileIntW(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetPrivateProfileIntW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetPrivateProfileIntW(arg1, arg2, arg3, arg4);
+}
+
+void test__GetPrivateProfileIntW__leakignore() {
+  char *p = strdup(str);
+  result = GetPrivateProfileIntW(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__GetPrivateProfileIntW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileIntW(NULL, arg2, arg3, arg4);
+}
+
+void test__GetPrivateProfileIntW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntW(x, arg2, arg3, arg4);
+}
+
+void test__GetPrivateProfileIntW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileIntW(arg1, NULL, arg3, arg4);
+}
+
+void test__GetPrivateProfileIntW__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntW(arg1, x, arg3, arg4);
+}
+
+void test__GetPrivateProfileIntW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntW(arg1, arg2, x, arg4);
+}
+
+void test__GetPrivateProfileIntW__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetPrivateProfileIntW(arg1, arg2, arg3, NULL);
+}
+
+void test__GetPrivateProfileIntW__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetPrivateProfileIntW(arg1, arg2, arg3, x);
+}
+
+void test__GetPrivateProfileSection__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetPrivateProfileSection(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetPrivateProfileSection__leakignore() {
+  char *p = strdup(str);
+  GetPrivateProfileSection(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__GetPrivateProfileSection__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSection(NULL, arg2, arg3, arg4);
+}
+
+void test__GetPrivateProfileSection__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSection(x, arg2, arg3, arg4);
+}
+
+void test__GetPrivateProfileSection__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSection(arg1, NULL, arg3, arg4);
+}
+
+void test__GetPrivateProfileSection__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSection(arg1, arg2, x, arg4);
+}
+
+void test__GetPrivateProfileSection__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSection(arg1, arg2, arg3, NULL);
+}
+
+void test__GetPrivateProfileSection__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSection(arg1, arg2, arg3, x);
+}
+
+void test__GetPrivateProfileSectionA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetPrivateProfileSectionA(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetPrivateProfileSectionA__leakignore() {
+  char *p = strdup(str);
+  GetPrivateProfileSectionA(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__GetPrivateProfileSectionA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionA(NULL, arg2, arg3, arg4);
+}
+
+void test__GetPrivateProfileSectionA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionA(x, arg2, arg3, arg4);
+}
+
+void test__GetPrivateProfileSectionA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionA(arg1, NULL, arg3, arg4);
+}
+
+void test__GetPrivateProfileSectionA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionA(arg1, arg2, x, arg4);
+}
+
+void test__GetPrivateProfileSectionA__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionA(arg1, arg2, arg3, NULL);
+}
+
+void test__GetPrivateProfileSectionA__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionA(arg1, arg2, arg3, x);
+}
+
+void test__GetPrivateProfileSectionW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetPrivateProfileSectionW(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetPrivateProfileSectionW__leakignore() {
+  char *p = strdup(str);
+  GetPrivateProfileSectionW(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__GetPrivateProfileSectionW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionW(NULL, arg2, arg3, arg4);
+}
+
+void test__GetPrivateProfileSectionW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionW(x, arg2, arg3, arg4);
+}
+
+void test__GetPrivateProfileSectionW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionW(arg1, NULL, arg3, arg4);
+}
+
+void test__GetPrivateProfileSectionW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionW(arg1, arg2, x, arg4);
+}
+
+void test__GetPrivateProfileSectionW__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionW(arg1, arg2, arg3, NULL);
+}
+
+void test__GetPrivateProfileSectionW__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionW(arg1, arg2, arg3, x);
+}
+
+void test__GetPrivateProfileSectionNames__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetPrivateProfileSectionNames(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetPrivateProfileSectionNames__leakignore() {
+  char *p = strdup(str);
+  GetPrivateProfileSectionNames(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__GetPrivateProfileSectionNames__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionNames(NULL, arg2, arg3);
+}
+
+void test__GetPrivateProfileSectionNames__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionNames(arg1, x, arg3);
+}
+
+void test__GetPrivateProfileSectionNames__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionNames(arg1, arg2, NULL);
+}
+
+void test__GetPrivateProfileSectionNames__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionNames(arg1, arg2, x);
+}
+
+void test__GetPrivateProfileSectionNamesA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetPrivateProfileSectionNamesA(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetPrivateProfileSectionNamesA__leakignore() {
+  char *p = strdup(str);
+  GetPrivateProfileSectionNamesA(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__GetPrivateProfileSectionNamesA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionNamesA(NULL, arg2, arg3);
+}
+
+void test__GetPrivateProfileSectionNamesA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionNamesA(arg1, x, arg3);
+}
+
+void test__GetPrivateProfileSectionNamesA__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionNamesA(arg1, arg2, NULL);
+}
+
+void test__GetPrivateProfileSectionNamesA__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionNamesA(arg1, arg2, x);
+}
+
+void test__GetPrivateProfileSectionNamesW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetPrivateProfileSectionNamesW(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetPrivateProfileSectionNamesW__leakignore() {
+  char *p = strdup(str);
+  GetPrivateProfileSectionNamesW(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__GetPrivateProfileSectionNamesW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionNamesW(NULL, arg2, arg3);
+}
+
+void test__GetPrivateProfileSectionNamesW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionNamesW(arg1, x, arg3);
+}
+
+void test__GetPrivateProfileSectionNamesW__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileSectionNamesW(arg1, arg2, NULL);
+}
+
+void test__GetPrivateProfileSectionNamesW__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileSectionNamesW(arg1, arg2, x);
+}
+
+void test__GetPrivateProfileString__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetPrivateProfileString__leakignore() {
+  char *p = strdup(str);
+  GetPrivateProfileString(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__GetPrivateProfileString__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileString(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__GetPrivateProfileString__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileString(arg1, x, arg3, arg4, arg5, arg6);
+}
+
+void test__GetPrivateProfileString__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileString(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__GetPrivateProfileString__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileString(arg1, arg2, arg3, NULL, arg5, arg6);
+}
+
+void test__GetPrivateProfileString__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileString(arg1, arg2, arg3, arg4, x, arg6);
+}
+
+void test__GetPrivateProfileString__arg6__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, NULL);
+}
+
+void test__GetPrivateProfileString__arg6__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, x);
+}
+
+void test__GetPrivateProfileStringA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetPrivateProfileStringA__leakignore() {
+  char *p = strdup(str);
+  GetPrivateProfileStringA(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__GetPrivateProfileStringA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringA(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__GetPrivateProfileStringA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringA(arg1, x, arg3, arg4, arg5, arg6);
+}
+
+void test__GetPrivateProfileStringA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringA(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__GetPrivateProfileStringA__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStringA(arg1, arg2, arg3, NULL, arg5, arg6);
+}
+
+void test__GetPrivateProfileStringA__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringA(arg1, arg2, arg3, arg4, x, arg6);
+}
+
+void test__GetPrivateProfileStringA__arg6__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, NULL);
+}
+
+void test__GetPrivateProfileStringA__arg6__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, x);
+}
+
+void test__GetPrivateProfileStringW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetPrivateProfileStringW(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetPrivateProfileStringW__leakignore() {
+  char *p = strdup(str);
+  GetPrivateProfileStringW(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__GetPrivateProfileStringW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStringW(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__GetPrivateProfileStringW__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStringW(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__GetPrivateProfileStringW__arg6__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStringW(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__GetPrivateProfileStruct__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetPrivateProfileStruct(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetPrivateProfileStruct__leakignore() {
+  char *p = strdup(str);
+  GetPrivateProfileStruct(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__GetPrivateProfileStruct__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStruct(NULL, arg2, arg3, arg4, arg5);
+}
+
+void test__GetPrivateProfileStruct__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStruct(x, arg2, arg3, arg4, arg5);
+}
+
+void test__GetPrivateProfileStruct__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStruct(arg1, NULL, arg3, arg4, arg5);
+}
+
+void test__GetPrivateProfileStruct__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStruct(arg1, x, arg3, arg4, arg5);
+}
+
+void test__GetPrivateProfileStruct__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStruct(arg1, arg2, NULL, arg4, arg5);
+}
+
+void test__GetPrivateProfileStruct__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStruct(arg1, arg2, arg3, x, arg5);
+}
+
+void test__GetPrivateProfileStruct__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStruct(arg1, arg2, arg3, arg4, NULL);
+}
+
+void test__GetPrivateProfileStruct__arg5__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStruct(arg1, arg2, arg3, arg4, x);
+}
+
+void test__GetPrivateProfileStructA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetPrivateProfileStructA(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetPrivateProfileStructA__leakignore() {
+  char *p = strdup(str);
+  GetPrivateProfileStructA(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__GetPrivateProfileStructA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructA(NULL, arg2, arg3, arg4, arg5);
+}
+
+void test__GetPrivateProfileStructA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructA(x, arg2, arg3, arg4, arg5);
+}
+
+void test__GetPrivateProfileStructA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructA(arg1, NULL, arg3, arg4, arg5);
+}
+
+void test__GetPrivateProfileStructA__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructA(arg1, x, arg3, arg4, arg5);
+}
+
+void test__GetPrivateProfileStructA__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructA(arg1, arg2, NULL, arg4, arg5);
+}
+
+void test__GetPrivateProfileStructA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructA(arg1, arg2, arg3, x, arg5);
+}
+
+void test__GetPrivateProfileStructA__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructA(arg1, arg2, arg3, arg4, NULL);
+}
+
+void test__GetPrivateProfileStructA__arg5__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructA(arg1, arg2, arg3, arg4, x);
+}
+
+void test__GetPrivateProfileStructW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetPrivateProfileStructW(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetPrivateProfileStructW__leakignore() {
+  char *p = strdup(str);
+  GetPrivateProfileStructW(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__GetPrivateProfileStructW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructW(NULL, arg2, arg3, arg4, arg5);
+}
+
+void test__GetPrivateProfileStructW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructW(x, arg2, arg3, arg4, arg5);
+}
+
+void test__GetPrivateProfileStructW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructW(arg1, NULL, arg3, arg4, arg5);
+}
+
+void test__GetPrivateProfileStructW__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructW(arg1, x, arg3, arg4, arg5);
+}
+
+void test__GetPrivateProfileStructW__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructW(arg1, arg2, NULL, arg4, arg5);
+}
+
+void test__GetPrivateProfileStructW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructW(arg1, arg2, arg3, x, arg5);
+}
+
+void test__GetPrivateProfileStructW__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  GetPrivateProfileStructW(arg1, arg2, arg3, arg4, NULL);
+}
+
+void test__GetPrivateProfileStructW__arg5__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetPrivateProfileStructW(arg1, arg2, arg3, arg4, x);
+}
+
+void test__BeginPaint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else BeginPaint(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__BeginPaint__leakignore() {
+  char *p = strdup(str);
+  BeginPaint(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__BeginPaint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  BeginPaint(x, arg2);
+}
+
+void test__BeginPaint__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  BeginPaint(arg1, NULL);
+}
+
+void test__EndPaint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else EndPaint(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__EndPaint__leakignore() {
+  char *p = strdup(str);
+  EndPaint(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__EndPaint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  EndPaint(x, arg2);
+}
+
+void test__EndPaint__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  EndPaint(arg1, NULL);
+}
+
+void test__GetStockObject__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = GetStockObject(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetStockObject__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetStockObject(arg1);
+}
+
+void test__GetStockObject__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((GetStockObject(arg1) > 10) || (GetStockObject(arg1) < 100)) {}
+}
+
+void test__GetStockObject__leakignore() {
+  char *p = strdup(str);
+  result = GetStockObject(p);
+  // cppcheck-suppress memleak
+}
+
+void test__GetStockObject__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetStockObject(x);
+}
+
+void test__LoadIcon__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = LoadIcon(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__LoadIcon__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  LoadIcon(arg1, arg2);
+}
+
+void test__LoadIcon__leakignore() {
+  char *p = strdup(str);
+  result = LoadIcon(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__LoadIcon__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = LoadIcon(x, arg2);
+}
+
+void test__LoadIcon__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = LoadIcon(arg1, NULL);
+}
+
+void test__LoadIcon__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = LoadIcon(arg1, x);
+}
+
+void test__LoadIconA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = LoadIconA(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__LoadIconA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  LoadIconA(arg1, arg2);
+}
+
+void test__LoadIconA__leakignore() {
+  char *p = strdup(str);
+  result = LoadIconA(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__LoadIconA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = LoadIconA(x, arg2);
+}
+
+void test__LoadIconA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = LoadIconA(arg1, NULL);
+}
+
+void test__LoadIconA__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = LoadIconA(arg1, x);
+}
+
+void test__LoadIconW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = LoadIconW(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__LoadIconW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  LoadIconW(arg1, arg2);
+}
+
+void test__LoadIconW__leakignore() {
+  char *p = strdup(str);
+  result = LoadIconW(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__LoadIconW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = LoadIconW(x, arg2);
+}
+
+void test__LoadIconW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = LoadIconW(arg1, NULL);
+}
+
+void test__LoadIconW__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = LoadIconW(arg1, x);
+}
+
+void test__CreateSolidBrush__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = CreateSolidBrush(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateSolidBrush__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateSolidBrush(arg1);
+}
+
+void test__CreateSolidBrush__leakignore() {
+  char *p = strdup(str);
+  result = CreateSolidBrush(p);
+  // cppcheck-suppress memleak
+}
+
+void test__CreateSolidBrush__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateSolidBrush(x);
+}
+
+void test__UpdateWindow__noreturn() {
+  int x = 100;
+  if (cond) x=1; else UpdateWindow(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__UpdateWindow__leakignore() {
+  char *p = strdup(str);
+  UpdateWindow(p);
+  // cppcheck-suppress memleak
+}
+
+void test__UpdateWindow__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  UpdateWindow(NULL);
+}
+
+void test__UpdateWindow__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  UpdateWindow(x);
+}
+
+void test__EnableWindow__noreturn() {
+  int x = 100;
+  if (cond) x=1; else EnableWindow(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__EnableWindow__leakignore() {
+  char *p = strdup(str);
+  EnableWindow(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__EnableWindow__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  EnableWindow(NULL, arg2);
+}
+
+void test__EnableWindow__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  EnableWindow(x, arg2);
+}
+
+void test__EnableWindow__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  EnableWindow(arg1, x);
+}
+
+void test__CreateWindow__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateWindow__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindow__leakignore() {
+  char *p = strdup(str);
+  result = CreateWindow(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress memleak
+}
+
+void test__CreateWindow__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindow__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindow__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindow__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindow__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindow__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindow__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindow__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(arg1, arg2, arg3, arg4, arg5, x, 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__CreateWindow__arg8__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
+}
+
+void test__CreateWindow__arg9__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
+}
+
+void test__CreateWindowA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateWindowA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindowA__leakignore() {
+  char *p = strdup(str);
+  result = CreateWindowA(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress memleak
+}
+
+void test__CreateWindowA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindowA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindowA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(x, 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__CreateWindowA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(arg1, arg2, x, 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__CreateWindowA__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(arg1, arg2, arg3, arg4, x, 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__CreateWindowA__arg7__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, x, 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__CreateWindowA__arg9__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
+}
+
+void test__CreateWindowW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateWindowW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindowW__leakignore() {
+  char *p = strdup(str);
+  result = CreateWindowW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress memleak
+}
+
+void test__CreateWindowW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindowW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindowW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(x, 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__CreateWindowW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(arg1, arg2, x, 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__CreateWindowW__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(arg1, arg2, arg3, arg4, x, 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__CreateWindowW__arg7__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, x, 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__CreateWindowW__arg9__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
+}
+
+void test__CreateWindowEx__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateWindowEx__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindowEx__leakignore() {
+  char *p = strdup(str);
+  result = CreateWindowEx(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress memleak
+}
+
+void test__CreateWindowEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindowEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(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__CreateWindowEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindowEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindowEx__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(arg1, arg2, x, 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__CreateWindowEx__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(arg1, arg2, arg3, arg4, x, 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__CreateWindowEx__arg7__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, x, 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__CreateWindowEx__arg9__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
+}
+
+void test__CreateWindowExA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateWindowExA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindowExA__leakignore() {
+  char *p = strdup(str);
+  result = CreateWindowExA(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__CreateWindowExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(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__CreateWindowExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(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__CreateWindowExA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(arg1, arg2, x, 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__CreateWindowExA__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(arg1, arg2, arg3, arg4, x, 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__CreateWindowExA__arg7__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, x, 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__CreateWindowExA__arg9__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
+}
+
+void test__CreateWindowExW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateWindowExW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindowExW__leakignore() {
+  char *p = strdup(str);
+  result = CreateWindowExW(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__CreateWindowExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindowExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+}
+
+void test__CreateWindowExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(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__CreateWindowExW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(arg1, arg2, x, 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__CreateWindowExW__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(arg1, arg2, arg3, arg4, x, 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__CreateWindowExW__arg7__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, x, 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__CreateWindowExW__arg9__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
+}
+
+void test__SetWindowText__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetWindowText(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetWindowText__leakignore() {
+  char *p = strdup(str);
+  SetWindowText(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__SetWindowText__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SetWindowText(NULL, arg2);
+}
+
+void test__SetWindowText__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetWindowText(x, arg2);
+}
+
+void test__SetWindowText__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  SetWindowText(arg1, NULL);
+}
+
+void test__SetWindowText__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetWindowText(arg1, x);
+}
+
+void test__SetWindowTextA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetWindowTextA(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetWindowTextA__leakignore() {
+  char *p = strdup(str);
+  SetWindowTextA(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__SetWindowTextA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SetWindowTextA(NULL, arg2);
+}
+
+void test__SetWindowTextA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetWindowTextA(x, arg2);
+}
+
+void test__SetWindowTextA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  SetWindowTextA(arg1, NULL);
+}
+
+void test__SetWindowTextA__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetWindowTextA(arg1, x);
+}
+
+void test__SetWindowTextW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetWindowTextW(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetWindowTextW__leakignore() {
+  char *p = strdup(str);
+  SetWindowTextW(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__SetWindowTextW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SetWindowTextW(NULL, arg2);
+}
+
+void test__SetWindowTextW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetWindowTextW(x, arg2);
+}
+
+void test__SetWindowTextW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  SetWindowTextW(arg1, NULL);
+}
+
+void test__SetWindowTextW__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetWindowTextW(arg1, x);
+}
+
+void test__RegisterClass__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RegisterClass(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RegisterClass__leakignore() {
+  char *p = strdup(str);
+  RegisterClass(p);
+  // cppcheck-suppress memleak
+}
+
+void test__RegisterClass__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  RegisterClass(NULL);
+}
+
+void test__RegisterClass__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  RegisterClass(x);
+}
+
+void test__RegisterClassEx__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RegisterClassEx(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RegisterClassEx__leakignore() {
+  char *p = strdup(str);
+  RegisterClassEx(p);
+  // 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__UnregisterClass__noreturn() {
+  int x = 100;
+  if (cond) x=1; else UnregisterClass(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__UnregisterClass__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  UnregisterClass(x, arg2);
+}
+
+void test__UnregisterClass__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  UnregisterClass(arg1, x);
+}
+
+void test__UnregisterClassA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else UnregisterClassA(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__UnregisterClassA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  UnregisterClassA(x, arg2);
+}
+
+void test__UnregisterClassA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  UnregisterClassA(arg1, x);
+}
+
+void test__UnregisterClassW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else UnregisterClassW(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__UnregisterClassW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  UnregisterClassW(x, arg2);
+}
+
+void test__UnregisterClassW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  UnregisterClassW(arg1, x);
+}
+
+void test__MessageBox__noreturn() {
+  int x = 100;
+  if (cond) x=1; else MessageBox(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__MessageBox__leakignore() {
+  char *p = strdup(str);
+  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__MessageBox__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBox(arg1, arg2, x, arg4);
+}
+
+void test__MessageBox__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBox(arg1, arg2, arg3, x);
+}
+
+void test__MessageBoxA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else MessageBoxA(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__MessageBoxA__leakignore() {
+  char *p = strdup(str);
+  MessageBoxA(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__MessageBoxA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxA(x, arg2, arg3, arg4);
+}
+
+void test__MessageBoxA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxA(arg1, x, arg3, arg4);
+}
+
+void test__MessageBoxA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxA(arg1, arg2, x, arg4);
+}
+
+void test__MessageBoxA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxA(arg1, arg2, arg3, x);
+}
+
+void test__MessageBoxW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else MessageBoxW(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__MessageBoxW__leakignore() {
+  char *p = strdup(str);
+  MessageBoxW(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__MessageBoxW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxW(x, arg2, arg3, arg4);
+}
+
+void test__MessageBoxW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxW(arg1, x, arg3, arg4);
+}
+
+void test__MessageBoxW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxW(arg1, arg2, x, arg4);
+}
+
+void test__MessageBoxW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  MessageBoxW(arg1, arg2, arg3, x);
+}
+
+void test__GlobalLock__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GlobalLock(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GlobalLock__leakignore() {
+  char *p = strdup(str);
+  GlobalLock(p);
+  // cppcheck-suppress memleak
+}
+
+void test__GlobalLock__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GlobalLock(NULL);
+}
+
+void test__GlobalLock__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GlobalLock(x);
+}
+
+void test__GlobalUnlock__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GlobalUnlock(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GlobalUnlock__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else OpenClipboard(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__OpenClipboard__leakignore() {
+  char *p = strdup(str);
+  OpenClipboard(p);
+  // cppcheck-suppress memleak
+}
+
+void test__OpenClipboard__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenClipboard(x);
+}
+
+void test__EmptyClipboard__noreturn() {
+  int x = 100;
+  if (cond) x=1; else EmptyClipboard();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__EmptyClipboard__leakignore() {
+  char *p = strdup(str);
+  EmptyClipboard();
+  // cppcheck-suppress memleak
+}
+
+void test__CloseClipboard__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CloseClipboard();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CloseClipboard__leakignore() {
+  char *p = strdup(str);
+  CloseClipboard();
+  // cppcheck-suppress memleak
+}
+
+void test__SetClipboardData__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetClipboardData(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetClipboardData__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else _rmdir(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___rmdir__leakignore() {
+  char *p = strdup(str);
+  _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 = 100;
+  if (cond) x=1; else _wrmdir(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wrmdir__leakignore() {
+  char *p = strdup(str);
+  _wrmdir(p);
+  // cppcheck-suppress memleak
+}
+
+void test___wrmdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wrmdir(NULL);
+}
+
+void test___wrmdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wrmdir(x);
+}
+
+void test___mkdir__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _mkdir(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mkdir__leakignore() {
+  char *p = strdup(str);
+  _mkdir(p);
+  // cppcheck-suppress memleak
+}
+
+void test___mkdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mkdir(NULL);
+}
+
+void test___mkdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mkdir(x);
+}
+
+void test___wmkdir__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wmkdir(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wmkdir__leakignore() {
+  char *p = strdup(str);
+  _wmkdir(p);
+  // cppcheck-suppress memleak
+}
+
+void test___wmkdir__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wmkdir(NULL);
+}
+
+void test___wmkdir__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wmkdir(x);
+}
+
+void test___abs64__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _abs64(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___abs64__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _abs64(arg1);
+}
+
+void test___abs64__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_abs64(arg1) > 10) || (_abs64(arg1) < 100)) {}
+}
+
+void test___abs64__leakignore() {
+  char *p = strdup(str);
+  result = _abs64(p);
+  // cppcheck-suppress memleak
+}
+
+void test___abs64__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _abs64(!x);
+}
+
+void test___abs64__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _abs64(x);
+}
+
+void test__CreateWaitableTimer__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = CreateWaitableTimer(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateWaitableTimer__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateWaitableTimer(arg1, arg2, arg3);
+}
+
+void test__CreateWaitableTimer__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWaitableTimer(x, arg2, arg3);
+}
+
+void test__CreateWaitableTimer__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWaitableTimer(arg1, x, arg3);
+}
+
+void test__CreateWaitableTimer__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateWaitableTimer(arg1, arg2, x);
+}
+
+void test__SetWaitableTimer__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetWaitableTimer(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetWaitableTimer__leakignore() {
+  char *p = strdup(str);
+  SetWaitableTimer(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__SetWaitableTimer__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetWaitableTimer(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__SetWaitableTimer__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  SetWaitableTimer(arg1, NULL, arg3, arg4, arg5, arg6);
+}
+
+void test__SetWaitableTimer__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetWaitableTimer(arg1, x, arg3, arg4, arg5, arg6);
+}
+
+void test__SetWaitableTimer__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetWaitableTimer(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__SetWaitableTimer__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetWaitableTimer(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__SetWaitableTimer__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetWaitableTimer(arg1, arg2, arg3, arg4, x, arg6);
+}
+
+void test__SetWaitableTimer__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetWaitableTimer(arg1, arg2, arg3, arg4, arg5, x);
+}
+
+void test__WaitForSingleObject__noreturn() {
+  int x = 100;
+  if (cond) x=1; else WaitForSingleObject(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__WaitForSingleObject__leakignore() {
+  char *p = strdup(str);
+  WaitForSingleObject(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__WaitForSingleObject__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WaitForSingleObject(x, arg2);
+}
+
+void test__WaitForSingleObject__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WaitForSingleObject(arg1, x);
+}
+
+void test___pclose__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _pclose(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___pclose__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _pclose(NULL);
+}
+
+void test___pclose__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _pclose(x);
+}
+
+void test___popen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _popen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___popen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _popen(arg1, arg2);
+}
+
+void test___popen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _popen(NULL, arg2);
+}
+
+void test___popen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _popen(x, arg2);
+}
+
+void test___popen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _popen(arg1, NULL);
+}
+
+void test___popen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _popen(arg1, x);
+}
+
+void test___wpopen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _wpopen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wpopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _wpopen(arg1, arg2);
+}
+
+void test___wpopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wpopen(NULL, arg2);
+}
+
+void test___wpopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wpopen(x, arg2);
+}
+
+void test___wpopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wpopen(arg1, NULL);
+}
+
+void test___wpopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wpopen(arg1, x);
+}
+
+void test___tpopen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _tpopen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tpopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tpopen(arg1, arg2);
+}
+
+void test___tpopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tpopen(NULL, arg2);
+}
+
+void test___tpopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tpopen(x, arg2);
+}
+
+void test___tpopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tpopen(arg1, NULL);
+}
+
+void test___tpopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tpopen(arg1, x);
+}
+
+void test___mktemp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mktemp(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mktemp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mktemp(arg1);
+}
+
+void test___mktemp__leakignore() {
+  char *p = strdup(str);
+  result = _mktemp(p);
+  // cppcheck-suppress memleak
+}
+
+void test___mktemp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mktemp(NULL);
+}
+
+void test___mktemp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mktemp(x);
+}
+
+void test___wmktemp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _wmktemp(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wmktemp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _wmktemp(arg1);
+}
+
+void test___wmktemp__leakignore() {
+  char *p = strdup(str);
+  result = _wmktemp(p);
+  // cppcheck-suppress memleak
+}
+
+void test___wmktemp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wmktemp(NULL);
+}
+
+void test___wmktemp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wmktemp(x);
+}
+
+void test__FindFirstFileEx__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = FindFirstFileEx(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FindFirstFileEx__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindFirstFileEx(arg1, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__FindFirstFileEx__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileEx(NULL, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__FindFirstFileEx__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileEx(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__FindFirstFileEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileEx(arg1, x, arg3, arg4, arg5, arg6);
+}
+
+void test__FindFirstFileEx__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileEx(arg1, arg2, NULL, arg4, arg5, arg6);
+}
+
+void test__FindFirstFileEx__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileEx(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__FindFirstFileEx__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileEx(arg1, arg2, arg3, arg4, arg5, x);
+}
+
+void test__FindFirstFileExA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = FindFirstFileExA(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FindFirstFileExA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindFirstFileExA(arg1, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__FindFirstFileExA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileExA(NULL, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__FindFirstFileExA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExA(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__FindFirstFileExA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExA(arg1, x, arg3, arg4, arg5, arg6);
+}
+
+void test__FindFirstFileExA__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileExA(arg1, arg2, NULL, arg4, arg5, arg6);
+}
+
+void test__FindFirstFileExA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExA(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__FindFirstFileExA__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExA(arg1, arg2, arg3, arg4, arg5, x);
+}
+
+void test__FindFirstFileExW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = FindFirstFileExW(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FindFirstFileExW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindFirstFileExW(arg1, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__FindFirstFileExW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileExW(NULL, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__FindFirstFileExW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExW(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__FindFirstFileExW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExW(arg1, x, arg3, arg4, arg5, arg6);
+}
+
+void test__FindFirstFileExW__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileExW(arg1, arg2, NULL, arg4, arg5, arg6);
+}
+
+void test__FindFirstFileExW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExW(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__FindFirstFileExW__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileExW(arg1, arg2, arg3, arg4, arg5, x);
+}
+
+void test__FindFirstFile__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = FindFirstFile(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FindFirstFile__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindFirstFile(arg1, arg2);
+}
+
+void test__FindFirstFile__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFile(NULL, arg2);
+}
+
+void test__FindFirstFile__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindFirstFile(x, arg2);
+}
+
+void test__FindFirstFile__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFile(arg1, NULL);
+}
+
+void test__FindFirstFileW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = FindFirstFileW(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FindFirstFileW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindFirstFileW(arg1, arg2);
+}
+
+void test__FindFirstFileW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileW(NULL, arg2);
+}
+
+void test__FindFirstFileW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileW(x, arg2);
+}
+
+void test__FindFirstFileW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileW(arg1, NULL);
+}
+
+void test__FindFirstFileA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = FindFirstFileA(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FindFirstFileA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindFirstFileA(arg1, arg2);
+}
+
+void test__FindFirstFileA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileA(NULL, arg2);
+}
+
+void test__FindFirstFileA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindFirstFileA(x, arg2);
+}
+
+void test__FindFirstFileA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindFirstFileA(arg1, NULL);
+}
+
+void test__FindClose__noreturn() {
+  int x = 100;
+  if (cond) x=1; else FindClose(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FindClose__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  FindClose(NULL);
+}
+
+void test__FindClose__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  FindClose(x);
+}
+
+void test__CreateThread__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = CreateThread(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateThread__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  CreateThread(arg1, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__CreateThread__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateThread(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__CreateThread__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateThread(arg1, x, arg3, arg4, arg5, arg6);
+}
+
+void test__CreateThread__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateThread(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__CreateThread__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateThread(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__CreateThread__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = CreateThread(arg1, arg2, arg3, arg4, x, arg6);
+}
+
+void test__FindNextFile__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = FindNextFile(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FindNextFile__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindNextFile(arg1, arg2);
+}
+
+void test__FindNextFile__leakignore() {
+  char *p = strdup(str);
+  result = FindNextFile(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__FindNextFile__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindNextFile(NULL, arg2);
+}
+
+void test__FindNextFile__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindNextFile(x, arg2);
+}
+
+void test__FindNextFile__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindNextFile(arg1, NULL);
+}
+
+void test__FindNextFileW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = FindNextFileW(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FindNextFileW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindNextFileW(arg1, arg2);
+}
+
+void test__FindNextFileW__leakignore() {
+  char *p = strdup(str);
+  result = FindNextFileW(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__FindNextFileW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindNextFileW(NULL, arg2);
+}
+
+void test__FindNextFileW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindNextFileW(x, arg2);
+}
+
+void test__FindNextFileW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindNextFileW(arg1, NULL);
+}
+
+void test__FindNextFileA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = FindNextFileA(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FindNextFileA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  FindNextFileA(arg1, arg2);
+}
+
+void test__FindNextFileA__leakignore() {
+  char *p = strdup(str);
+  result = FindNextFileA(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__FindNextFileA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindNextFileA(NULL, arg2);
+}
+
+void test__FindNextFileA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = FindNextFileA(x, arg2);
+}
+
+void test__FindNextFileA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = FindNextFileA(arg1, NULL);
+}
+
+void test__SetEnvironmentVariable__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetEnvironmentVariable(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetEnvironmentVariable__leakignore() {
+  char *p = strdup(str);
+  SetEnvironmentVariable(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__SetEnvironmentVariable__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetEnvironmentVariable(x, arg2);
+}
+
+void test__SetEnvironmentVariableW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetEnvironmentVariableW(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetEnvironmentVariableW__leakignore() {
+  char *p = strdup(str);
+  SetEnvironmentVariableW(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__SetEnvironmentVariableW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetEnvironmentVariableW(x, arg2);
+}
+
+void test__SetEnvironmentVariableA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetEnvironmentVariableA(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetEnvironmentVariableA__leakignore() {
+  char *p = strdup(str);
+  SetEnvironmentVariableA(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__SetEnvironmentVariableA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetEnvironmentVariableA(x, arg2);
+}
+
+void test__QueryDosDevice__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QueryDosDevice(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QueryDosDevice__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QueryDosDevice(arg1, arg2, arg3);
+}
+
+void test__QueryDosDevice__leakignore() {
+  char *p = strdup(str);
+  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__QueryDosDevice__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QueryDosDevice(arg1, arg2, x);
+}
+
+void test__QueryDosDeviceW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QueryDosDeviceW(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QueryDosDeviceW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QueryDosDeviceW(arg1, arg2, arg3);
+}
+
+void test__QueryDosDeviceW__leakignore() {
+  char *p = strdup(str);
+  result = QueryDosDeviceW(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__QueryDosDeviceW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QueryDosDeviceW(x, arg2, arg3);
+}
+
+void test__QueryDosDeviceW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QueryDosDeviceW(arg1, arg2, x);
+}
+
+void test__QueryDosDeviceA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = QueryDosDeviceA(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__QueryDosDeviceA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  QueryDosDeviceA(arg1, arg2, arg3);
+}
+
+void test__QueryDosDeviceA__leakignore() {
+  char *p = strdup(str);
+  result = QueryDosDeviceA(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__QueryDosDeviceA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QueryDosDeviceA(x, arg2, arg3);
+}
+
+void test__QueryDosDeviceA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = QueryDosDeviceA(arg1, arg2, x);
+}
+
+void test__GetDefaultCommConfig__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = GetDefaultCommConfig(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetDefaultCommConfig__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetDefaultCommConfig(arg1, arg2, arg3);
+}
+
+void test__GetDefaultCommConfig__leakignore() {
+  char *p = strdup(str);
+  result = GetDefaultCommConfig(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__GetDefaultCommConfig__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetDefaultCommConfig(x, arg2, arg3);
+}
+
+void test__GetDefaultCommConfig__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetDefaultCommConfig(arg1, NULL, arg3);
+}
+
+void test__GetDefaultCommConfigW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = GetDefaultCommConfigW(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetDefaultCommConfigW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetDefaultCommConfigW(arg1, arg2, arg3);
+}
+
+void test__GetDefaultCommConfigW__leakignore() {
+  char *p = strdup(str);
+  result = GetDefaultCommConfigW(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__GetDefaultCommConfigW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetDefaultCommConfigW(x, arg2, arg3);
+}
+
+void test__GetDefaultCommConfigW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetDefaultCommConfigW(arg1, NULL, arg3);
+}
+
+void test__GetDefaultCommConfigA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = GetDefaultCommConfigA(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetDefaultCommConfigA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetDefaultCommConfigA(arg1, arg2, arg3);
+}
+
+void test__GetDefaultCommConfigA__leakignore() {
+  char *p = strdup(str);
+  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__GetDefaultCommConfigA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetDefaultCommConfigA(arg1, NULL, arg3);
+}
+
+void test__GetTempPath__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetTempPath(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetTempPath__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else GetTempPathW(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetTempPathW__leakignore() {
+  char *p = strdup(str);
+  GetTempPathW(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__GetTempPathW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetTempPathW(x, arg2);
+}
+
+void test__GetTempPathA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetTempPathA(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetTempPathA__leakignore() {
+  char *p = strdup(str);
+  GetTempPathA(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__GetTempPathA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetTempPathA(x, arg2);
+}
+
+void test__SetupDiDestroyDeviceInfoList__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetupDiDestroyDeviceInfoList(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetupDiDestroyDeviceInfoList__leakignore() {
+  char *p = strdup(str);
+  SetupDiDestroyDeviceInfoList(p);
+  // cppcheck-suppress memleak
+}
+
+void test__SetupDiDestroyDeviceInfoList__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiDestroyDeviceInfoList(x);
+}
+
+void test__SetupDiGetDeviceInstanceId__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetupDiGetDeviceInstanceId(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetupDiGetDeviceInstanceId__leakignore() {
+  char *p = strdup(str);
+  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__SetupDiGetDeviceInstanceId__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiGetDeviceInstanceId(arg1, arg2, arg3, x, arg5);
+}
+
+void test__SetupDiEnumDeviceInfo__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetupDiEnumDeviceInfo(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetupDiEnumDeviceInfo__leakignore() {
+  char *p = strdup(str);
+  SetupDiEnumDeviceInfo(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__SetupDiEnumDeviceInfo__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiEnumDeviceInfo(x, arg2, arg3);
+}
+
+void test__SetupDiEnumDeviceInfo__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiEnumDeviceInfo(arg1, x, arg3);
+}
+
+void test__SetupDiGetClassDevs__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetupDiGetClassDevs(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetupDiGetClassDevs__leakignore() {
+  char *p = strdup(str);
+  SetupDiGetClassDevs(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__SetupDiGetClassDevs__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiGetClassDevs(arg1, x, arg3, arg4);
+}
+
+void test__SetupDiGetClassDevs__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiGetClassDevs(arg1, arg2, x, arg4);
+}
+
+void test__SetupDiGetClassDevs__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetupDiGetClassDevs(arg1, arg2, arg3, x);
+}
+
+void test___mbsstr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mbsstr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbsstr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsstr(arg1, arg2);
+}
+
+void test___mbsstr__leakignore() {
+  char *p = strdup(str);
+  result = _mbsstr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___mbsstr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsstr(NULL, arg2);
+}
+
+void test___mbsstr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsstr(x, arg2);
+}
+
+void test___mbsstr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsstr(arg1, NULL);
+}
+
+void test___mbsstr__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsstr(arg1, x);
+}
+
+void test___tcsstr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _tcsstr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcsstr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcsstr(arg1, arg2);
+}
+
+void test___tcsstr__leakignore() {
+  char *p = strdup(str);
+  result = _tcsstr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___tcsstr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsstr(NULL, arg2);
+}
+
+void test___tcsstr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsstr(x, arg2);
+}
+
+void test___tcsstr__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsstr(arg1, NULL);
+}
+
+void test___tcsstr__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsstr(arg1, x);
+}
+
+void test___mbsstr_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mbsstr_l(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbsstr_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsstr_l(arg1, arg2, arg3);
+}
+
+void test___mbsstr_l__leakignore() {
+  char *p = strdup(str);
+  result = _mbsstr_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___mbsstr_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsstr_l(NULL, arg2, arg3);
+}
+
+void test___mbsstr_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsstr_l(x, arg2, arg3);
+}
+
+void test___mbsstr_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsstr_l(arg1, NULL, arg3);
+}
+
+void test___mbsstr_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsstr_l(arg1, x, arg3);
+}
+
+void test___mbsstr_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsstr_l(arg1, arg2, x);
+}
+
+void test___memccpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _memccpy(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___memccpy__leakignore() {
+  char *p = strdup(str);
+  _memccpy(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___memccpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _memccpy(NULL, arg2, arg3, arg4);
+}
+
+void test___memccpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _memccpy(arg1, NULL, arg3, arg4);
+}
+
+void test___memccpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _memccpy(arg1, x, arg3, arg4);
+}
+
+void test___memccpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _memccpy(arg1, arg2, x, arg4);
+}
+
+void test___memccpy__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _memccpy(arg1, arg2, arg3, x);
+}
+
+void test___fcloseall__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _fcloseall();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___open__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _open(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___open__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _open(arg1, arg2, arg3);
+}
+
+void test___open__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _open(NULL, arg2, arg3);
+}
+
+void test___open__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _open(x, arg2, arg3);
+}
+
+void test___open__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _open(arg1, x, arg3);
+}
+
+void test___open__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _open(arg1, arg2, x);
+}
+
+void test___wopen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _wopen(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _wopen(arg1, arg2, arg3);
+}
+
+void test___wopen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wopen(NULL, arg2, arg3);
+}
+
+void test___wopen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wopen(x, arg2, arg3);
+}
+
+void test___wopen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _wopen(arg1, x, arg3);
+}
+
+void test___wopen__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _wopen(arg1, arg2, x);
+}
+
+void test___topen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _topen(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___topen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _topen(arg1, arg2, arg3);
+}
+
+void test___topen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _topen(NULL, arg2, arg3);
+}
+
+void test___topen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _topen(x, arg2, arg3);
+}
+
+void test___topen__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _topen(arg1, x, arg3);
+}
+
+void test___topen__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _topen(arg1, arg2, x);
+}
+
+void test___close__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _close(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___close__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _close(x);
+}
+
+void test___swab__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _swab(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___swab__leakignore() {
+  char *p = strdup(str);
+  _swab(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___swab__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _swab(NULL, arg2, arg3);
+}
+
+void test___swab__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _swab(arg1, NULL, arg3);
+}
+
+void test___swab__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _swab(arg1, x, arg3);
+}
+
+void test___swab__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _swab(arg1, arg2, !x);
+}
+
+void test___swab__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _swab(arg1, arg2, x);
+}
+
+void test___strnicmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _strnicmp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___strnicmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _strnicmp(arg1, arg2, arg3);
+}
+
+void test___strnicmp__leakignore() {
+  char *p = strdup(str);
+  result = _strnicmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___strnicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _strnicmp(NULL, arg2, arg3);
+}
+
+void test___strnicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _strnicmp(x, arg2, arg3);
+}
+
+void test___strnicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _strnicmp(arg1, NULL, arg3);
+}
+
+void test___strnicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _strnicmp(arg1, x, arg3);
+}
+
+void test___strnicmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _strnicmp(arg1, arg2, !x);
+}
+
+void test___strnicmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _strnicmp(arg1, arg2, x);
+}
+
+void test___wcsnicmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _wcsnicmp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wcsnicmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _wcsnicmp(arg1, arg2, arg3);
+}
+
+void test___wcsnicmp__leakignore() {
+  char *p = strdup(str);
+  result = _wcsnicmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___wcsnicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wcsnicmp(NULL, arg2, arg3);
+}
+
+void test___wcsnicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wcsnicmp(x, arg2, arg3);
+}
+
+void test___wcsnicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wcsnicmp(arg1, NULL, arg3);
+}
+
+void test___wcsnicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wcsnicmp(arg1, x, arg3);
+}
+
+void test___wcsnicmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _wcsnicmp(arg1, arg2, !x);
+}
+
+void test___wcsnicmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _wcsnicmp(arg1, arg2, x);
+}
+
+void test___mbsnicmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mbsnicmp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbsnicmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsnicmp(arg1, arg2, arg3);
+}
+
+void test___mbsnicmp__leakignore() {
+  char *p = strdup(str);
+  result = _mbsnicmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___mbsnicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsnicmp(NULL, arg2, arg3);
+}
+
+void test___mbsnicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsnicmp(x, arg2, arg3);
+}
+
+void test___mbsnicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsnicmp(arg1, NULL, arg3);
+}
+
+void test___mbsnicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsnicmp(arg1, x, arg3);
+}
+
+void test___mbsnicmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _mbsnicmp(arg1, arg2, !x);
+}
+
+void test___mbsnicmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsnicmp(arg1, arg2, x);
+}
+
+void test___tcsncicmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _tcsncicmp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcsncicmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcsncicmp(arg1, arg2, arg3);
+}
+
+void test___tcsncicmp__leakignore() {
+  char *p = strdup(str);
+  result = _tcsncicmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___tcsncicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsncicmp(NULL, arg2, arg3);
+}
+
+void test___tcsncicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsncicmp(x, arg2, arg3);
+}
+
+void test___tcsncicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsncicmp(arg1, NULL, arg3);
+}
+
+void test___tcsncicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsncicmp(arg1, x, arg3);
+}
+
+void test___tcsncicmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _tcsncicmp(arg1, arg2, !x);
+}
+
+void test___tcsncicmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tcsncicmp(arg1, arg2, x);
+}
+
+void test___tcsnicmp__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _tcsnicmp(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcsnicmp__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcsnicmp(arg1, arg2, arg3);
+}
+
+void test___tcsnicmp__leakignore() {
+  char *p = strdup(str);
+  result = _tcsnicmp(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___tcsnicmp__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsnicmp(NULL, arg2, arg3);
+}
+
+void test___tcsnicmp__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsnicmp(x, arg2, arg3);
+}
+
+void test___tcsnicmp__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsnicmp(arg1, NULL, arg3);
+}
+
+void test___tcsnicmp__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsnicmp(arg1, x, arg3);
+}
+
+void test___tcsnicmp__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _tcsnicmp(arg1, arg2, !x);
+}
+
+void test___tcsnicmp__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tcsnicmp(arg1, arg2, x);
+}
+
+void test___strnicmp_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _strnicmp_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___strnicmp_l__leakignore() {
+  char *p = strdup(str);
+  result = _strnicmp_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___strnicmp_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _strnicmp_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___strnicmp_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _strnicmp_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___strnicmp_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _strnicmp_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___strnicmp_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _strnicmp_l(arg1, arg2, arg3, x);
+}
+
+void test___wcsnicmp_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _wcsnicmp_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___wcsnicmp_l__leakignore() {
+  char *p = strdup(str);
+  result = _wcsnicmp_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___wcsnicmp_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wcsnicmp_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___wcsnicmp_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wcsnicmp_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___wcsnicmp_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _wcsnicmp_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___wcsnicmp_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _wcsnicmp_l(arg1, arg2, arg3, x);
+}
+
+void test___mbsnicmp_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mbsnicmp_l(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbsnicmp_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsnicmp_l(arg1, arg2, arg3, arg4);
+}
+
+void test___mbsnicmp_l__leakignore() {
+  char *p = strdup(str);
+  result = _mbsnicmp_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___mbsnicmp_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsnicmp_l(NULL, arg2, arg3, arg4);
+}
+
+void test___mbsnicmp_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsnicmp_l(x, arg2, arg3, arg4);
+}
+
+void test___mbsnicmp_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsnicmp_l(arg1, NULL, arg3, arg4);
+}
+
+void test___mbsnicmp_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsnicmp_l(arg1, x, arg3, arg4);
+}
+
+void test___mbsnicmp_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _mbsnicmp_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___mbsnicmp_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsnicmp_l(arg1, arg2, arg3, x);
+}
+
+void test___tcsncicmp_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _tcsncicmp_l(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcsncicmp_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcsncicmp_l(arg1, arg2, arg3, arg4);
+}
+
+void test___tcsncicmp_l__leakignore() {
+  char *p = strdup(str);
+  result = _tcsncicmp_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___tcsncicmp_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsncicmp_l(NULL, arg2, arg3, arg4);
+}
+
+void test___tcsncicmp_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsncicmp_l(x, arg2, arg3, arg4);
+}
+
+void test___tcsncicmp_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsncicmp_l(arg1, NULL, arg3, arg4);
+}
+
+void test___tcsncicmp_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsncicmp_l(arg1, x, arg3, arg4);
+}
+
+void test___tcsncicmp_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _tcsncicmp_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___tcsncicmp_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tcsncicmp_l(arg1, arg2, arg3, x);
+}
+
+void test___malloc_dbg__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _malloc_dbg(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___malloc_dbg__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _malloc_dbg(arg1, arg2, arg3, arg4);
+}
+
+void test___malloc_dbg__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _malloc_dbg(x, arg2, arg3, arg4);
+}
+
+void test___malloc_dbg__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _malloc_dbg(arg1, x, arg3, arg4);
+}
+
+void test___malloc_dbg__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _malloc_dbg(arg1, arg2, x, arg4);
+}
+
+void test___malloc_dbg__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _malloc_dbg(arg1, arg2, arg3, x);
+}
+
+void test___aligned_malloc_dbg__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _aligned_malloc_dbg(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___aligned_malloc_dbg__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _aligned_malloc_dbg(arg1, arg2, arg3, arg4);
+}
+
+void test___aligned_malloc_dbg__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _aligned_malloc_dbg(x, arg2, arg3, arg4);
+}
+
+void test___aligned_malloc_dbg__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _aligned_malloc_dbg(arg1, x, arg3, arg4);
+}
+
+void test___aligned_malloc_dbg__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _aligned_malloc_dbg(arg1, arg2, x, arg4);
+}
+
+void test___aligned_malloc_dbg__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _aligned_malloc_dbg(arg1, arg2, arg3, x);
+}
+
+void test___aligned_malloc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _aligned_malloc(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___aligned_malloc__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _aligned_malloc(arg1, arg2);
+}
+
+void test___aligned_malloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _aligned_malloc(x, arg2);
+}
+
+void test___aligned_malloc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _aligned_malloc(arg1, x);
+}
+
+void test___mbslen_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mbslen_l(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbslen_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbslen_l(arg1, arg2);
+}
+
+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_l__leakignore() {
+  char *p = strdup(str);
+  result = _mbslen_l(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___mbslen_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbslen_l(NULL, arg2);
+}
+
+void test___mbslen_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbslen_l(x, arg2);
+}
+
+void test___mbslen_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbslen_l(arg1, x);
+}
+
+void test___mbstrlen_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mbstrlen_l(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbstrlen_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbstrlen_l(arg1, arg2);
+}
+
+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_l__leakignore() {
+  char *p = strdup(str);
+  result = _mbstrlen_l(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___mbstrlen_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbstrlen_l(NULL, arg2);
+}
+
+void test___mbstrlen_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbstrlen_l(x, arg2);
+}
+
+void test___mbstrlen_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbstrlen_l(arg1, x);
+}
+
+void test___tcsclen_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _tcsclen_l(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcsclen_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcsclen_l(arg1, arg2);
+}
+
+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___tcsclen_l__leakignore() {
+  char *p = strdup(str);
+  result = _tcsclen_l(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___tcsclen_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsclen_l(NULL, arg2);
+}
+
+void test___tcsclen_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsclen_l(x, arg2);
+}
+
+void test___tcsclen_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tcsclen_l(arg1, x);
+}
+
+void test___mbslen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mbslen(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbslen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbslen(arg1);
+}
+
+void test___mbslen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_mbslen(arg1) > 10) || (_mbslen(arg1) < 100)) {}
+}
+
+void test___mbslen__leakignore() {
+  char *p = strdup(str);
+  result = _mbslen(p);
+  // cppcheck-suppress memleak
+}
+
+void test___mbslen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbslen(NULL);
+}
+
+void test___mbslen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbslen(x);
+}
+
+void test___mbstrlen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mbstrlen(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbstrlen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbstrlen(arg1);
+}
+
+void test___mbstrlen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_mbstrlen(arg1) > 10) || (_mbstrlen(arg1) < 100)) {}
+}
+
+void test___mbstrlen__leakignore() {
+  char *p = strdup(str);
+  result = _mbstrlen(p);
+  // cppcheck-suppress memleak
+}
+
+void test___mbstrlen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbstrlen(NULL);
+}
+
+void test___mbstrlen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbstrlen(x);
+}
+
+void test___tcslen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _tcslen(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcslen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcslen(arg1);
+}
+
+void test___tcslen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_tcslen(arg1) > 10) || (_tcslen(arg1) < 100)) {}
+}
+
+void test___tcslen__leakignore() {
+  char *p = strdup(str);
+  result = _tcslen(p);
+  // cppcheck-suppress memleak
+}
+
+void test___tcslen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcslen(NULL);
+}
+
+void test___tcslen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcslen(x);
+}
+
+void test___tcsclen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _tcsclen(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcsclen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcsclen(arg1);
+}
+
+void test___tcsclen__pure(int arg1) {
+  // cppcheck-suppress incorrectLogicOperator
+  if ((_tcsclen(arg1) > 10) || (_tcsclen(arg1) < 100)) {}
+}
+
+void test___tcsclen__leakignore() {
+  char *p = strdup(str);
+  result = _tcsclen(p);
+  // cppcheck-suppress memleak
+}
+
+void test___tcsclen__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsclen(NULL);
+}
+
+void test___tcsclen__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsclen(x);
+}
+
+void test___mbsrchr_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mbsrchr_l(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbsrchr_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsrchr_l(arg1, arg2, arg3);
+}
+
+void test___mbsrchr_l__leakignore() {
+  char *p = strdup(str);
+  result = _mbsrchr_l(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___mbsrchr_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsrchr_l(NULL, arg2, arg3);
+}
+
+void test___mbsrchr_l__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsrchr_l(x, arg2, arg3);
+}
+
+void test___mbsrchr_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsrchr_l(arg1, x, arg3);
+}
+
+void test___mbsrchr_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsrchr_l(arg1, arg2, x);
+}
+
+void test___mbsrchr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _mbsrchr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbsrchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _mbsrchr(arg1, arg2);
+}
+
+void test___mbsrchr__leakignore() {
+  char *p = strdup(str);
+  result = _mbsrchr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___mbsrchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _mbsrchr(NULL, arg2);
+}
+
+void test___mbsrchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _mbsrchr(x, arg2);
+}
+
+void test___mbsrchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _mbsrchr(arg1, x);
+}
+
+void test___tcsrchr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _tcsrchr(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcsrchr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tcsrchr(arg1, arg2);
+}
+
+void test___tcsrchr__leakignore() {
+  char *p = strdup(str);
+  result = _tcsrchr(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___tcsrchr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tcsrchr(NULL, arg2);
+}
+
+void test___tcsrchr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tcsrchr(x, arg2);
+}
+
+void test___tcsrchr__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tcsrchr(arg1, x);
+}
+
+void test___strftime_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _strftime_l(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___strftime_l__leakignore() {
+  char *p = strdup(str);
+  _strftime_l(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test___strftime_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _strftime_l(NULL, arg2, arg3, arg4, arg5);
+}
+
+void test___strftime_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strftime_l(arg1, x, arg3, arg4, arg5);
+}
+
+void test___strftime_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _strftime_l(arg1, arg2, NULL, arg4, arg5);
+}
+
+void test___strftime_l__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _strftime_l(arg1, arg2, x, arg4, arg5);
+}
+
+void test___strftime_l__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _strftime_l(arg1, arg2, arg3, NULL, arg5);
+}
+
+void test___strftime_l__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _strftime_l(arg1, arg2, arg3, x, arg5);
+}
+
+void test___strftime_l__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strftime_l(arg1, arg2, arg3, arg4, x);
+}
+
+void test___wcsftime_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wcsftime_l(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wcsftime_l__leakignore() {
+  char *p = strdup(str);
+  _wcsftime_l(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test___wcsftime_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsftime_l(NULL, arg2, arg3, arg4, arg5);
+}
+
+void test___wcsftime_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsftime_l(arg1, x, arg3, arg4, arg5);
+}
+
+void test___wcsftime_l__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsftime_l(arg1, arg2, NULL, arg4, arg5);
+}
+
+void test___wcsftime_l__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsftime_l(arg1, arg2, x, arg4, arg5);
+}
+
+void test___wcsftime_l__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsftime_l(arg1, arg2, arg3, NULL, arg5);
+}
+
+void test___wcsftime_l__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsftime_l(arg1, arg2, arg3, x, arg5);
+}
+
+void test___wcsftime_l__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsftime_l(arg1, arg2, arg3, arg4, x);
+}
+
+void test___tcsftime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tcsftime(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcsftime__leakignore() {
+  char *p = strdup(str);
+  _tcsftime(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___tcsftime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsftime(NULL, arg2, arg3, arg4);
+}
+
+void test___tcsftime__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcsftime(arg1, x, arg3, arg4);
+}
+
+void test___tcsftime__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsftime(arg1, arg2, NULL, arg4);
+}
+
+void test___tcsftime__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsftime(arg1, arg2, x, arg4);
+}
+
+void test___tcsftime__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsftime(arg1, arg2, arg3, NULL);
+}
+
+void test___tcsftime__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsftime(arg1, arg2, arg3, x);
+}
+
+void test___wfreopen_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _wfreopen_s(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wfreopen_s__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _wfreopen_s(arg1, arg2, arg3, arg4);
+}
+
+void test___wfreopen_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _wfreopen_s(x, arg2, arg3, arg4);
+}
+
+void test___wfreopen_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _wfreopen_s(arg1, x, arg3, arg4);
+}
+
+void test___wfreopen_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wfreopen_s(arg1, arg2, NULL, arg4);
+}
+
+void test___wfreopen_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wfreopen_s(arg1, arg2, x, arg4);
+}
+
+void test___wfreopen_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wfreopen_s(arg1, arg2, arg3, NULL);
+}
+
+void test___wfreopen_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wfreopen_s(arg1, arg2, arg3, x);
+}
+
+void test___tfreopen_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _tfreopen_s(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tfreopen_s__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tfreopen_s(arg1, arg2, arg3, arg4);
+}
+
+void test___tfreopen_s__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tfreopen_s(x, arg2, arg3, arg4);
+}
+
+void test___tfreopen_s__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tfreopen_s(arg1, x, arg3, arg4);
+}
+
+void test___tfreopen_s__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tfreopen_s(arg1, arg2, NULL, arg4);
+}
+
+void test___tfreopen_s__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tfreopen_s(arg1, arg2, x, arg4);
+}
+
+void test___tfreopen_s__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tfreopen_s(arg1, arg2, arg3, NULL);
+}
+
+void test___tfreopen_s__arg4__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tfreopen_s(arg1, arg2, arg3, x);
+}
+
+void test___wfreopen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _wfreopen(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wfreopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _wfreopen(arg1, arg2, arg3);
+}
+
+void test___wfreopen__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _wfreopen(x, arg2, arg3);
+}
+
+void test___wfreopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wfreopen(arg1, NULL, arg3);
+}
+
+void test___wfreopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wfreopen(arg1, x, arg3);
+}
+
+void test___wfreopen__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _wfreopen(arg1, arg2, NULL);
+}
+
+void test___wfreopen__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _wfreopen(arg1, arg2, x);
+}
+
+void test___tfreopen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _tfreopen(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tfreopen__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tfreopen(arg1, arg2, arg3);
+}
+
+void test___tfreopen__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tfreopen(x, arg2, arg3);
+}
+
+void test___tfreopen__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tfreopen(arg1, NULL, arg3);
+}
+
+void test___tfreopen__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tfreopen(arg1, x, arg3);
+}
+
+void test___tfreopen__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _tfreopen(arg1, arg2, NULL);
+}
+
+void test___tfreopen__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _tfreopen(arg1, arg2, x);
+}
+
+void test___mbsncpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _mbsncpy(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbsncpy__leakignore() {
+  char *p = strdup(str);
+  _mbsncpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___mbsncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsncpy(NULL, arg2, arg3);
+}
+
+void test___mbsncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsncpy(arg1, NULL, arg3);
+}
+
+void test___mbsncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsncpy(arg1, x, arg3);
+}
+
+void test___mbsncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _mbsncpy(arg1, arg2, !x);
+}
+
+void test___mbsncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbsncpy(arg1, arg2, x);
+}
+
+void test___mbsnbcpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _mbsnbcpy(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbsnbcpy__leakignore() {
+  char *p = strdup(str);
+  _mbsnbcpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___mbsnbcpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsnbcpy(NULL, arg2, arg3);
+}
+
+void test___mbsnbcpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsnbcpy(arg1, NULL, arg3);
+}
+
+void test___mbsnbcpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsnbcpy(arg1, x, arg3);
+}
+
+void test___mbsnbcpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _mbsnbcpy(arg1, arg2, !x);
+}
+
+void test___mbsnbcpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbsnbcpy(arg1, arg2, x);
+}
+
+void test___tcsncpy__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tcsncpy(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcsncpy__leakignore() {
+  char *p = strdup(str);
+  _tcsncpy(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test___tcsncpy__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsncpy(NULL, arg2, arg3);
+}
+
+void test___tcsncpy__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsncpy(arg1, NULL, arg3);
+}
+
+void test___tcsncpy__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsncpy(arg1, x, arg3);
+}
+
+void test___tcsncpy__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _tcsncpy(arg1, arg2, !x);
+}
+
+void test___tcsncpy__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcsncpy(arg1, arg2, x);
+}
+
+void test___strncpy_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _strncpy_l(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___strncpy_l__leakignore() {
+  char *p = strdup(str);
+  _strncpy_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___strncpy_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _strncpy_l(NULL, arg2, arg3, arg4);
+}
+
+void test___strncpy_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _strncpy_l(arg1, NULL, arg3, arg4);
+}
+
+void test___strncpy_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _strncpy_l(arg1, x, arg3, arg4);
+}
+
+void test___strncpy_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _strncpy_l(arg1, arg2, !x, arg4);
+}
+
+void test___strncpy_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strncpy_l(arg1, arg2, x, arg4);
+}
+
+void test___strncpy_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _strncpy_l(arg1, arg2, arg3, x);
+}
+
+void test___wcsncpy_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _wcsncpy_l(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___wcsncpy_l__leakignore() {
+  char *p = strdup(str);
+  _wcsncpy_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___wcsncpy_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsncpy_l(NULL, arg2, arg3, arg4);
+}
+
+void test___wcsncpy_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _wcsncpy_l(arg1, NULL, arg3, arg4);
+}
+
+void test___wcsncpy_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _wcsncpy_l(arg1, x, arg3, arg4);
+}
+
+void test___wcsncpy_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _wcsncpy_l(arg1, arg2, !x, arg4);
+}
+
+void test___wcsncpy_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsncpy_l(arg1, arg2, x, arg4);
+}
+
+void test___wcsncpy_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _wcsncpy_l(arg1, arg2, arg3, x);
+}
+
+void test___mbsncpy_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _mbsncpy_l(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___mbsncpy_l__leakignore() {
+  char *p = strdup(str);
+  _mbsncpy_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___mbsncpy_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsncpy_l(NULL, arg2, arg3, arg4);
+}
+
+void test___mbsncpy_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _mbsncpy_l(arg1, NULL, arg3, arg4);
+}
+
+void test___mbsncpy_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _mbsncpy_l(arg1, x, arg3, arg4);
+}
+
+void test___mbsncpy_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _mbsncpy_l(arg1, arg2, !x, arg4);
+}
+
+void test___mbsncpy_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbsncpy_l(arg1, arg2, x, arg4);
+}
+
+void test___mbsncpy_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _mbsncpy_l(arg1, arg2, arg3, x);
+}
+
+void test___tcsncpy_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _tcsncpy_l(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tcsncpy_l__leakignore() {
+  char *p = strdup(str);
+  _tcsncpy_l(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test___tcsncpy_l__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsncpy_l(NULL, arg2, arg3, arg4);
+}
+
+void test___tcsncpy_l__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _tcsncpy_l(arg1, NULL, arg3, arg4);
+}
+
+void test___tcsncpy_l__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  _tcsncpy_l(arg1, x, arg3, arg4);
+}
+
+void test___tcsncpy_l__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  _tcsncpy_l(arg1, arg2, !x, arg4);
+}
+
+void test___tcsncpy_l__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcsncpy_l(arg1, arg2, x, arg4);
+}
+
+void test___tcsncpy_l__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _tcsncpy_l(arg1, arg2, arg3, x);
+}
+
+void test___localtime32_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _localtime32_s(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___localtime32_s__leakignore() {
+  char *p = strdup(str);
+  _localtime32_s(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___localtime32_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _localtime32_s(NULL, arg2);
+}
+
+void test___localtime32_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _localtime32_s(arg1, NULL);
+}
+
+void test___localtime64_s__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _localtime64_s(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___localtime64_s__leakignore() {
+  char *p = strdup(str);
+  _localtime64_s(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___localtime64_s__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  _localtime64_s(NULL, arg2);
+}
+
+void test___localtime64_s__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  _localtime64_s(arg1, NULL);
+}
+
+void test__CreateDirectory__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateDirectory(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateDirectory__leakignore() {
+  char *p = strdup(str);
+  CreateDirectory(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__CreateDirectory__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateDirectory(x, arg2);
+}
+
+void test__CreateDirectory__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateDirectory(arg1, x);
+}
+
+void test__CreateDirectoryA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateDirectoryA(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateDirectoryA__leakignore() {
+  char *p = strdup(str);
+  CreateDirectoryA(p, arg2);
+  // 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 = 100;
+  if (cond) x=1; else CreateDirectoryW(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateDirectoryW__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else RemoveDirectory(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RemoveDirectory__leakignore() {
+  char *p = strdup(str);
+  RemoveDirectory(p);
+  // cppcheck-suppress memleak
+}
+
+void test__RemoveDirectory__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RemoveDirectory(x);
+}
+
+void test__RemoveDirectoryA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RemoveDirectoryA(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RemoveDirectoryA__leakignore() {
+  char *p = strdup(str);
+  RemoveDirectoryA(p);
+  // cppcheck-suppress memleak
+}
+
+void test__RemoveDirectoryA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RemoveDirectoryA(x);
+}
+
+void test__RemoveDirectoryW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else RemoveDirectoryW(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__RemoveDirectoryW__leakignore() {
+  char *p = strdup(str);
+  RemoveDirectoryW(p);
+  // cppcheck-suppress memleak
+}
+
+void test__RemoveDirectoryW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  RemoveDirectoryW(x);
+}
+
+void test____isascii__noreturn() {
+  int x = 100;
+  if (cond) x=1; else __isascii(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test____isascii__leakignore() {
+  char *p = strdup(str);
+  __isascii(p);
+  // cppcheck-suppress memleak
+}
+
+void test____isascii__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  __isascii(x);
+}
+
+void test__iswascii__noreturn() {
+  int x = 100;
+  if (cond) x=1; else iswascii(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__iswascii__leakignore() {
+  char *p = strdup(str);
+  iswascii(p);
+  // cppcheck-suppress memleak
+}
+
+void test__iswascii__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  iswascii(x);
+}
+
+void test___getchar__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _getchar();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___getchar__leakignore() {
+  char *p = strdup(str);
+  _getchar();
+  // cppcheck-suppress memleak
+}
+
+void test___getch_nolock__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _getch_nolock();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___getch_nolock__leakignore() {
+  char *p = strdup(str);
+  _getch_nolock();
+  // cppcheck-suppress memleak
+}
+
+void test___getwch__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _getwch();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___getwch__leakignore() {
+  char *p = strdup(str);
+  _getwch();
+  // cppcheck-suppress memleak
+}
+
+void test___getwch_nolock__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _getwch_nolock();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___getwch_nolock__leakignore() {
+  char *p = strdup(str);
+  _getwch_nolock();
+  // cppcheck-suppress memleak
+}
+
+void test__Sleep__noreturn() {
+  int x = 100;
+  if (cond) x=1; else Sleep(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__Sleep__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else SleepEx(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SleepEx__leakignore() {
+  char *p = strdup(str);
+  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__LoadLibrary__noreturn() {
+  int x = 100;
+  if (cond) x=1; else LoadLibrary(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__LoadLibrary__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  LoadLibrary(NULL);
+}
+
+void test__LoadLibrary__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  LoadLibrary(x);
+}
+
+void test__LoadLibraryA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else LoadLibraryA(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__LoadLibraryA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  LoadLibraryA(NULL);
+}
+
+void test__LoadLibraryA__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  LoadLibraryA(x);
+}
+
+void test__LoadLibraryW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else LoadLibraryW(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__LoadLibraryW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  LoadLibraryW(NULL);
+}
+
+void test__LoadLibraryW__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  LoadLibraryW(x);
+}
+
+void test__LoadLibraryEx__noreturn() {
+  int x = 100;
+  if (cond) x=1; else LoadLibraryEx(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__LoadLibraryEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  LoadLibraryEx(x, arg2, arg3);
+}
+
+void test__LoadLibraryEx__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  LoadLibraryEx(arg1, arg2, x);
+}
+
+void test__LoadLibraryExA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else LoadLibraryExA(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__LoadLibraryExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  LoadLibraryExA(x, arg2, arg3);
+}
+
+void test__LoadLibraryExA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  LoadLibraryExA(arg1, arg2, x);
+}
+
+void test__LoadLibraryExW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else LoadLibraryExW(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__LoadLibraryExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  LoadLibraryExW(x, arg2, arg3);
+}
+
+void test__LoadLibraryExW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  LoadLibraryExW(arg1, arg2, x);
+}
+
+void test__GetModuleHandle__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = GetModuleHandle(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetModuleHandle__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetModuleHandle(arg1);
+}
+
+void test__GetModuleHandle__leakignore() {
+  char *p = strdup(str);
+  result = GetModuleHandle(p);
+  // cppcheck-suppress memleak
+}
+
+void test__GetModuleHandle__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetModuleHandle(x);
+}
+
+void test__GetModuleHandleA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = GetModuleHandleA(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetModuleHandleA__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetModuleHandleA(arg1);
+}
+
+void test__GetModuleHandleA__leakignore() {
+  char *p = strdup(str);
+  result = GetModuleHandleA(p);
+  // cppcheck-suppress memleak
+}
+
+void test__GetModuleHandleA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetModuleHandleA(x);
+}
+
+void test__GetModuleHandleW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = GetModuleHandleW(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetModuleHandleW__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetModuleHandleW(arg1);
+}
+
+void test__GetModuleHandleW__leakignore() {
+  char *p = strdup(str);
+  result = GetModuleHandleW(p);
+  // cppcheck-suppress memleak
+}
+
+void test__GetModuleHandleW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetModuleHandleW(x);
+}
+
+void test__GetModuleHandleEx__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetModuleHandleEx(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetModuleHandleEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetModuleHandleEx(x, arg2, arg3);
+}
+
+void test__GetModuleHandleEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetModuleHandleEx(arg1, x, arg3);
+}
+
+void test__GetModuleHandleEx__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetModuleHandleEx(arg1, arg2, NULL);
+}
+
+void test__GetModuleHandleExA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetModuleHandleExA(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetModuleHandleExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetModuleHandleExA(x, arg2, arg3);
+}
+
+void test__GetModuleHandleExA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetModuleHandleExA(arg1, x, arg3);
+}
+
+void test__GetModuleHandleExA__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetModuleHandleExA(arg1, arg2, NULL);
+}
+
+void test__GetModuleHandleExW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetModuleHandleExW(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetModuleHandleExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetModuleHandleExW(x, arg2, arg3);
+}
+
+void test__GetModuleHandleExW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetModuleHandleExW(arg1, x, arg3);
+}
+
+void test__GetModuleHandleExW__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  GetModuleHandleExW(arg1, arg2, NULL);
+}
+
+void test__FreeLibrary__noreturn() {
+  int x = 100;
+  if (cond) x=1; else FreeLibrary(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FreeLibrary__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  FreeLibrary(!x);
+}
+
+void test__FreeLibrary__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  FreeLibrary(x);
+}
+
+void test__FreeLibraryAndExitThread__noreturn() {
+  int x = 100;
+  if (cond) x=1; else FreeLibraryAndExitThread(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FreeLibraryAndExitThread__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  FreeLibraryAndExitThread(!x, arg2);
+}
+
+void test__FreeLibraryAndExitThread__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  FreeLibraryAndExitThread(x, arg2);
+}
+
+void test__FreeLibraryAndExitThread__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  FreeLibraryAndExitThread(arg1, !x);
+}
+
+void test__FreeLibraryAndExitThread__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  FreeLibraryAndExitThread(arg1, x);
+}
+
+void test__GetProcAddress__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = GetProcAddress(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetProcAddress__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetProcAddress(arg1, arg2);
+}
+
+void test__GetProcAddress__leakignore() {
+  char *p = strdup(str);
+  result = GetProcAddress(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__GetProcAddress__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = GetProcAddress(!x, arg2);
+}
+
+void test__GetProcAddress__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = GetProcAddress(NULL, arg2);
+}
+
+void test__GetProcAddress__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = GetProcAddress(x, arg2);
+}
+
+void test__GetProcAddress__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = GetProcAddress(arg1, x);
+}
+
+void test__CreateEvent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateEvent(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateEvent__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEvent(!x, arg2, arg3, arg4);
+}
+
+void test__CreateEvent__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEvent(x, arg2, arg3, arg4);
+}
+
+void test__CreateEvent__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEvent(arg1, x, arg3, arg4);
+}
+
+void test__CreateEvent__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEvent(arg1, arg2, x, arg4);
+}
+
+void test__CreateEvent__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEvent(arg1, arg2, arg3, !x);
+}
+
+void test__CreateEvent__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEvent(arg1, arg2, arg3, x);
+}
+
+void test__CreateEventA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateEventA(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateEventA__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventA(!x, arg2, arg3, arg4);
+}
+
+void test__CreateEventA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventA(x, arg2, arg3, arg4);
+}
+
+void test__CreateEventA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventA(arg1, x, arg3, arg4);
+}
+
+void test__CreateEventA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventA(arg1, arg2, x, arg4);
+}
+
+void test__CreateEventA__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventA(arg1, arg2, arg3, !x);
+}
+
+void test__CreateEventA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventA(arg1, arg2, arg3, x);
+}
+
+void test__CreateEventW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateEventW(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateEventW__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventW(!x, arg2, arg3, arg4);
+}
+
+void test__CreateEventW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventW(x, arg2, arg3, arg4);
+}
+
+void test__CreateEventW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventW(arg1, x, arg3, arg4);
+}
+
+void test__CreateEventW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventW(arg1, arg2, x, arg4);
+}
+
+void test__CreateEventW__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventW(arg1, arg2, arg3, !x);
+}
+
+void test__CreateEventW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventW(arg1, arg2, arg3, x);
+}
+
+void test__CreateEventEx__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateEventEx(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateEventEx__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventEx(!x, arg2, arg3, arg4);
+}
+
+void test__CreateEventEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventEx(x, arg2, arg3, arg4);
+}
+
+void test__CreateEventEx__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventEx(arg1, !x, arg3, arg4);
+}
+
+void test__CreateEventEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventEx(arg1, x, arg3, arg4);
+}
+
+void test__CreateEventEx__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventEx(arg1, arg2, !x, arg4);
+}
+
+void test__CreateEventEx__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventEx(arg1, arg2, x, arg4);
+}
+
+void test__CreateEventEx__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventEx(arg1, arg2, arg3, !x);
+}
+
+void test__CreateEventEx__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventEx(arg1, arg2, arg3, x);
+}
+
+void test__CreateEventExA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateEventExA(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateEventExA__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExA(!x, arg2, arg3, arg4);
+}
+
+void test__CreateEventExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExA(x, arg2, arg3, arg4);
+}
+
+void test__CreateEventExA__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExA(arg1, !x, arg3, arg4);
+}
+
+void test__CreateEventExA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExA(arg1, x, arg3, arg4);
+}
+
+void test__CreateEventExA__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExA(arg1, arg2, !x, arg4);
+}
+
+void test__CreateEventExA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExA(arg1, arg2, x, arg4);
+}
+
+void test__CreateEventExA__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExA(arg1, arg2, arg3, !x);
+}
+
+void test__CreateEventExA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExA(arg1, arg2, arg3, x);
+}
+
+void test__CreateEventExW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateEventExW(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateEventExW__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExW(!x, arg2, arg3, arg4);
+}
+
+void test__CreateEventExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExW(x, arg2, arg3, arg4);
+}
+
+void test__CreateEventExW__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExW(arg1, !x, arg3, arg4);
+}
+
+void test__CreateEventExW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExW(arg1, x, arg3, arg4);
+}
+
+void test__CreateEventExW__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExW(arg1, arg2, !x, arg4);
+}
+
+void test__CreateEventExW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExW(arg1, arg2, x, arg4);
+}
+
+void test__CreateEventExW__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateEventExW(arg1, arg2, arg3, !x);
+}
+
+void test__CreateEventExW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateEventExW(arg1, arg2, arg3, x);
+}
+
+void test__OpenEvent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else OpenEvent(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__OpenEvent__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenEvent(!x, arg2, arg3);
+}
+
+void test__OpenEvent__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenEvent(x, arg2, arg3);
+}
+
+void test__OpenEvent__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenEvent(arg1, x, arg3);
+}
+
+void test__OpenEvent__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenEvent(arg1, arg2, NULL);
+}
+
+void test__OpenEvent__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenEvent(arg1, arg2, x);
+}
+
+void test__OpenEventA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else OpenEventA(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__OpenEventA__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenEventA(!x, arg2, arg3);
+}
+
+void test__OpenEventA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenEventA(x, arg2, arg3);
+}
+
+void test__OpenEventA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenEventA(arg1, x, arg3);
+}
+
+void test__OpenEventA__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenEventA(arg1, arg2, NULL);
+}
+
+void test__OpenEventA__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenEventA(arg1, arg2, x);
+}
+
+void test__OpenEventW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else OpenEventW(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__OpenEventW__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenEventW(!x, arg2, arg3);
+}
+
+void test__OpenEventW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenEventW(x, arg2, arg3);
+}
+
+void test__OpenEventW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenEventW(arg1, x, arg3);
+}
+
+void test__OpenEventW__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenEventW(arg1, arg2, NULL);
+}
+
+void test__OpenEventW__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenEventW(arg1, arg2, x);
+}
+
+void test__PulseEvent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else PulseEvent(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__PulseEvent__leakignore() {
+  char *p = strdup(str);
+  PulseEvent(p);
+  // cppcheck-suppress memleak
+}
+
+void test__PulseEvent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  PulseEvent(NULL);
+}
+
+void test__PulseEvent__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  PulseEvent(x);
+}
+
+void test__ResetEvent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ResetEvent(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ResetEvent__leakignore() {
+  char *p = strdup(str);
+  ResetEvent(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ResetEvent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  ResetEvent(NULL);
+}
+
+void test__ResetEvent__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  ResetEvent(x);
+}
+
+void test__SetEvent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetEvent(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetEvent__leakignore() {
+  char *p = strdup(str);
+  SetEvent(p);
+  // cppcheck-suppress memleak
+}
+
+void test__SetEvent__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SetEvent(NULL);
+}
+
+void test__SetEvent__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  SetEvent(x);
+}
+
+void test__InitializeCriticalSection__noreturn() {
+  int x = 100;
+  if (cond) x=1; else InitializeCriticalSection(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__InitializeCriticalSection__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  InitializeCriticalSection(!x);
+}
+
+void test__InitializeCriticalSection__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  InitializeCriticalSection(NULL);
+}
+
+void test__InitializeCriticalSectionAndSpinCount__noreturn() {
+  int x = 100;
+  if (cond) x=1; else InitializeCriticalSectionAndSpinCount(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__InitializeCriticalSectionAndSpinCount__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  InitializeCriticalSectionAndSpinCount(!x, arg2);
+}
+
+void test__InitializeCriticalSectionAndSpinCount__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  InitializeCriticalSectionAndSpinCount(NULL, arg2);
+}
+
+void test__InitializeCriticalSectionAndSpinCount__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  InitializeCriticalSectionAndSpinCount(arg1, !x);
+}
+
+void test__InitializeCriticalSectionAndSpinCount__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  InitializeCriticalSectionAndSpinCount(arg1, x);
+}
+
+void test__InitializeCriticalSectionEx__noreturn() {
+  int x = 100;
+  if (cond) x=1; else InitializeCriticalSectionEx(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__InitializeCriticalSectionEx__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  InitializeCriticalSectionEx(!x, arg2, arg3);
+}
+
+void test__InitializeCriticalSectionEx__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  InitializeCriticalSectionEx(NULL, arg2, arg3);
+}
+
+void test__InitializeCriticalSectionEx__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  InitializeCriticalSectionEx(arg1, !x, arg3);
+}
+
+void test__InitializeCriticalSectionEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  InitializeCriticalSectionEx(arg1, x, arg3);
+}
+
+void test__InitializeCriticalSectionEx__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  InitializeCriticalSectionEx(arg1, arg2, !x);
+}
+
+void test__InitializeCriticalSectionEx__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  InitializeCriticalSectionEx(arg1, arg2, x);
+}
+
+void test__SetCriticalSectionSpinCount__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetCriticalSectionSpinCount(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetCriticalSectionSpinCount__leakignore() {
+  char *p = strdup(str);
+  SetCriticalSectionSpinCount(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__SetCriticalSectionSpinCount__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  SetCriticalSectionSpinCount(!x, arg2);
+}
+
+void test__SetCriticalSectionSpinCount__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  SetCriticalSectionSpinCount(NULL, arg2);
+}
+
+void test__SetCriticalSectionSpinCount__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  SetCriticalSectionSpinCount(arg1, !x);
+}
+
+void test__SetCriticalSectionSpinCount__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetCriticalSectionSpinCount(arg1, x);
+}
+
+void test__DeleteCriticalSection__noreturn() {
+  int x = 100;
+  if (cond) x=1; else DeleteCriticalSection(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__DeleteCriticalSection__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  DeleteCriticalSection(!x);
+}
+
+void test__DeleteCriticalSection__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  DeleteCriticalSection(NULL);
+}
+
+void test__DeleteCriticalSection__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  DeleteCriticalSection(x);
+}
+
+void test__EnterCriticalSection__noreturn() {
+  int x = 100;
+  if (cond) x=1; else EnterCriticalSection(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__EnterCriticalSection__leakignore() {
+  char *p = strdup(str);
+  EnterCriticalSection(p);
+  // cppcheck-suppress memleak
+}
+
+void test__EnterCriticalSection__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  EnterCriticalSection(!x);
+}
+
+void test__EnterCriticalSection__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  EnterCriticalSection(NULL);
+}
+
+void test__EnterCriticalSection__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  EnterCriticalSection(x);
+}
+
+void test__TryEnterCriticalSection__noreturn() {
+  int x = 100;
+  if (cond) x=1; else TryEnterCriticalSection(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__TryEnterCriticalSection__leakignore() {
+  char *p = strdup(str);
+  TryEnterCriticalSection(p);
+  // cppcheck-suppress memleak
+}
+
+void test__TryEnterCriticalSection__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  TryEnterCriticalSection(!x);
+}
+
+void test__TryEnterCriticalSection__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  TryEnterCriticalSection(NULL);
+}
+
+void test__TryEnterCriticalSection__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  TryEnterCriticalSection(x);
+}
+
+void test__LeaveCriticalSection__noreturn() {
+  int x = 100;
+  if (cond) x=1; else LeaveCriticalSection(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__LeaveCriticalSection__leakignore() {
+  char *p = strdup(str);
+  LeaveCriticalSection(p);
+  // cppcheck-suppress memleak
+}
+
+void test__LeaveCriticalSection__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  LeaveCriticalSection(!x);
+}
+
+void test__LeaveCriticalSection__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  LeaveCriticalSection(NULL);
+}
+
+void test__LeaveCriticalSection__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  LeaveCriticalSection(x);
+}
+
+void test__lstrcat__noreturn() {
+  int x = 100;
+  if (cond) x=1; else lstrcat(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__lstrcat__leakignore() {
+  char *p = strdup(str);
+  lstrcat(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__lstrcat__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  lstrcat(NULL, arg2);
+}
+
+void test__lstrcat__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  lstrcat(x, arg2);
+}
+
+void test__lstrcat__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  lstrcat(arg1, NULL);
+}
+
+void test__lstrcat__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  lstrcat(arg1, x);
+}
+
+void test__CreateSemaphore__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateSemaphore(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateSemaphore__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphore(x, arg2, arg3, arg4);
+}
+
+void test__CreateSemaphore__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphore(arg1, x, arg3, arg4);
+}
+
+void test__CreateSemaphore__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphore(arg1, arg2, x, arg4);
+}
+
+void test__CreateSemaphore__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateSemaphore(arg1, arg2, arg3, !x);
+}
+
+void test__CreateSemaphore__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphore(arg1, arg2, arg3, x);
+}
+
+void test__CreateSemaphoreA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateSemaphoreA(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateSemaphoreA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreA(x, arg2, arg3, arg4);
+}
+
+void test__CreateSemaphoreA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreA(arg1, x, arg3, arg4);
+}
+
+void test__CreateSemaphoreA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreA(arg1, arg2, x, arg4);
+}
+
+void test__CreateSemaphoreA__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateSemaphoreA(arg1, arg2, arg3, !x);
+}
+
+void test__CreateSemaphoreA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreA(arg1, arg2, arg3, x);
+}
+
+void test__CreateSemaphoreW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateSemaphoreW(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateSemaphoreW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreW(x, arg2, arg3, arg4);
+}
+
+void test__CreateSemaphoreW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreW(arg1, x, arg3, arg4);
+}
+
+void test__CreateSemaphoreW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreW(arg1, arg2, x, arg4);
+}
+
+void test__CreateSemaphoreW__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateSemaphoreW(arg1, arg2, arg3, !x);
+}
+
+void test__CreateSemaphoreW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreW(arg1, arg2, arg3, x);
+}
+
+void test__CreateSemaphoreEx__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateSemaphoreEx(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateSemaphoreEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreEx(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__CreateSemaphoreEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreEx(arg1, x, arg3, arg4, arg5, arg6);
+}
+
+void test__CreateSemaphoreEx__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreEx(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__CreateSemaphoreEx__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateSemaphoreEx(arg1, arg2, arg3, !x, arg5, arg6);
+}
+
+void test__CreateSemaphoreEx__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreEx(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__CreateSemaphoreEx__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreEx(arg1, arg2, arg3, arg4, x, arg6);
+}
+
+void test__CreateSemaphoreEx__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreEx(arg1, arg2, arg3, arg4, arg5, x);
+}
+
+void test__CreateSemaphoreExA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateSemaphoreExA(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateSemaphoreExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExA(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__CreateSemaphoreExA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExA(arg1, x, arg3, arg4, arg5, arg6);
+}
+
+void test__CreateSemaphoreExA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExA(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__CreateSemaphoreExA__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateSemaphoreExA(arg1, arg2, arg3, !x, arg5, arg6);
+}
+
+void test__CreateSemaphoreExA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExA(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__CreateSemaphoreExA__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExA(arg1, arg2, arg3, arg4, x, arg6);
+}
+
+void test__CreateSemaphoreExA__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExA(arg1, arg2, arg3, arg4, arg5, x);
+}
+
+void test__CreateSemaphoreExW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateSemaphoreExW(arg1, arg2, arg3, arg4, arg5, arg6);
+  // 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__CreateSemaphoreExW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExW(arg1, x, arg3, arg4, arg5, arg6);
+}
+
+void test__CreateSemaphoreExW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExW(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__CreateSemaphoreExW__arg4__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateSemaphoreExW(arg1, arg2, arg3, !x, arg5, arg6);
+}
+
+void test__CreateSemaphoreExW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExW(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__CreateSemaphoreExW__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExW(arg1, arg2, arg3, arg4, x, arg6);
+}
+
+void test__CreateSemaphoreExW__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateSemaphoreExW(arg1, arg2, arg3, arg4, arg5, x);
+}
+
+void test__OpenSemaphore__noreturn() {
+  int x = 100;
+  if (cond) x=1; else OpenSemaphore(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__OpenSemaphore__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenSemaphore(x, arg2, arg3);
+}
+
+void test__OpenSemaphore__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenSemaphore(arg1, x, arg3);
+}
+
+void test__OpenSemaphore__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenSemaphore(arg1, arg2, !x);
+}
+
+void test__OpenSemaphore__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenSemaphore(arg1, arg2, NULL);
+}
+
+void test__OpenSemaphore__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenSemaphore(arg1, arg2, x);
+}
+
+void test__OpenSemaphoreA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else OpenSemaphoreA(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__OpenSemaphoreA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenSemaphoreA(x, arg2, arg3);
+}
+
+void test__OpenSemaphoreA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenSemaphoreA(arg1, x, arg3);
+}
+
+void test__OpenSemaphoreA__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenSemaphoreA(arg1, arg2, !x);
+}
+
+void test__OpenSemaphoreA__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenSemaphoreA(arg1, arg2, NULL);
+}
+
+void test__OpenSemaphoreA__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenSemaphoreA(arg1, arg2, x);
+}
+
+void test__OpenSemaphoreW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else OpenSemaphoreW(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__OpenSemaphoreW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenSemaphoreW(x, arg2, arg3);
+}
+
+void test__OpenSemaphoreW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenSemaphoreW(arg1, x, arg3);
+}
+
+void test__OpenSemaphoreW__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenSemaphoreW(arg1, arg2, !x);
+}
+
+void test__OpenSemaphoreW__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenSemaphoreW(arg1, arg2, NULL);
+}
+
+void test__OpenSemaphoreW__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenSemaphoreW(arg1, arg2, x);
+}
+
+void test__ReleaseSemaphore__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ReleaseSemaphore(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ReleaseSemaphore__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  ReleaseSemaphore(!x, arg2, arg3);
+}
+
+void test__ReleaseSemaphore__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ReleaseSemaphore(x, arg2, arg3);
+}
+
+void test__ReleaseSemaphore__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  ReleaseSemaphore(arg1, !x, arg3);
+}
+
+void test__ReleaseSemaphore__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ReleaseSemaphore(arg1, x, arg3);
+}
+
+void test__ReleaseSemaphore__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  ReleaseSemaphore(arg1, arg2, !x);
+}
+
+void test__ReleaseSemaphore__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ReleaseSemaphore(arg1, arg2, x);
+}
+
+void test__CreateMutex__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateMutex(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateMutex__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutex(!x, arg2, arg3);
+}
+
+void test__CreateMutex__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutex(x, arg2, arg3);
+}
+
+void test__CreateMutex__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutex(arg1, x, arg3);
+}
+
+void test__CreateMutex__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutex(arg1, arg2, !x);
+}
+
+void test__CreateMutex__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutex(arg1, arg2, x);
+}
+
+void test__CreateMutexA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateMutexA(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateMutexA__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexA(!x, arg2, arg3);
+}
+
+void test__CreateMutexA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexA(x, arg2, arg3);
+}
+
+void test__CreateMutexA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexA(arg1, x, arg3);
+}
+
+void test__CreateMutexA__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexA(arg1, arg2, !x);
+}
+
+void test__CreateMutexA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexA(arg1, arg2, x);
+}
+
+void test__CreateMutexW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateMutexW(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateMutexW__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexW(!x, arg2, arg3);
+}
+
+void test__CreateMutexW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexW(x, arg2, arg3);
+}
+
+void test__CreateMutexW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexW(arg1, x, arg3);
+}
+
+void test__CreateMutexW__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexW(arg1, arg2, !x);
+}
+
+void test__CreateMutexW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexW(arg1, arg2, x);
+}
+
+void test__CreateMutexEx__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateMutexEx(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateMutexEx__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexEx(!x, arg2, arg3, arg4);
+}
+
+void test__CreateMutexEx__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexEx(x, arg2, arg3, arg4);
+}
+
+void test__CreateMutexEx__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexEx(arg1, !x, arg3, arg4);
+}
+
+void test__CreateMutexEx__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexEx(arg1, x, arg3, arg4);
+}
+
+void test__CreateMutexEx__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexEx(arg1, arg2, x, arg4);
+}
+
+void test__CreateMutexEx__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexEx(arg1, arg2, arg3, x);
+}
+
+void test__CreateMutexExA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateMutexExA(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateMutexExA__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexExA(!x, arg2, arg3, arg4);
+}
+
+void test__CreateMutexExA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExA(x, arg2, arg3, arg4);
+}
+
+void test__CreateMutexExA__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexExA(arg1, !x, arg3, arg4);
+}
+
+void test__CreateMutexExA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExA(arg1, x, arg3, arg4);
+}
+
+void test__CreateMutexExA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExA(arg1, arg2, x, arg4);
+}
+
+void test__CreateMutexExA__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExA(arg1, arg2, arg3, x);
+}
+
+void test__CreateMutexExW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else CreateMutexExW(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__CreateMutexExW__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexExW(!x, arg2, arg3, arg4);
+}
+
+void test__CreateMutexExW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExW(x, arg2, arg3, arg4);
+}
+
+void test__CreateMutexExW__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  CreateMutexExW(arg1, !x, arg3, arg4);
+}
+
+void test__CreateMutexExW__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExW(arg1, x, arg3, arg4);
+}
+
+void test__CreateMutexExW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExW(arg1, arg2, x, arg4);
+}
+
+void test__CreateMutexExW__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  CreateMutexExW(arg1, arg2, arg3, x);
+}
+
+void test__OpenMutex__noreturn() {
+  int x = 100;
+  if (cond) x=1; else OpenMutex(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__OpenMutex__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenMutex(x, arg2, arg3);
+}
+
+void test__OpenMutex__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenMutex(arg1, x, arg3);
+}
+
+void test__OpenMutex__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenMutex(arg1, arg2, !x);
+}
+
+void test__OpenMutex__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenMutex(arg1, arg2, NULL);
+}
+
+void test__OpenMutex__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenMutex(arg1, arg2, x);
+}
+
+void test__OpenMutexA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else OpenMutexA(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__OpenMutexA__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenMutexA(x, arg2, arg3);
+}
+
+void test__OpenMutexA__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenMutexA(arg1, x, arg3);
+}
+
+void test__OpenMutexA__arg3__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  OpenMutexA(arg1, arg2, !x);
+}
+
+void test__OpenMutexA__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenMutexA(arg1, arg2, NULL);
+}
+
+void test__OpenMutexA__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenMutexA(arg1, arg2, x);
+}
+
+void test__OpenMutexW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else OpenMutexW(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__OpenMutexW__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  OpenMutexW(x, arg2, arg3);
+}
+
+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__OpenMutexW__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  OpenMutexW(arg1, arg2, NULL);
+}
+
+void test__OpenMutexW__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  OpenMutexW(arg1, arg2, x);
+}
+
+void test__ReleaseMutex__noreturn() {
+  int x = 100;
+  if (cond) x=1; else ReleaseMutex(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ReleaseMutex__leakignore() {
+  char *p = strdup(str);
+  ReleaseMutex(p);
+  // cppcheck-suppress memleak
+}
+
+void test__ReleaseMutex__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  ReleaseMutex(!x);
+}
+
+void test__ReleaseMutex__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ReleaseMutex(x);
+}
+
+void test___malloca__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _malloca(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___malloca__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _malloca(x);
+}
+
+void test___alloca__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _alloca(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___alloca__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _alloca(arg1);
+}
+
+void test___alloca__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _alloca(x);
+}
+
+void test___freea__noreturn() {
+  int x = 100;
+  if (cond) x=1; else _freea(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___freea__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  _freea(x);
+}
+
+void test__strlwr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else strlwr(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__strlwr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  strlwr(NULL);
+}
+
+void test__strlwr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  strlwr(x);
+}
+
+void test__strupr__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else GetLocalTime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetLocalTime__leakignore() {
+  char *p = strdup(str);
+  GetLocalTime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__GetLocalTime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetLocalTime(NULL);
+}
+
+void test__GetSystemTime__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetSystemTime(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetSystemTime__leakignore() {
+  char *p = strdup(str);
+  GetSystemTime(p);
+  // cppcheck-suppress memleak
+}
+
+void test__GetSystemTime__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetSystemTime(NULL);
+}
+
+void test__GetLastError__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = GetLastError();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetLastError__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetLastError();
+}
+
+void test__SetLastError__noreturn() {
+  int x = 100;
+  if (cond) x=1; else SetLastError(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__SetLastError__leakignore() {
+  char *p = strdup(str);
+  SetLastError(p);
+  // cppcheck-suppress memleak
+}
+
+void test__SetLastError__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  SetLastError(x);
+}
+
+void test__AllocateAndInitializeSid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else AllocateAndInitializeSid(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__AllocateAndInitializeSid__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  AllocateAndInitializeSid(NULL);
+}
+
+void test__AllocateAndInitializeSid__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  AllocateAndInitializeSid(NULL);
+}
+
+void test__FreeSid__noreturn() {
+  int x = 100;
+  if (cond) x=1; else FreeSid(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__FreeSid__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  FreeSid(x);
+}
+
+void test__HeapAlloc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else HeapAlloc(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__HeapAlloc__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapAlloc(x, arg2, arg3);
+}
+
+void test__HeapAlloc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapAlloc(arg1, x, arg3);
+}
+
+void test__HeapAlloc__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapAlloc(arg1, arg2, x);
+}
+
+void test__HeapReAlloc__noreturn() {
+  int x = 100;
+  if (cond) x=1; else HeapReAlloc(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__HeapReAlloc__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapReAlloc(arg1, x, arg3, arg4);
+}
+
+void test__HeapReAlloc__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  HeapReAlloc(arg1, arg2, NULL, arg4);
+}
+
+void test__HeapReAlloc__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  HeapReAlloc(arg1, arg2, x, arg4);
+}
+
+void test__HeapReAlloc__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapReAlloc(arg1, arg2, arg3, x);
+}
+
+void test__HeapFree__noreturn() {
+  int x = 100;
+  if (cond) x=1; else HeapFree(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__HeapFree__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapFree(x, arg2, arg3);
+}
+
+void test__HeapFree__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapFree(arg1, x, arg3);
+}
+
+void test__HeapFree__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  HeapFree(arg1, arg2, NULL);
+}
+
+void test__HeapFree__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  HeapFree(arg1, arg2, x);
+}
+
+void test__HeapSize__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = HeapSize(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__HeapSize__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  HeapSize(arg1, arg2, arg3);
+}
+
+void test__HeapSize__leakignore() {
+  char *p = strdup(str);
+  result = HeapSize(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__HeapSize__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = HeapSize(x, arg2, arg3);
+}
+
+void test__HeapSize__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = HeapSize(arg1, x, arg3);
+}
+
+void test__HeapSize__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = HeapSize(arg1, arg2, x);
+}
+
+void test__HeapValidate__noreturn() {
+  int x = 100;
+  if (cond) x=1; else HeapValidate(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__HeapValidate__leakignore() {
+  char *p = strdup(str);
+  HeapValidate(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__HeapValidate__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapValidate(x, arg2, arg3);
+}
+
+void test__HeapValidate__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapValidate(arg1, x, arg3);
+}
+
+void test__HeapValidate__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  HeapValidate(arg1, arg2, x);
+}
+
+void test__GetProcessHeap__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = GetProcessHeap();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetProcessHeap__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  GetProcessHeap();
+}
+
+void test__GetUserName__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetUserName(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetUserName__leakignore() {
+  char *p = strdup(str);
+  GetUserName(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__GetUserName__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetUserName(arg1, NULL);
+}
+
+void test__GetUserName__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetUserName(arg1, x);
+}
+
+void test__GetUserNameA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetUserNameA(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetUserNameA__leakignore() {
+  char *p = strdup(str);
+  GetUserNameA(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__GetUserNameA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetUserNameA(arg1, NULL);
+}
+
+void test__GetUserNameA__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetUserNameA(arg1, x);
+}
+
+void test__GetUserNameW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetUserNameW(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetUserNameW__leakignore() {
+  char *p = strdup(str);
+  GetUserNameW(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__GetUserNameW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetUserNameW(arg1, NULL);
+}
+
+void test__GetUserNameW__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  GetUserNameW(arg1, x);
+}
+
+void test__GetWindowText__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetWindowText(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetWindowText__leakignore() {
+  char *p = strdup(str);
+  GetWindowText(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__GetWindowText__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetWindowText(NULL, arg2, arg3);
+}
+
+void test__GetWindowText__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetWindowText(arg1, NULL, arg3);
+}
+
+void test__GetWindowText__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetWindowText(arg1, arg2, x);
+}
+
+void test__GetWindowTextA__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetWindowTextA(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetWindowTextA__leakignore() {
+  char *p = strdup(str);
+  GetWindowTextA(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__GetWindowTextA__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetWindowTextA(NULL, arg2, arg3);
+}
+
+void test__GetWindowTextA__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetWindowTextA(arg1, NULL, arg3);
+}
+
+void test__GetWindowTextA__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetWindowTextA(arg1, arg2, x);
+}
+
+void test__GetWindowTextW__noreturn() {
+  int x = 100;
+  if (cond) x=1; else GetWindowTextW(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__GetWindowTextW__leakignore() {
+  char *p = strdup(str);
+  GetWindowTextW(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__GetWindowTextW__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  GetWindowTextW(NULL, arg2, arg3);
+}
+
+void test__GetWindowTextW__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  GetWindowTextW(arg1, NULL, arg3);
+}
+
+void test__GetWindowTextW__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  GetWindowTextW(arg1, arg2, x);
+}
+
+void test__socket__noreturn() {
+  int x = 100;
+  if (cond) x=1; else socket(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__socket__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  socket(x, arg2, arg3);
+}
+
+void test__socket__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  socket(arg1, x, arg3);
+}
+
+void test__socket__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  socket(arg1, arg2, x);
+}
+
+void test__closesocket__noreturn() {
+  int x = 100;
+  if (cond) x=1; else closesocket(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__closesocket__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  closesocket(x);
+}
+
+void test__accept__noreturn() {
+  int x = 100;
+  if (cond) x=1; else accept(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__accept__leakignore() {
+  char *p = strdup(str);
+  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__bind__noreturn() {
+  int x = 100;
+  if (cond) x=1; else bind(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__bind__leakignore() {
+  char *p = strdup(str);
+  bind(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__bind__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  bind(x, arg2, arg3);
+}
+
+void test__bind__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  bind(arg1, NULL, arg3);
+}
+
+void test__bind__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  bind(arg1, arg2, x);
+}
+
+void test__connect__noreturn() {
+  int x = 100;
+  if (cond) x=1; else connect(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__connect__leakignore() {
+  char *p = strdup(str);
+  connect(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__connect__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  connect(x, arg2, arg3);
+}
+
+void test__connect__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  connect(arg1, NULL, arg3);
+}
+
+void test__connect__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  connect(arg1, arg2, x);
+}
+
+void test__getpeername__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getpeername(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getpeername__leakignore() {
+  char *p = strdup(str);
+  getpeername(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__getpeername__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getpeername(x, arg2, arg3);
+}
+
+void test__getpeername__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getpeername(arg1, NULL, arg3);
+}
+
+void test__getpeername__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  getpeername(arg1, arg2, NULL);
+}
+
+void test__getpeername__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getpeername(arg1, arg2, x);
+}
+
+void test__getsockname__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getsockname(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getsockname__leakignore() {
+  char *p = strdup(str);
+  getsockname(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__getsockname__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getsockname(x, arg2, arg3);
+}
+
+void test__getsockname__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  getsockname(arg1, NULL, arg3);
+}
+
+void test__getsockname__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  getsockname(arg1, arg2, NULL);
+}
+
+void test__getsockname__arg3__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getsockname(arg1, arg2, x);
+}
+
+void test__getsockopt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else getsockopt(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__getsockopt__leakignore() {
+  char *p = strdup(str);
+  getsockopt(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__getsockopt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getsockopt(x, arg2, arg3, arg4, arg5);
+}
+
+void test__getsockopt__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getsockopt(arg1, x, arg3, arg4, arg5);
+}
+
+void test__getsockopt__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  getsockopt(arg1, arg2, x, arg4, arg5);
+}
+
+void test__getsockopt__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  getsockopt(arg1, arg2, arg3, NULL, arg5);
+}
+
+void test__getsockopt__arg5__notnull() {
+  // cppcheck-suppress nullPointer
+  getsockopt(arg1, arg2, arg3, arg4, NULL);
+}
+
+void test__getsockopt__arg5__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  getsockopt(arg1, arg2, arg3, arg4, x);
+}
+
+void test__htonl__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = htonl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__htonl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  htonl(arg1);
+}
+
+void test__htonl__leakignore() {
+  char *p = strdup(str);
+  result = htonl(p);
+  // cppcheck-suppress memleak
+}
+
+void test__htonl__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = htonl(x);
+}
+
+void test__htons__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = htons(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__htons__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  htons(arg1);
+}
+
+void test__htons__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else result = inet_addr(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__inet_addr__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  inet_addr(arg1);
+}
+
+void test__inet_addr__leakignore() {
+  char *p = strdup(str);
+  result = inet_addr(p);
+  // cppcheck-suppress memleak
+}
+
+void test__inet_addr__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = inet_addr(NULL);
+}
+
+void test__inet_addr__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = inet_addr(x);
+}
+
+void test__inet_ntoa__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = inet_ntoa(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__inet_ntoa__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  inet_ntoa(arg1);
+}
+
+void test__inet_ntoa__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else ioctlsocket(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ioctlsocket__leakignore() {
+  char *p = strdup(str);
+  ioctlsocket(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+void test__ioctlsocket__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ioctlsocket(x, arg2, arg3);
+}
+
+void test__ioctlsocket__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  ioctlsocket(arg1, x, arg3);
+}
+
+void test__ioctlsocket__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  ioctlsocket(arg1, arg2, NULL);
+}
+
+void test__listen__noreturn() {
+  int x = 100;
+  if (cond) x=1; else listen(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__listen__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else result = ntohl(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ntohl__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ntohl(arg1);
+}
+
+void test__ntohl__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else result = ntohs(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__ntohs__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  ntohs(arg1);
+}
+
+void test__ntohs__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else recv(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__recv__leakignore() {
+  char *p = strdup(str);
+  recv(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__recv__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recv(x, arg2, arg3, arg4);
+}
+
+void test__recv__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  recv(arg1, NULL, arg3, arg4);
+}
+
+void test__recv__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recv(arg1, arg2, x, arg4);
+}
+
+void test__recv__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recv(arg1, arg2, arg3, x);
+}
+
+void test__recvfrom__noreturn() {
+  int x = 100;
+  if (cond) x=1; else recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__recvfrom__leakignore() {
+  char *p = strdup(str);
+  recvfrom(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__recvfrom__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recvfrom(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__recvfrom__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  recvfrom(arg1, NULL, arg3, arg4, arg5, arg6);
+}
+
+void test__recvfrom__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recvfrom(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__recvfrom__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  recvfrom(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__select__noreturn() {
+  int x = 100;
+  if (cond) x=1; else select(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__select__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else send(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__send__leakignore() {
+  char *p = strdup(str);
+  send(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__send__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  send(x, arg2, arg3, arg4);
+}
+
+void test__send__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  send(arg1, NULL, arg3, arg4);
+}
+
+void test__send__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  send(arg1, arg2, x, arg4);
+}
+
+void test__send__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  send(arg1, arg2, arg3, x);
+}
+
+void test__sendto__noreturn() {
+  int x = 100;
+  if (cond) x=1; else sendto(arg1, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__sendto__leakignore() {
+  char *p = strdup(str);
+  sendto(p, arg2, arg3, arg4, arg5, arg6);
+  // cppcheck-suppress memleak
+}
+
+void test__sendto__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendto(x, arg2, arg3, arg4, arg5, arg6);
+}
+
+void test__sendto__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  sendto(arg1, NULL, arg3, arg4, arg5, arg6);
+}
+
+void test__sendto__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendto(arg1, arg2, x, arg4, arg5, arg6);
+}
+
+void test__sendto__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendto(arg1, arg2, arg3, x, arg5, arg6);
+}
+
+void test__sendto__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendto(arg1, arg2, arg3, arg4, x, arg6);
+}
+
+void test__sendto__arg6__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  sendto(arg1, arg2, arg3, arg4, arg5, x);
+}
+
+void test__setsockopt__noreturn() {
+  int x = 100;
+  if (cond) x=1; else setsockopt(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__setsockopt__leakignore() {
+  char *p = strdup(str);
+  setsockopt(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__setsockopt__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setsockopt(x, arg2, arg3, arg4, arg5);
+}
+
+void test__setsockopt__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setsockopt(arg1, x, arg3, arg4, arg5);
+}
+
+void test__setsockopt__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setsockopt(arg1, arg2, x, arg4, arg5);
+}
+
+void test__setsockopt__arg4__notnull() {
+  // cppcheck-suppress nullPointer
+  setsockopt(arg1, arg2, arg3, NULL, arg5);
+}
+
+void test__setsockopt__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  setsockopt(arg1, arg2, arg3, arg4, x);
+}
+
+void test__shutdown__noreturn() {
+  int x = 100;
+  if (cond) x=1; else shutdown(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__shutdown__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else WSAStartup(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__WSAStartup__leakignore() {
+  char *p = strdup(str);
+  WSAStartup(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__WSAStartup__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WSAStartup(x, arg2);
+}
+
+void test__WSAStartup__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  WSAStartup(arg1, NULL);
+}
+
+void test__WSACleanup__noreturn() {
+  int x = 100;
+  if (cond) x=1; else WSACleanup();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__WSAGetLastError__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = WSAGetLastError();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__WSAGetLastError__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  WSAGetLastError();
+}
+
+void test__WSASetLastError__noreturn() {
+  int x = 100;
+  if (cond) x=1; else WSASetLastError(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__WSASetLastError__leakignore() {
+  char *p = strdup(str);
+  WSASetLastError(p);
+  // cppcheck-suppress memleak
+}
+
+void test__WSASetLastError__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  WSASetLastError(x);
+}
+
+void test___fileno__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _fileno(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___fileno__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _fileno(arg1);
+}
+
+void test___fileno__leakignore() {
+  char *p = strdup(str);
+  result = _fileno(p);
+  // cppcheck-suppress memleak
+}
+
+void test___fileno__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  result = _fileno(!x);
+}
+
+void test___fileno__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  result = _fileno(NULL);
+}
+
+void test___fileno__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  result = _fileno(x);
+}
+
+void test___tolower__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _tolower(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tolower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tolower(arg1);
+}
+
+void test___tolower__leakignore() {
+  char *p = strdup(str);
+  result = _tolower(p);
+  // cppcheck-suppress memleak
+}
+
+void test___tolower__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tolower(x);
+}
+
+void test___tolower_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _tolower_l(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___tolower_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _tolower_l(arg1, arg2);
+}
+
+void test___tolower_l__leakignore() {
+  char *p = strdup(str);
+  result = _tolower_l(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___tolower_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tolower_l(x, arg2);
+}
+
+void test___tolower_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _tolower_l(arg1, x);
+}
+
+void test___towlower_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _towlower_l(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___towlower_l__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _towlower_l(arg1, arg2);
+}
+
+void test___towlower_l__leakignore() {
+  char *p = strdup(str);
+  result = _towlower_l(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___towlower_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _towlower_l(x, arg2);
+}
+
+void test___towlower_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _towlower_l(arg1, x);
+}
+
+void test___toupper__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = _toupper(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test___toupper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  _toupper(arg1);
+}
+
+void test___toupper__leakignore() {
+  char *p = strdup(str);
+  result = _toupper(p);
+  // cppcheck-suppress memleak
+}
+
+void test___toupper__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _toupper(x);
+}
+
+void test___toupper_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  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___towupper_l__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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 = strdup(str);
+  result = _towupper_l(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test___towupper_l__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _towupper_l(x, arg2);
+}
+
+void test___towupper_l__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = _towupper_l(arg1, x);
+}
+
+void test____noop__noreturn() {
+  int x = 100;
+  if (cond) x=1; else __noop();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test____noop__leakignore() {
+  char *p = strdup(str);
+  __noop();
+  // cppcheck-suppress memleak
+}
+
+void test____nop__noreturn() {
+  int x = 100;
+  if (cond) x=1; else __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
new file mode 100644
index 000000000..d1b7f3531
--- /dev/null
+++ b/test/cfg/generated-cfg-tests-wxwidgets.cpp
@@ -0,0 +1,2974 @@
+// auto generated tests from cfg/wxwidgets.cfg
+//
+// Generated by command:
+// ./generate_cfg_tests cfg/wxwidgets.cfg > generated-cfg-tests-wxwidgets.cpp
+//
+// Recommended cppcheck command line:
+// $ cppcheck --enable=warning,information --inline-suppr generated-cfg-tests-wxwidgets.cpp
+// => 'unmatched suppression' warnings are false negatives.
+//
+
+void test__wxString__Format__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxString::Format(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__Format__leakignore() {
+  char *p = strdup(str);
+  wxString::Format(p);
+  // cppcheck-suppress memleak
+}
+
+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__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxString::Format(x);
+}
+
+void test__wxString__Printf__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxString::Printf(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__Printf__leakignore() {
+  char *p = strdup(str);
+  wxString::Printf(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxString__Printf__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxString::Printf(!x);
+}
+
+void test__wxString__Printf__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxString::Printf(NULL);
+}
+
+void test__wxString__Printf__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxString::Printf(x);
+}
+
+void test__wxString__IsEmpty__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxString::IsEmpty();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__IsEmpty__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::IsEmpty();
+}
+
+void test__wxString__IsEmpty__leakignore() {
+  char *p = strdup(str);
+  result = wxString::IsEmpty();
+  // cppcheck-suppress memleak
+}
+
+void test__wxString__IsNull__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxString::IsNull();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__IsNull__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::IsNull();
+}
+
+void test__wxString__IsNull__leakignore() {
+  char *p = strdup(str);
+  result = wxString::IsNull();
+  // cppcheck-suppress memleak
+}
+
+void test__wxString__IsNumber__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxString::IsNumber();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__IsNumber__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::IsNumber();
+}
+
+void test__wxString__IsNumber__leakignore() {
+  char *p = strdup(str);
+  result = wxString::IsNumber();
+  // cppcheck-suppress memleak
+}
+
+void test__wxString__IsAscii__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxString::IsAscii();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__IsAscii__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::IsAscii();
+}
+
+void test__wxString__IsAscii__leakignore() {
+  char *p = strdup(str);
+  result = wxString::IsAscii();
+  // cppcheck-suppress memleak
+}
+
+void test__wxString__IsWord__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxString::IsWord();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__IsWord__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::IsWord();
+}
+
+void test__wxString__IsWord__leakignore() {
+  char *p = strdup(str);
+  result = wxString::IsWord();
+  // cppcheck-suppress memleak
+}
+
+void test__wxString__Len__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxString::Len();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__Len__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::Len();
+}
+
+void test__wxString__Len__leakignore() {
+  char *p = strdup(str);
+  result = wxString::Len();
+  // cppcheck-suppress memleak
+}
+
+void test__wxString__length__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxString::length();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__length__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::length();
+}
+
+void test__wxString__length__leakignore() {
+  char *p = strdup(str);
+  result = wxString::length();
+  // cppcheck-suppress memleak
+}
+
+void test__wxString__Length__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxString::Length();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__Length__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::Length();
+}
+
+void test__wxString__Length__leakignore() {
+  char *p = strdup(str);
+  result = wxString::Length();
+  // cppcheck-suppress memleak
+}
+
+void test__wxString__Lower__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxString::Lower();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__Lower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::Lower();
+}
+
+void test__wxString__Lower__leakignore() {
+  char *p = strdup(str);
+  result = wxString::Lower();
+  // cppcheck-suppress memleak
+}
+
+void test__wxString__MakeCapitalized__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxString::MakeCapitalized();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__MakeCapitalized__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::MakeCapitalized();
+}
+
+void test__wxString__MakeCapitalized__leakignore() {
+  char *p = strdup(str);
+  result = wxString::MakeCapitalized();
+  // cppcheck-suppress memleak
+}
+
+void test__wxString__MakeLower__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxString::MakeLower();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__MakeLower__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::MakeLower();
+}
+
+void test__wxString__MakeLower__leakignore() {
+  char *p = strdup(str);
+  result = wxString::MakeLower();
+  // cppcheck-suppress memleak
+}
+
+void test__wxString__MakeUpper__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxString::MakeUpper();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__MakeUpper__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxString::MakeUpper();
+}
+
+void test__wxString__MakeUpper__leakignore() {
+  char *p = strdup(str);
+  result = wxString::MakeUpper();
+  // cppcheck-suppress memleak
+}
+
+void test__wxString__Matches__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = wxString::Matches(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxString__Matches__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxString::Matches(x);
+}
+
+void test__wxString__LowerCase__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxString::LowerCase();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxString__LowerCase__leakignore() {
+  char *p = strdup(str);
+  wxString::LowerCase();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSysErrorCode__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSysErrorCode();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSysErrorCode__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSysErrorCode();
+}
+
+void test__wxLogMessage__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxLogMessage(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogMessage__leakignore() {
+  char *p = strdup(str);
+  wxLogMessage(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogMessage__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogMessage(!x);
+}
+
+void test__wxLogMessage__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogMessage(NULL);
+}
+
+void test__wxLogMessage__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogMessage(x);
+}
+
+void test__wxLogVerbose__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxLogVerbose(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogVerbose__leakignore() {
+  char *p = strdup(str);
+  wxLogVerbose(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogVerbose__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogVerbose(!x);
+}
+
+void test__wxLogVerbose__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogVerbose(NULL);
+}
+
+void test__wxLogVerbose__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogVerbose(x);
+}
+
+void test__wxLogWarning__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxLogWarning(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogWarning__leakignore() {
+  char *p = strdup(str);
+  wxLogWarning(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogWarning__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogWarning(!x);
+}
+
+void test__wxLogWarning__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogWarning(NULL);
+}
+
+void test__wxLogWarning__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogWarning(x);
+}
+
+void test__wxLogFatalError__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxLogFatalError(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogFatalError__leakignore() {
+  char *p = strdup(str);
+  wxLogFatalError(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogFatalError__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogFatalError(!x);
+}
+
+void test__wxLogFatalError__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogFatalError(NULL);
+}
+
+void test__wxLogFatalError__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogFatalError(x);
+}
+
+void test__wxLogError__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxLogError(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogError__leakignore() {
+  char *p = strdup(str);
+  wxLogError(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogError__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogError(!x);
+}
+
+void test__wxLogError__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogError(NULL);
+}
+
+void test__wxLogError__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogError(x);
+}
+
+void test__wxLogTrace__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxLogTrace(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogTrace__leakignore() {
+  char *p = strdup(str);
+  wxLogTrace(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogTrace__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogTrace(arg1, !x);
+}
+
+void test__wxLogTrace__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogTrace(arg1, NULL);
+}
+
+void test__wxLogTrace__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogTrace(arg1, x);
+}
+
+void test__wxLogDebug__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxLogDebug(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogDebug__leakignore() {
+  char *p = strdup(str);
+  wxLogDebug(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogDebug__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogDebug(!x);
+}
+
+void test__wxLogDebug__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogDebug(NULL);
+}
+
+void test__wxLogDebug__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogDebug(x);
+}
+
+void test__wxLogSysError__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxLogSysError(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogSysError__leakignore() {
+  char *p = strdup(str);
+  wxLogSysError(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogSysError__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogSysError(!x);
+}
+
+void test__wxLogSysError__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogSysError(NULL);
+}
+
+void test__wxLogSysError__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogSysError(x);
+}
+
+void test__wxLogGeneric__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxLogGeneric(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogGeneric__leakignore() {
+  char *p = strdup(str);
+  wxLogGeneric(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogGeneric__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxLogGeneric(x, arg2);
+}
+
+void test__wxLogGeneric__arg2__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogGeneric(arg1, !x);
+}
+
+void test__wxLogGeneric__arg2__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogGeneric(arg1, NULL);
+}
+
+void test__wxLogGeneric__arg2__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogGeneric(arg1, x);
+}
+
+void test__wxLogInfo__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxLogInfo(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLogInfo__leakignore() {
+  char *p = strdup(str);
+  wxLogInfo(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxLogInfo__arg1__notbool() {
+  // cppcheck-suppress invalidFunctionArgBool
+  wxLogInfo(!x);
+}
+
+void test__wxLogInfo__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxLogInfo(NULL);
+}
+
+void test__wxLogInfo__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxLogInfo(x);
+}
+
+void test__wxSpinCtrl__GetMax__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSpinCtrl::GetMax();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrl__GetMax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrl::GetMax();
+}
+
+void test__wxSpinCtrl__GetMax__leakignore() {
+  char *p = strdup(str);
+  result = wxSpinCtrl::GetMax();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSpinCtrl__GetMin__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSpinCtrl::GetMin();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrl__GetMin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrl::GetMin();
+}
+
+void test__wxSpinCtrl__GetMin__leakignore() {
+  char *p = strdup(str);
+  result = wxSpinCtrl::GetMin();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSpinCtrl__GetBase__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSpinCtrl::GetBase();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrl__GetBase__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrl::GetBase();
+}
+
+void test__wxSpinCtrl__GetBase__leakignore() {
+  char *p = strdup(str);
+  result = wxSpinCtrl::GetBase();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSpinCtrl__GetValue__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSpinCtrl::GetValue();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrl__GetValue__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrl::GetValue();
+}
+
+void test__wxSpinCtrl__GetValue__leakignore() {
+  char *p = strdup(str);
+  result = wxSpinCtrl::GetValue();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSpinCtrl__SetBase__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  wxSpinCtrl::SetBase(p);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else result = wxSpinCtrlDouble::GetDigits();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__GetDigits__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrlDouble::GetDigits();
+}
+
+void test__wxSpinCtrlDouble__GetDigits__leakignore() {
+  char *p = strdup(str);
+  result = wxSpinCtrlDouble::GetDigits();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSpinCtrlDouble__GetIncrement__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSpinCtrlDouble::GetIncrement();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__GetIncrement__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrlDouble::GetIncrement();
+}
+
+void test__wxSpinCtrlDouble__GetIncrement__leakignore() {
+  char *p = strdup(str);
+  result = wxSpinCtrlDouble::GetIncrement();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSpinCtrlDouble__GetMax__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSpinCtrlDouble::GetMax();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__GetMax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrlDouble::GetMax();
+}
+
+void test__wxSpinCtrlDouble__GetMax__leakignore() {
+  char *p = strdup(str);
+  result = wxSpinCtrlDouble::GetMax();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSpinCtrlDouble__GetMin__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSpinCtrlDouble::GetMin();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__GetMin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrlDouble::GetMin();
+}
+
+void test__wxSpinCtrlDouble__GetMin__leakignore() {
+  char *p = strdup(str);
+  result = wxSpinCtrlDouble::GetMin();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSpinCtrlDouble__GetValue__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSpinCtrlDouble::GetValue();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__GetValue__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSpinCtrlDouble::GetValue();
+}
+
+void test__wxSpinCtrlDouble__GetValue__leakignore() {
+  char *p = strdup(str);
+  result = wxSpinCtrlDouble::GetValue();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSpinCtrlDouble__SetDigits__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxSpinCtrlDouble::SetDigits(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__SetDigits__leakignore() {
+  char *p = strdup(str);
+  wxSpinCtrlDouble::SetDigits(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxSpinCtrlDouble__SetDigits__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxSpinCtrlDouble::SetDigits(x);
+}
+
+void test__wxSpinCtrlDouble__SetIncrement__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxSpinCtrlDouble::SetIncrement(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__SetIncrement__leakignore() {
+  char *p = strdup(str);
+  wxSpinCtrlDouble::SetIncrement(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxSpinCtrlDouble__SetIncrement__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxSpinCtrlDouble::SetIncrement(x);
+}
+
+void test__wxSpinCtrlDouble__SetRange__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxSpinCtrlDouble::SetRange(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__SetRange__leakignore() {
+  char *p = strdup(str);
+  wxSpinCtrlDouble::SetRange(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else wxSpinCtrlDouble::SetValue(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSpinCtrlDouble__SetValue__leakignore() {
+  char *p = strdup(str);
+  wxSpinCtrlDouble::SetValue(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxSpinCtrlDouble__SetValue__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxSpinCtrlDouble::SetValue(x);
+}
+
+void test__wxSlider__GetLineSize__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSlider::GetLineSize();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetLineSize__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetLineSize();
+}
+
+void test__wxSlider__GetLineSize__leakignore() {
+  char *p = strdup(str);
+  result = wxSlider::GetLineSize();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSlider__GetMax__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSlider::GetMax();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetMax__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetMax();
+}
+
+void test__wxSlider__GetMax__leakignore() {
+  char *p = strdup(str);
+  result = wxSlider::GetMax();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSlider__GetMin__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSlider::GetMin();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetMin__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetMin();
+}
+
+void test__wxSlider__GetMin__leakignore() {
+  char *p = strdup(str);
+  result = wxSlider::GetMin();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSlider__GetPageSize__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSlider::GetPageSize();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetPageSize__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetPageSize();
+}
+
+void test__wxSlider__GetPageSize__leakignore() {
+  char *p = strdup(str);
+  result = wxSlider::GetPageSize();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSlider__GetSelEnd__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSlider::GetSelEnd();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetSelEnd__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetSelEnd();
+}
+
+void test__wxSlider__GetSelEnd__leakignore() {
+  char *p = strdup(str);
+  result = wxSlider::GetSelEnd();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSlider__GetSelStart__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSlider::GetSelStart();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetSelStart__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetSelStart();
+}
+
+void test__wxSlider__GetSelStart__leakignore() {
+  char *p = strdup(str);
+  result = wxSlider::GetSelStart();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSlider__GetThumbLength__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSlider::GetThumbLength();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetThumbLength__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetThumbLength();
+}
+
+void test__wxSlider__GetThumbLength__leakignore() {
+  char *p = strdup(str);
+  result = wxSlider::GetThumbLength();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSlider__GetTickFreq__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSlider::GetTickFreq();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetTickFreq__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetTickFreq();
+}
+
+void test__wxSlider__GetTickFreq__leakignore() {
+  char *p = strdup(str);
+  result = wxSlider::GetTickFreq();
+  // cppcheck-suppress memleak
+}
+
+void test__wxSlider__GetValue__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxSlider::GetValue();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSlider__GetValue__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxSlider::GetValue();
+}
+
+void test__wxSlider__GetValue__leakignore() {
+  char *p = strdup(str);
+  result = wxSlider::GetValue();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTimer__GetId__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTimer::GetId();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__GetId__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTimer::GetId();
+}
+
+void test__wxTimer__GetId__leakignore() {
+  char *p = strdup(str);
+  result = wxTimer::GetId();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTimer__GetInterval__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTimer::GetInterval();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__GetInterval__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTimer::GetInterval();
+}
+
+void test__wxTimer__GetInterval__leakignore() {
+  char *p = strdup(str);
+  result = wxTimer::GetInterval();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTimer__GetOwner__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTimer::GetOwner();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__GetOwner__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTimer::GetOwner();
+}
+
+void test__wxTimer__GetOwner__leakignore() {
+  char *p = strdup(str);
+  result = wxTimer::GetOwner();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTimer__IsOneShot__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTimer::IsOneShot();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__IsOneShot__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTimer::IsOneShot();
+}
+
+void test__wxTimer__IsOneShot__leakignore() {
+  char *p = strdup(str);
+  result = wxTimer::IsOneShot();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTimer__IsRunning__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTimer::IsRunning();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__IsRunning__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTimer::IsRunning();
+}
+
+void test__wxTimer__IsRunning__leakignore() {
+  char *p = strdup(str);
+  result = wxTimer::IsRunning();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTimer__Notify__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxTimer::Notify();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__Notify__leakignore() {
+  char *p = strdup(str);
+  wxTimer::Notify();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTimer__SetOwner__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxTimer::SetOwner(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__SetOwner__leakignore() {
+  char *p = strdup(str);
+  wxTimer::SetOwner(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else wxTimer::Start(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__Start__leakignore() {
+  char *p = strdup(str);
+  wxTimer::Start(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else wxTimer::StartOnce(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__StartOnce__leakignore() {
+  char *p = strdup(str);
+  wxTimer::StartOnce(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxTimer__StartOnce__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTimer::StartOnce(x);
+}
+
+void test__wxTimer__Stop__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxTimer::Stop();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTimer__Stop__leakignore() {
+  char *p = strdup(str);
+  wxTimer::Stop();
+  // cppcheck-suppress memleak
+}
+
+void test__wxRadioBox__Enable__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxRadioBox::Enable(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__Enable__leakignore() {
+  char *p = strdup(str);
+  wxRadioBox::Enable(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else wxRadioBox::FindString(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__FindString__leakignore() {
+  char *p = strdup(str);
+  wxRadioBox::FindString(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else result = wxRadioBox::GetColumnCount();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__GetColumnCount__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxRadioBox::GetColumnCount();
+}
+
+void test__wxRadioBox__GetColumnCount__leakignore() {
+  char *p = strdup(str);
+  result = wxRadioBox::GetColumnCount();
+  // cppcheck-suppress memleak
+}
+
+void test__wxRadioBox__GetItemFromPoint__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = wxRadioBox::GetItemFromPoint(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxRadioBox__GetItemFromPoint__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxRadioBox::GetItemFromPoint(x);
+}
+
+void test__wxRadioBox__GetItemHelpText__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = wxRadioBox::GetItemHelpText(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxRadioBox__GetItemHelpText__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxRadioBox::GetItemHelpText(x);
+}
+
+void test__wxRadioBox__GetItemToolTip__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = wxRadioBox::GetItemToolTip(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxRadioBox__GetItemToolTip__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxRadioBox::GetItemToolTip(x);
+}
+
+void test__wxRadioBox__GetRowCount__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxRadioBox::GetRowCount();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__GetRowCount__leakignore() {
+  char *p = strdup(str);
+  wxRadioBox::GetRowCount();
+  // cppcheck-suppress memleak
+}
+
+void test__wxRadioBox__IsItemEnabled__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = wxRadioBox::IsItemEnabled(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxRadioBox__IsItemEnabled__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxRadioBox::IsItemEnabled(x);
+}
+
+void test__wxRadioBox__IsItemShown__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = wxRadioBox::IsItemShown(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxRadioBox__IsItemShown__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxRadioBox::IsItemShown(x);
+}
+
+void test__wxRadioBox__SetItemHelpText__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxRadioBox::SetItemHelpText(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__SetItemHelpText__leakignore() {
+  char *p = strdup(str);
+  wxRadioBox::SetItemHelpText(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else wxRadioBox::SetItemToolTip(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__SetItemToolTip__leakignore() {
+  char *p = strdup(str);
+  wxRadioBox::SetItemToolTip(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else wxRadioBox::SetSelection(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__SetSelection__leakignore() {
+  char *p = strdup(str);
+  wxRadioBox::SetSelection(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxRadioBox__SetSelection__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxRadioBox::SetSelection(x);
+}
+
+void test__wxRadioBox__Show__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxRadioBox::Show(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__Show__leakignore() {
+  char *p = strdup(str);
+  wxRadioBox::Show(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else result = wxRadioBox::GetCount();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__GetCount__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxRadioBox::GetCount();
+}
+
+void test__wxRadioBox__GetCount__leakignore() {
+  char *p = strdup(str);
+  result = wxRadioBox::GetCount();
+  // cppcheck-suppress memleak
+}
+
+void test__wxRadioBox__GetString__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = wxRadioBox::GetString(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxRadioBox__GetString__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxRadioBox::GetString(x);
+}
+
+void test__wxRadioBox__SetString__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxRadioBox::SetString(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__SetString__leakignore() {
+  char *p = strdup(str);
+  wxRadioBox::SetString(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else result = wxRadioBox::GetSelection();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRadioBox__GetSelection__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxRadioBox::GetSelection();
+}
+
+void test__wxRadioBox__GetSelection__leakignore() {
+  char *p = strdup(str);
+  result = wxRadioBox::GetSelection();
+  // cppcheck-suppress memleak
+}
+
+void test__wxButton__GetAuthNeeded__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxButton::GetAuthNeeded();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxButton__GetAuthNeeded__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxButton::GetAuthNeeded();
+}
+
+void test__wxButton__GetAuthNeeded__leakignore() {
+  char *p = strdup(str);
+  result = wxButton::GetAuthNeeded();
+  // cppcheck-suppress memleak
+}
+
+void test__wxButton__GetLabel__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxButton::GetLabel();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxButton__GetLabel__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxButton::GetLabel();
+}
+
+void test__wxButton__GetLabel__leakignore() {
+  char *p = strdup(str);
+  result = wxButton::GetLabel();
+  // cppcheck-suppress memleak
+}
+
+void test__wxButton__SetAuthNeeded__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxButton::SetAuthNeeded(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxButton__SetAuthNeeded__leakignore() {
+  char *p = strdup(str);
+  wxButton::SetAuthNeeded(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxButton__SetAuthNeeded__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxButton::SetAuthNeeded(x);
+}
+
+void test__wxButton__SetDefault__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxButton::SetDefault();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxButton__SetDefault__leakignore() {
+  char *p = strdup(str);
+  wxButton::SetDefault();
+  // cppcheck-suppress memleak
+}
+
+void test__wxButton__SetLabel__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxButton::SetLabel(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxButton__SetLabel__leakignore() {
+  char *p = strdup(str);
+  wxButton::SetLabel(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxButton__SetLabel__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxButton::SetLabel(x);
+}
+
+void test__wxColour__Alpha__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxColour::Alpha();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxColour__Alpha__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxColour::Alpha();
+}
+
+void test__wxColour__Alpha__leakignore() {
+  char *p = strdup(str);
+  result = wxColour::Alpha();
+  // cppcheck-suppress memleak
+}
+
+void test__wxColour__Blue__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxColour::Blue();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxColour__Blue__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxColour::Blue();
+}
+
+void test__wxColour__Blue__leakignore() {
+  char *p = strdup(str);
+  result = wxColour::Blue();
+  // cppcheck-suppress memleak
+}
+
+void test__wxColour__Green__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxColour::Green();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxColour__Green__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxColour::Green();
+}
+
+void test__wxColour__Green__leakignore() {
+  char *p = strdup(str);
+  result = wxColour::Green();
+  // cppcheck-suppress memleak
+}
+
+void test__wxColour__Red__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxColour::Red();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxColour__Red__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxColour::Red();
+}
+
+void test__wxColour__Red__leakignore() {
+  char *p = strdup(str);
+  result = wxColour::Red();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__AddLine__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxTextFile::AddLine(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__AddLine__leakignore() {
+  char *p = strdup(str);
+  wxTextFile::AddLine(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else wxTextFile::Clear();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__Clear__leakignore() {
+  char *p = strdup(str);
+  wxTextFile::Clear();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__Close__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxTextFile::Close();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__Close__leakignore() {
+  char *p = strdup(str);
+  wxTextFile::Close();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__Create__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxTextFile::Create(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__Create__leakignore() {
+  char *p = strdup(str);
+  wxTextFile::Create(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__Create__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTextFile::Create(x);
+}
+
+void test__wxTextFile__Eof__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTextFile::Eof();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__Eof__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::Eof();
+}
+
+void test__wxTextFile__Eof__leakignore() {
+  char *p = strdup(str);
+  result = wxTextFile::Eof();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__Exists__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTextFile::Exists();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__Exists__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::Exists();
+}
+
+void test__wxTextFile__Exists__leakignore() {
+  char *p = strdup(str);
+  result = wxTextFile::Exists();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__GetCurrentLine__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTextFile::GetCurrentLine();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetCurrentLine__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetCurrentLine();
+}
+
+void test__wxTextFile__GetCurrentLine__leakignore() {
+  char *p = strdup(str);
+  result = wxTextFile::GetCurrentLine();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__GetFirstLine__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTextFile::GetFirstLine();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetFirstLine__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetFirstLine();
+}
+
+void test__wxTextFile__GetFirstLine__leakignore() {
+  char *p = strdup(str);
+  result = wxTextFile::GetFirstLine();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__GetLastLine__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTextFile::GetLastLine();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetLastLine__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetLastLine();
+}
+
+void test__wxTextFile__GetLastLine__leakignore() {
+  char *p = strdup(str);
+  result = wxTextFile::GetLastLine();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__GetLineCount__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTextFile::GetLineCount();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetLineCount__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetLineCount();
+}
+
+void test__wxTextFile__GetLineCount__leakignore() {
+  char *p = strdup(str);
+  result = wxTextFile::GetLineCount();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__GetLineType__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTextFile::GetLineType();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetLineType__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetLineType();
+}
+
+void test__wxTextFile__GetLineType__leakignore() {
+  char *p = strdup(str);
+  result = wxTextFile::GetLineType();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__GetName__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTextFile::GetName();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetName__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetName();
+}
+
+void test__wxTextFile__GetName__leakignore() {
+  char *p = strdup(str);
+  result = wxTextFile::GetName();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__GetNextLine__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTextFile::GetNextLine();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetNextLine__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetNextLine();
+}
+
+void test__wxTextFile__GetNextLine__leakignore() {
+  char *p = strdup(str);
+  result = wxTextFile::GetNextLine();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__GetPrevLine__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTextFile::GetPrevLine();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GetPrevLine__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GetPrevLine();
+}
+
+void test__wxTextFile__GetPrevLine__leakignore() {
+  char *p = strdup(str);
+  result = wxTextFile::GetPrevLine();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__GoToLine__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxTextFile::GoToLine(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GoToLine__leakignore() {
+  char *p = strdup(str);
+  wxTextFile::GoToLine(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__GoToLine__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTextFile::GoToLine(x);
+}
+
+void test__wxTextFile__GuessType__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxTextFile::GuessType();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__GuessType__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::GuessType();
+}
+
+void test__wxTextFile__GuessType__leakignore() {
+  char *p = strdup(str);
+  result = wxTextFile::GuessType();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__InsertLine__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxTextFile::InsertLine(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__InsertLine__leakignore() {
+  char *p = strdup(str);
+  wxTextFile::InsertLine(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else result = wxTextFile::IsOpened();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__IsOpened__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxTextFile::IsOpened();
+}
+
+void test__wxTextFile__IsOpened__leakignore() {
+  char *p = strdup(str);
+  result = wxTextFile::IsOpened();
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__RemoveLine__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxTextFile::RemoveLine(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxTextFile__RemoveLine__leakignore() {
+  char *p = strdup(str);
+  wxTextFile::RemoveLine(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__RemoveLine__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxTextFile::RemoveLine(x);
+}
+
+void test__wxTextFile__GetLine__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__leakignore() {
+  char *p = strdup(str);
+  result = wxTextFile::GetLine(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxTextFile__GetLine__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxTextFile::GetLine(x);
+}
+
+void test__wxSizer__AddSpacer__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxSizer::AddSpacer(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSizer__AddSpacer__leakignore() {
+  char *p = strdup(str);
+  wxSizer::AddSpacer(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxSizer__AddSpacer__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxSizer::AddSpacer(x);
+}
+
+void test__wxBoxSizer__AddSpacer__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxBoxSizer::AddSpacer(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxBoxSizer__AddSpacer__leakignore() {
+  char *p = strdup(str);
+  wxBoxSizer::AddSpacer(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxBoxSizer__AddSpacer__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxBoxSizer::AddSpacer(x);
+}
+
+void test__wxBoxSizer__CalcMin__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxBoxSizer::CalcMin();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxBoxSizer__CalcMin__leakignore() {
+  char *p = strdup(str);
+  wxBoxSizer::CalcMin();
+  // cppcheck-suppress memleak
+}
+
+void test__wxBoxSizer__GetOrientation__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxBoxSizer::GetOrientation();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxBoxSizer__GetOrientation__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxBoxSizer::GetOrientation();
+}
+
+void test__wxBoxSizer__GetOrientation__leakignore() {
+  char *p = strdup(str);
+  result = wxBoxSizer::GetOrientation();
+  // cppcheck-suppress memleak
+}
+
+void test__wxBoxSizer__RecalcSizes__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxBoxSizer::RecalcSizes();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxBoxSizer__RecalcSizes__leakignore() {
+  char *p = strdup(str);
+  wxBoxSizer::RecalcSizes();
+  // cppcheck-suppress memleak
+}
+
+void test__wxBoxSizer__SetOrientation__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxBoxSizer::SetOrientation(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxBoxSizer__SetOrientation__leakignore() {
+  char *p = strdup(str);
+  wxBoxSizer::SetOrientation(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxBoxSizer__SetOrientation__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxBoxSizer::SetOrientation(x);
+}
+
+void test__wxStaticBoxSizer__CalcMin__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxStaticBoxSizer::CalcMin();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxStaticBoxSizer__CalcMin__leakignore() {
+  char *p = strdup(str);
+  wxStaticBoxSizer::CalcMin();
+  // cppcheck-suppress memleak
+}
+
+void test__wxStaticBoxSizer__GetStaticBox__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxStaticBoxSizer::GetStaticBox();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxStaticBoxSizer__GetStaticBox__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxStaticBoxSizer::GetStaticBox();
+}
+
+void test__wxStaticBoxSizer__GetStaticBox__leakignore() {
+  char *p = strdup(str);
+  result = wxStaticBoxSizer::GetStaticBox();
+  // cppcheck-suppress memleak
+}
+
+void test__wxStaticBoxSizer__RecalcSizes__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxStaticBoxSizer::RecalcSizes();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxStaticBoxSizer__RecalcSizes__leakignore() {
+  char *p = strdup(str);
+  wxStaticBoxSizer::RecalcSizes();
+  // cppcheck-suppress memleak
+}
+
+void test__wxMenu__Append__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxMenu::Append(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxMenu__Append__leakignore() {
+  char *p = strdup(str);
+  wxMenu::Append(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else wxLaunchDefaultBrowser(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxLaunchDefaultBrowser__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else result = wxDirExists(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxDirExists__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxDirExists(arg1);
+}
+
+void test__wxDirExists__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else result = wxFileExists(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxFileExists__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxFileExists(arg1);
+}
+
+void test__wxFileExists__leakignore() {
+  char *p = strdup(str);
+  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 = 100;
+  if (cond) x=1; else 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 = 100;
+  if (cond) x=1; else result = wxGetCwd();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxGetCwd__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxGetCwd();
+}
+
+void test__wxSetWorkingDirectory__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxSetWorkingDirectory(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSetWorkingDirectory__leakignore() {
+  char *p = strdup(str);
+  wxSetWorkingDirectory(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxSetWorkingDirectory__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxSetWorkingDirectory(x);
+}
+
+void test__wxMkdir__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxMkdir(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxMkdir__leakignore() {
+  char *p = strdup(str);
+  wxMkdir(p, arg2);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else wxRmdir(arg1, arg2);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxRmdir__leakignore() {
+  char *p = strdup(str);
+  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__wxGetTranslation__noreturn() {
+  int x = 100;
+  if (cond) x=1; else 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__wxGetTranslation__leakignore() {
+  char *p = strdup(str);
+  result = wxGetTranslation(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+void test__wxGetTranslation__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxGetTranslation(x, arg2, arg3, arg4);
+}
+
+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 = 100;
+  if (cond) x=1; else wxApp::MacOpenFile(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxApp__MacOpenFile__leakignore() {
+  char *p = strdup(str);
+  wxApp::MacOpenFile(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxApp__MacOpenFile__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxApp::MacOpenFile(x);
+}
+
+void test__wxArtProvider__Insert__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxArtProvider::Insert(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxArtProvider__Insert__leakignore() {
+  char *p = strdup(str);
+  wxArtProvider::Insert(p);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else wxCalendarCtrl::EnableYearChange(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxCalendarCtrl__EnableYearChange__leakignore() {
+  char *p = strdup(str);
+  wxCalendarCtrl::EnableYearChange(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxCalendarCtrl__EnableYearChange__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxCalendarCtrl::EnableYearChange(x);
+}
+
+void test__wxComboCtrl__GetTextIndent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxComboCtrl::GetTextIndent();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxComboCtrl__GetTextIndent__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxComboCtrl::GetTextIndent();
+}
+
+void test__wxComboCtrl__GetTextIndent__leakignore() {
+  char *p = strdup(str);
+  result = wxComboCtrl::GetTextIndent();
+  // cppcheck-suppress memleak
+}
+
+void test__wxComboCtrl__HidePopup__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxComboCtrl::HidePopup(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxComboCtrl__HidePopup__leakignore() {
+  char *p = strdup(str);
+  wxComboCtrl::HidePopup(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxComboCtrl__HidePopup__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxComboCtrl::HidePopup(x);
+}
+
+void test__wxComboCtrl__ShowPopup__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxComboCtrl::ShowPopup();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxComboCtrl__ShowPopup__leakignore() {
+  char *p = strdup(str);
+  wxComboCtrl::ShowPopup();
+  // cppcheck-suppress memleak
+}
+
+void test__wxComboCtrl__SetTextIndent__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxComboCtrl::SetTextIndent(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxComboCtrl__SetTextIndent__leakignore() {
+  char *p = strdup(str);
+  wxComboCtrl::SetTextIndent(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxComboCtrl__SetTextIndent__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxComboCtrl::SetTextIndent(x);
+}
+
+void test__wxDataViewCustomRenderer__Activate__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxDataViewCustomRenderer::Activate(arg1, arg2, arg3, arg4);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxDataViewCustomRenderer__Activate__leakignore() {
+  char *p = strdup(str);
+  wxDataViewCustomRenderer::Activate(p, arg2, arg3, arg4);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxDataViewCustomRenderer__LeftClick__leakignore() {
+  char *p = strdup(str);
+  wxDataViewCustomRenderer::LeftClick(p, arg2, arg3, arg4, arg5);
+  // cppcheck-suppress memleak
+}
+
+void test__wxDataViewCustomRenderer__LeftClick__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxDataViewCustomRenderer::LeftClick(x, arg2, arg3, arg4, arg5);
+}
+
+void test__wxDataViewCustomRenderer__LeftClick__arg2__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxDataViewCustomRenderer::LeftClick(arg1, x, arg3, arg4, arg5);
+}
+
+void test__wxDataViewCustomRenderer__LeftClick__arg3__notnull() {
+  // cppcheck-suppress nullPointer
+  wxDataViewCustomRenderer::LeftClick(arg1, arg2, NULL, arg4, arg5);
+}
+
+void test__wxDataViewCustomRenderer__LeftClick__arg4__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, x, arg5);
+}
+
+void test__wxDataViewCustomRenderer__LeftClick__arg5__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, arg4, x);
+}
+
+void test__wxDebugContext__GetLevel__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxDebugContext::GetLevel();
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxDebugContext__GetLevel__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxDebugContext::GetLevel();
+}
+
+void test__wxDebugContext__GetLevel__leakignore() {
+  char *p = strdup(str);
+  result = wxDebugContext::GetLevel();
+  // cppcheck-suppress memleak
+}
+
+void test__wxDebugContext__SetLevel__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxDebugContext::SetLevel(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxDebugContext__SetLevel__leakignore() {
+  char *p = strdup(str);
+  wxDebugContext::SetLevel(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxDebugContext__SetLevel__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxDebugContext::SetLevel(x);
+}
+
+void test__wxDos2UnixFilename__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxDos2UnixFilename(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxDos2UnixFilename__leakignore() {
+  char *p = strdup(str);
+  wxDos2UnixFilename(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxDos2UnixFilename__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxDos2UnixFilename(NULL);
+}
+
+void test__wxDos2UnixFilename__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxDos2UnixFilename(x);
+}
+
+void test__wxFileNameFromPath__noreturn() {
+  int x = 100;
+  if (cond) x=1; else result = wxFileNameFromPath(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxFileNameFromPath__useretval() {
+  // cppcheck-suppress ignoredReturnValue
+  wxFileNameFromPath(arg1);
+}
+
+void test__wxFileNameFromPath__leakignore() {
+  char *p = strdup(str);
+  result = wxFileNameFromPath(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxFileNameFromPath__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  result = wxFileNameFromPath(x);
+}
+
+void test__wxSizerItem__SetWindow__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxSizerItem::SetWindow(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSizerItem__SetWindow__leakignore() {
+  char *p = strdup(str);
+  wxSizerItem::SetWindow(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxSizerItem__SetWindow__arg1__notnull() {
+  // cppcheck-suppress nullPointer
+  wxSizerItem::SetWindow(NULL);
+}
+
+void test__wxSizerItem__SetWindow__arg1__notuninit() {
+  int x[10];
+  // cppcheck-suppress uninitvar
+  wxSizerItem::SetWindow(x);
+}
+
+void test__wxSizerItem__SetSizer__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxSizerItem::SetSizer(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSizerItem__SetSizer__leakignore() {
+  char *p = strdup(str);
+  wxSizerItem::SetSizer(p);
+  // cppcheck-suppress memleak
+}
+
+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 = 100;
+  if (cond) x=1; else wxSizerItem::SetSpacer(arg1);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxSizerItem__SetSpacer__leakignore() {
+  char *p = strdup(str);
+  wxSizerItem::SetSpacer(p);
+  // cppcheck-suppress memleak
+}
+
+void test__wxSizerItem__SetSpacer__arg1__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxSizerItem::SetSpacer(x);
+}
+
+void test__wxGrid__SetCellAlignment__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxGrid::SetCellAlignment(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxGrid__SetCellAlignment__leakignore() {
+  char *p = strdup(str);
+  wxGrid::SetCellAlignment(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxGrid::SetCellAlignment(arg1, arg2, x);
+}
+
+void test__wxGrid__SetCellTextColour__noreturn() {
+  int x = 100;
+  if (cond) x=1; else wxGrid::SetCellTextColour(arg1, arg2, arg3);
+  // cppcheck-suppress shiftTooManyBits
+  x = 1 << x;
+}
+
+void test__wxGrid__SetCellTextColour__leakignore() {
+  char *p = strdup(str);
+  wxGrid::SetCellTextColour(p, arg2, arg3);
+  // cppcheck-suppress memleak
+}
+
+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__arg3__notuninit() {
+  int x;
+  // cppcheck-suppress uninitvar
+  wxGrid::SetCellTextColour(arg1, arg2, x);
+}
+