// 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 --platform=unix64 generated-cfg-tests-posix.cpp
// => 'unmatched suppression' warnings are false negatives.
//

void test__a64l__noreturn() {
  int x = 1;
  if (cond) { x=100; result = a64l(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__a64l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  a64l(arg1);
}

void test__a64l__leakignore() {
  char *p = malloc(10); *p=0;
  result = a64l(p);
  // cppcheck-suppress memleak
}

void test__a64l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = a64l(p);
}

void test__a64l__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = a64l(x);
}

void test__l64a__noreturn() {
  int x = 1;
  if (cond) { x=100; result = l64a(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__l64a__useretval() {
  // cppcheck-suppress ignoredReturnValue
  l64a(arg1);
}

void test__l64a__leakignore() {
  char *p = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; accept(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__accept__leakignore() {
  char *p = malloc(10); *p=0;
  accept(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__accept__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  accept(x, arg2, arg3);
}

void test__accept__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  accept(arg1, x, arg3);
}

void test__accept__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  accept(arg1, arg2, x);
}

void test__access__noreturn() {
  int x = 1;
  if (cond) { x=100; result = access(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__access__useretval() {
  // cppcheck-suppress ignoredReturnValue
  access(arg1, arg2);
}

void test__access__leakignore() {
  char *p = malloc(10); *p=0;
  result = access(p, arg2);
  // cppcheck-suppress memleak
}

void test__access__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = access(p, arg2);
}

void test__access__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = access(x, arg2);
}

void test__access__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = access(arg1, x);
}

void test__adjtime__noreturn() {
  int x = 1;
  if (cond) { x=100; adjtime(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__adjtime__leakignore() {
  char *p = malloc(10); *p=0;
  adjtime(p, arg2);
  // cppcheck-suppress memleak
}

void test__adjtime__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  adjtime(x, arg2);
}

void test__gettimeofday__noreturn() {
  int x = 1;
  if (cond) { x=100; gettimeofday(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__gettimeofday__leakignore() {
  char *p = malloc(10); *p=0;
  gettimeofday(p, arg2);
  // cppcheck-suppress memleak
}

void test__settimeofday__noreturn() {
  int x = 1;
  if (cond) { x=100; settimeofday(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__settimeofday__leakignore() {
  char *p = malloc(10); *p=0;
  settimeofday(p, arg2);
  // cppcheck-suppress memleak
}

void test__settimeofday__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  settimeofday(x, arg2);
}

void test__settimeofday__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  settimeofday(arg1, x);
}

void test__FD_CLR__noreturn() {
  int x = 1;
  if (cond) { x=100; FD_CLR(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FD_CLR__leakignore() {
  char *p = malloc(10); *p=0;
  FD_CLR(p, arg2);
  // cppcheck-suppress memleak
}

void test__FD_CLR__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  FD_CLR(x, arg2);
}

void test__FD_CLR__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  FD_CLR(arg1, p);
}

void test__FD_ISSET__noreturn() {
  int x = 1;
  if (cond) { x=100; FD_ISSET(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FD_ISSET__leakignore() {
  char *p = malloc(10); *p=0;
  FD_ISSET(p, arg2);
  // cppcheck-suppress memleak
}

void test__FD_ISSET__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  FD_ISSET(x, arg2);
}

void test__FD_ISSET__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  FD_ISSET(arg1, p);
}

void test__FD_SET__noreturn() {
  int x = 1;
  if (cond) { x=100; FD_SET(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FD_SET__leakignore() {
  char *p = malloc(10); *p=0;
  FD_SET(p, arg2);
  // cppcheck-suppress memleak
}

void test__FD_SET__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  FD_SET(x, arg2);
}

void test__FD_SET__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  FD_SET(arg1, p);
}

void test__FD_ZERO__noreturn() {
  int x = 1;
  if (cond) { x=100; FD_ZERO(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FD_ZERO__leakignore() {
  char *p = malloc(10); *p=0;
  FD_ZERO(p);
  // cppcheck-suppress memleak
}

void test__FD_ZERO__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  FD_ZERO(p);
}

void test__fdatasync__noreturn() {
  int x = 1;
  if (cond) { x=100; fdatasync(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__fdatasync__leakignore() {
  char *p = malloc(10); *p=0;
  fdatasync(p);
  // cppcheck-suppress memleak
}

void test__fdatasync__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  fdatasync(x);
}

void test__fnmatch__noreturn() {
  int x = 1;
  if (cond) { x=100; result = fnmatch(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__fnmatch__useretval() {
  // cppcheck-suppress ignoredReturnValue
  fnmatch(arg1, arg2, arg3);
}

void test__fnmatch__pure(int arg1,int arg2,int arg3) {
  // cppcheck-suppress incorrectLogicOperator
  if ((fnmatch(arg1, arg2, arg3) > 10) || (fnmatch(arg1, arg2, arg3) < 100)) {}
}

void test__fnmatch__leakignore() {
  char *p = malloc(10); *p=0;
  result = fnmatch(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__fnmatch__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = fnmatch(p, arg2, arg3);
}

void test__fnmatch__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = fnmatch(x, arg2, arg3);
}

void test__fnmatch__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = fnmatch(arg1, p, arg3);
}

void test__fnmatch__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = fnmatch(arg1, x, arg3);
}

void test__fnmatch__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = fnmatch(arg1, arg2, x);
}

void test__fsync__noreturn() {
  int x = 1;
  if (cond) { x=100; fsync(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__fsync__leakignore() {
  char *p = malloc(10); *p=0;
  fsync(p);
  // cppcheck-suppress memleak
}

void test__fsync__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  fsync(x);
}

void test__truncate__noreturn() {
  int x = 1;
  if (cond) { x=100; truncate(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__truncate__leakignore() {
  char *p = malloc(10); *p=0;
  truncate(p, arg2);
  // cppcheck-suppress memleak
}

void test__truncate__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  truncate(p, arg2);
}

void test__truncate__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  truncate(x, arg2);
}

void test__truncate__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  truncate(arg1, x);
}

void test__ftruncate__noreturn() {
  int x = 1;
  if (cond) { x=100; ftruncate(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ftruncate__leakignore() {
  char *p = malloc(10); *p=0;
  ftruncate(p, arg2);
  // cppcheck-suppress memleak
}

void test__ftruncate__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ftruncate(x, arg2);
}

void test__ftruncate__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ftruncate(arg1, x);
}

void test__flock__noreturn() {
  int x = 1;
  if (cond) { x=100; flock(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__flock__leakignore() {
  char *p = malloc(10); *p=0;
  flock(p, arg2);
  // cppcheck-suppress memleak
}

void test__flock__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  flock(x, arg2);
}

void test__flock__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  flock(arg1, x);
}

void test__symlink__noreturn() {
  int x = 1;
  if (cond) { x=100; symlink(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__symlink__leakignore() {
  char *p = malloc(10); *p=0;
  symlink(p, arg2);
  // cppcheck-suppress memleak
}

void test__symlink__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  symlink(p, arg2);
}

void test__symlink__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  symlink(x, arg2);
}

void test__symlink__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  symlink(arg1, p);
}

void test__symlink__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  symlink(arg1, x);
}

void test__open__noreturn() {
  int x = 1;
  if (cond) { x=100; open(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__open__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  open(p, arg2, arg3);
}

void test__open__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  open(x, arg2, arg3);
}

void test__open__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  open(arg1, x, arg3);
}

void test__open__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  open(arg1, arg2, x);
}

void test__creat__noreturn() {
  int x = 1;
  if (cond) { x=100; result = creat(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__creat__useretval() {
  // cppcheck-suppress ignoredReturnValue
  creat(arg1, arg2);
}

void test__creat__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = creat(p, arg2);
}

void test__creat__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = creat(x, arg2);
}

void test__creat__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = creat(arg1, x);
}

void test__sleep__noreturn() {
  int x = 1;
  if (cond) { x=100; sleep(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sleep__leakignore() {
  char *p = malloc(10); *p=0;
  sleep(p);
  // cppcheck-suppress memleak
}

void test__sleep__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  sleep(!x);
}

void test__sleep__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sleep(x);
}

void test__usleep__noreturn() {
  int x = 1;
  if (cond) { x=100; usleep(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__usleep__leakignore() {
  char *p = malloc(10); *p=0;
  usleep(p);
  // cppcheck-suppress memleak
}

void test__usleep__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  usleep(!x);
}

void test___exit__noreturn() {
  int x = 1;
  if (cond) { x=100; _exit(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___exit__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _exit(x);
}

void test__faccessat__noreturn() {
  int x = 1;
  if (cond) { x=100; faccessat(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__faccessat__leakignore() {
  char *p = malloc(10); *p=0;
  faccessat(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__faccessat__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  faccessat(x, arg2, arg3, arg4);
}

void test__faccessat__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  faccessat(arg1, p, arg3, arg4);
}

void test__faccessat__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  faccessat(arg1, x, arg3, arg4);
}

void test__faccessat__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  faccessat(arg1, arg2, x, arg4);
}

void test__faccessat__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  faccessat(arg1, arg2, arg3, x);
}

void test__acct__noreturn() {
  int x = 1;
  if (cond) { x=100; acct(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__acct__leakignore() {
  char *p = malloc(10); *p=0;
  acct(p);
  // cppcheck-suppress memleak
}

void test__acct__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  acct(x);
}

void test__alarm__noreturn() {
  int x = 1;
  if (cond) { x=100; alarm(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__alarm__leakignore() {
  char *p = malloc(10); *p=0;
  alarm(p);
  // cppcheck-suppress memleak
}

void test__alarm__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  alarm(x);
}

void test__getrpcent__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getrpcent(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getrpcent__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getrpcent();
}

void test__getrpcent__leakignore() {
  char *p = malloc(10); *p=0;
  result = getrpcent();
  // cppcheck-suppress memleak
}

void test__getrpcbyname__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getrpcbyname(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getrpcbyname__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getrpcbyname(arg1);
}

void test__getrpcbyname__leakignore() {
  char *p = malloc(10); *p=0;
  result = getrpcbyname(p);
  // cppcheck-suppress memleak
}

void test__getrpcbyname__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = getrpcbyname(p);
}

void test__getrpcbyname__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = getrpcbyname(x);
}

void test__getrpcbynumber__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getrpcbynumber(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getrpcbynumber__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getrpcbynumber(arg1);
}

void test__getrpcbynumber__leakignore() {
  char *p = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; result = getprotoent(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getprotoent__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getprotoent();
}

void test__getprotoent__leakignore() {
  char *p = malloc(10); *p=0;
  result = getprotoent();
  // cppcheck-suppress memleak
}

void test__getprotobyname__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getprotobyname(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getprotobyname__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getprotobyname(arg1);
}

void test__getprotobyname__leakignore() {
  char *p = malloc(10); *p=0;
  result = getprotobyname(p);
  // cppcheck-suppress memleak
}

void test__getprotobyname__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = getprotobyname(p);
}

void test__getprotobyname__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = getprotobyname(x);
}

void test__getprotobynumber__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getprotobynumber(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getprotobynumber__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getprotobynumber(arg1);
}

void test__getprotobynumber__leakignore() {
  char *p = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; result = getservent(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getservent__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getservent();
}

void test__getservent__leakignore() {
  char *p = malloc(10); *p=0;
  result = getservent();
  // cppcheck-suppress memleak
}

void test__getservbyname__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getservbyname(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getservbyname__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getservbyname(arg1, arg2);
}

void test__getservbyname__leakignore() {
  char *p = malloc(10); *p=0;
  result = getservbyname(p, arg2);
  // cppcheck-suppress memleak
}

void test__getservbyname__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = getservbyname(p, 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 = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; result = getnetent(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getnetent__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getnetent();
}

void test__getnetent__leakignore() {
  char *p = malloc(10); *p=0;
  result = getnetent();
  // cppcheck-suppress memleak
}

void test__getnetbyname__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getnetbyname(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getnetbyname__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getnetbyname(arg1);
}

void test__getnetbyname__leakignore() {
  char *p = malloc(10); *p=0;
  result = getnetbyname(p);
  // cppcheck-suppress memleak
}

void test__getnetbyname__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = getnetbyname(p);
}

void test__getnetbyname__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = getnetbyname(x);
}

void test__getnetbyaddr__noreturn() {
  int x = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; result = gethostent(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__gethostent__useretval() {
  // cppcheck-suppress ignoredReturnValue
  gethostent();
}

void test__gethostent__leakignore() {
  char *p = malloc(10); *p=0;
  result = gethostent();
  // cppcheck-suppress memleak
}

void test__gethostbyname__noreturn() {
  int x = 1;
  if (cond) { x=100; result = gethostbyname(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__gethostbyname__useretval() {
  // cppcheck-suppress ignoredReturnValue
  gethostbyname(arg1);
}

void test__gethostbyname__leakignore() {
  char *p = malloc(10); *p=0;
  result = gethostbyname(p);
  // cppcheck-suppress memleak
}

void test__gethostbyname__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = gethostbyname(p);
}

void test__gethostbyname__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = gethostbyname(x);
}

void test__gethostbyname2__noreturn() {
  int x = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  result = gethostbyname2(p, arg2);
  // cppcheck-suppress memleak
}

void test__gethostbyname2__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = gethostbyname2(p, 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 = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  result = gethostbyaddr(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__gethostbyaddr__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = gethostbyaddr(p, 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 = 1;
  if (cond) { x=100; brk(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__brk__leakignore() {
  char *p = malloc(10); *p=0;
  brk(p);
  // cppcheck-suppress memleak
}

void test__brk__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  brk(p);
}

void test__sbrk__noreturn() {
  int x = 1;
  if (cond) { x=100; sbrk(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sbrk__leakignore() {
  char *p = malloc(10); *p=0;
  sbrk(p);
  // cppcheck-suppress memleak
}

void test__sbrk__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sbrk(x);
}

void test__closedir__noreturn() {
  int x = 1;
  if (cond) { x=100; closedir(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__closedir__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  closedir(!x);
}

void test__closedir__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  closedir(p);
}

void test__closedir__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  closedir(x);
}

void test__strfry__noreturn() {
  int x = 1;
  if (cond) { x=100; strfry(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__strfry__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  strfry(p);
}

void test__strsep__noreturn() {
  int x = 1;
  if (cond) { x=100; strsep(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__strsep__leakignore() {
  char *p = malloc(10); *p=0;
  strsep(p, arg2);
  // cppcheck-suppress memleak
}

void test__strsep__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  strsep(p, arg2);
}

void test__strsep__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  strsep(x, arg2);
}

void test__strsep__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  strsep(arg1, p);
}

void test__strsep__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  strsep(arg1, x);
}

void test__strdup__noreturn() {
  int x = 1;
  if (cond) { x=100; strdup(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__strdup__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  strdup(p);
}

void test__strdup__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  strdup(x);
}

void test__strndup__noreturn() {
  int x = 1;
  if (cond) { x=100; strndup(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__strndup__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  strndup(p, 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 = 1;
  if (cond) { x=100; wcsdup(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wcsdup__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  wcsdup(p);
}

void test__wcsdup__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wcsdup(x);
}

void test__mkstemp__noreturn() {
  int x = 1;
  if (cond) { x=100; mkstemp(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__mkstemp__leakignore() {
  char *p = malloc(10); *p=0;
  mkstemp(p);
  // cppcheck-suppress memleak
}

void test__mkstemp__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  mkstemp(p);
}

void test__mkstemp__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  mkstemp(x);
}

void test__mkdtemp__noreturn() {
  int x = 1;
  if (cond) { x=100; mkdtemp(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__mkdtemp__leakignore() {
  char *p = malloc(10); *p=0;
  mkdtemp(p);
  // cppcheck-suppress memleak
}

void test__mkdtemp__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  mkdtemp(p);
}

void test__mkdtemp__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  mkdtemp(x);
}

void test__mktemp__noreturn() {
  int x = 1;
  if (cond) { x=100; result = mktemp(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__mktemp__useretval() {
  // cppcheck-suppress ignoredReturnValue
  mktemp(arg1);
}

void test__mktemp__leakignore() {
  char *p = malloc(10); *p=0;
  result = mktemp(p);
  // cppcheck-suppress memleak
}

void test__mktemp__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = mktemp(p);
}

void test__mktemp__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = mktemp(x);
}

void test__getcwd__noreturn() {
  int x = 1;
  if (cond) { x=100; getcwd(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getcwd__leakignore() {
  char *p = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; mkdir(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__mkdir__leakignore() {
  char *p = malloc(10); *p=0;
  mkdir(p, arg2);
  // cppcheck-suppress memleak
}

void test__mkdir__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  mkdir(p, 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 = 1;
  if (cond) { x=100; rmdir(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__rmdir__leakignore() {
  char *p = malloc(10); *p=0;
  rmdir(p);
  // cppcheck-suppress memleak
}

void test__rmdir__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  rmdir(p);
}

void test__rmdir__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  rmdir(x);
}

void test__chdir__noreturn() {
  int x = 1;
  if (cond) { x=100; chdir(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__chdir__leakignore() {
  char *p = malloc(10); *p=0;
  chdir(p);
  // cppcheck-suppress memleak
}

void test__chdir__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  chdir(p);
}

void test__chdir__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  chdir(x);
}

void test__chroot__noreturn() {
  int x = 1;
  if (cond) { x=100; chroot(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__chroot__leakignore() {
  char *p = malloc(10); *p=0;
  chroot(p);
  // cppcheck-suppress memleak
}

void test__chroot__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  chroot(p);
}

void test__chroot__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  chroot(x);
}

void test__link__noreturn() {
  int x = 1;
  if (cond) { x=100; link(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__link__leakignore() {
  char *p = malloc(10); *p=0;
  link(p, arg2);
  // cppcheck-suppress memleak
}

void test__link__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  link(p, arg2);
}

void test__link__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  link(x, arg2);
}

void test__link__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  link(arg1, p);
}

void test__link__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  link(arg1, x);
}

void test__unlink__noreturn() {
  int x = 1;
  if (cond) { x=100; unlink(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__unlink__leakignore() {
  char *p = malloc(10); *p=0;
  unlink(p);
  // cppcheck-suppress memleak
}

void test__unlink__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  unlink(p);
}

void test__unlink__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  unlink(x);
}

void test__rename__noreturn() {
  int x = 1;
  if (cond) { x=100; rename(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__rename__leakignore() {
  char *p = malloc(10); *p=0;
  rename(p);
  // cppcheck-suppress memleak
}

void test__rename__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  rename(p);
}

void test__rename__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  rename(x);
}

void test__stat__noreturn() {
  int x = 1;
  if (cond) { x=100; stat(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__stat__leakignore() {
  char *p = malloc(10); *p=0;
  stat(p, arg2);
  // cppcheck-suppress memleak
}

void test__stat__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  stat(p, arg2);
}

void test__stat__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  stat(x, arg2);
}

void test__stat__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  stat(arg1, p);
}

void test__lstat__noreturn() {
  int x = 1;
  if (cond) { x=100; lstat(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__lstat__leakignore() {
  char *p = malloc(10); *p=0;
  lstat(p, arg2);
  // cppcheck-suppress memleak
}

void test__lstat__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  lstat(p, arg2);
}

void test__lstat__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  lstat(x, arg2);
}

void test__lstat__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  lstat(arg1, p);
}

void test__fstat__noreturn() {
  int x = 1;
  if (cond) { x=100; fstat(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__fstat__leakignore() {
  char *p = malloc(10); *p=0;
  fstat(p, arg2);
  // cppcheck-suppress memleak
}

void test__fstat__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  fstat(x, arg2);
}

void test__fstat__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  fstat(arg1, p);
}

void test__chmod__noreturn() {
  int x = 1;
  if (cond) { x=100; chmod(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__chmod__leakignore() {
  char *p = malloc(10); *p=0;
  chmod(p, arg2);
  // cppcheck-suppress memleak
}

void test__chmod__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  chmod(p, 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 = 1;
  if (cond) { x=100; fchmod(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__fchmod__leakignore() {
  char *p = malloc(10); *p=0;
  fchmod(p, arg2);
  // cppcheck-suppress memleak
}

void test__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 = 1;
  if (cond) { x=100; chown(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__chown__leakignore() {
  char *p = malloc(10); *p=0;
  chown(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__chown__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  chown(p, 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 = 1;
  if (cond) { x=100; lchown(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__lchown__leakignore() {
  char *p = malloc(10); *p=0;
  lchown(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__lchown__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  lchown(p, 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 = 1;
  if (cond) { x=100; fchown(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__fchown__leakignore() {
  char *p = malloc(10); *p=0;
  fchown(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__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 = 1;
  if (cond) { x=100; times(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__times__leakignore() {
  char *p = malloc(10); *p=0;
  times(p);
  // cppcheck-suppress memleak
}

void test__times__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  times(x);
}

void test__utime__noreturn() {
  int x = 1;
  if (cond) { x=100; utime(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__utime__leakignore() {
  char *p = malloc(10); *p=0;
  utime(p, arg2);
  // cppcheck-suppress memleak
}

void test__utime__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  utime(p, 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 = 1;
  if (cond) { x=100; utimes(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__utimes__leakignore() {
  char *p = malloc(10); *p=0;
  utimes(p, arg2);
  // cppcheck-suppress memleak
}

void test__utimes__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  utimes(p, 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 = 1;
  if (cond) { x=100; result = opendir(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__opendir__useretval() {
  // cppcheck-suppress ignoredReturnValue
  opendir(arg1);
}

void test__opendir__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = opendir(p);
}

void test__opendir__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = opendir(x);
}

void test__fdopendir__noreturn() {
  int x = 1;
  if (cond) { x=100; 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 = 1;
  if (cond) { x=100; result = isatty(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__isatty__useretval() {
  // cppcheck-suppress ignoredReturnValue
  isatty(arg1);
}

void test__isatty__leakignore() {
  char *p = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; 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() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = popen(p, arg2);
}

void test__popen__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = popen(x, arg2);
}

void test__popen__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = popen(arg1, p);
}

void test__popen__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = popen(arg1, x);
}

void test__pclose__noreturn() {
  int x = 1;
  if (cond) { x=100; pclose(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pclose__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  pclose(p);
}

void test__pclose__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  pclose(x);
}

void test__socket__noreturn() {
  int x = 1;
  if (cond) { x=100; 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 = 1;
  if (cond) { x=100; nice(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__nice__leakignore() {
  char *p = malloc(10); *p=0;
  nice(p);
  // cppcheck-suppress memleak
}

void test__nice__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  nice(x);
}

void test__pause__noreturn() {
  int x = 1;
  if (cond) { x=100; pause(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pause__leakignore() {
  char *p = malloc(10); *p=0;
  pause();
  // cppcheck-suppress memleak
}

void test__close__noreturn() {
  int x = 1;
  if (cond) { x=100; close(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__close__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  close(x);
}

void test__confstr__noreturn() {
  int x = 1;
  if (cond) { x=100; confstr(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__confstr__leakignore() {
  char *p = malloc(10); *p=0;
  confstr(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__confstr__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  confstr(x, arg2, arg3);
}

void test__confstr__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  confstr(arg1, x, arg3);
}

void test__confstr__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  confstr(arg1, arg2, x);
}

void test__fpathconf__noreturn() {
  int x = 1;
  if (cond) { x=100; fpathconf(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__fpathconf__leakignore() {
  char *p = malloc(10); *p=0;
  fpathconf(p, arg2);
  // cppcheck-suppress memleak
}

void test__fpathconf__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  fpathconf(x, arg2);
}

void test__fpathconf__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  fpathconf(arg1, x);
}

void test__pathconf__noreturn() {
  int x = 1;
  if (cond) { x=100; pathconf(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pathconf__leakignore() {
  char *p = malloc(10); *p=0;
  pathconf(p, arg2);
  // cppcheck-suppress memleak
}

void test__pathconf__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  pathconf(p, 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 = 1;
  if (cond) { x=100; sysconf(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sysconf__leakignore() {
  char *p = malloc(10); *p=0;
  sysconf(p);
  // cppcheck-suppress memleak
}

void test__sysconf__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sysconf(x);
}

void test__fdopen__noreturn() {
  int x = 1;
  if (cond) { x=100; 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() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = fdopen(arg1, p);
}

void test__fdopen__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = fdopen(arg1, x);
}

void test__random__noreturn() {
  int x = 1;
  if (cond) { x=100; result = random(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__random__useretval() {
  // cppcheck-suppress ignoredReturnValue
  random();
}

void test__srandom__noreturn() {
  int x = 1;
  if (cond) { x=100; srandom(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__rewinddir__noreturn() {
  int x = 1;
  if (cond) { x=100; rewinddir(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__rewinddir__leakignore() {
  char *p = malloc(10); *p=0;
  rewinddir(p);
  // cppcheck-suppress memleak
}

void test__rewinddir__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  rewinddir(p);
}

void test__rewinddir__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  rewinddir(x);
}

void test__seekdir__noreturn() {
  int x = 1;
  if (cond) { x=100; seekdir(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__seekdir__leakignore() {
  char *p = malloc(10); *p=0;
  seekdir(p, arg2);
  // cppcheck-suppress memleak
}

void test__seekdir__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  seekdir(p, 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 = 1;
  if (cond) { x=100; rand_r(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__rand_r__leakignore() {
  char *p = malloc(10); *p=0;
  rand_r(p);
  // cppcheck-suppress memleak
}

void test__rand_r__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  rand_r(p);
}

void test__strcasecmp__noreturn() {
  int x = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  strcasecmp(p, arg2);
  // cppcheck-suppress memleak
}

void test__strcasecmp__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  strcasecmp(p, arg2);
}

void test__strcasecmp__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  strcasecmp(x, arg2);
}

void test__strcasecmp__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  strcasecmp(arg1, p);
}

void test__strcasecmp__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  strcasecmp(arg1, x);
}

void test__strncasecmp__noreturn() {
  int x = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  strncasecmp(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__strncasecmp__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  strncasecmp(p, arg2, arg3);
}

void test__strncasecmp__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  strncasecmp(x, arg2, arg3);
}

void test__strncasecmp__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  strncasecmp(arg1, p, 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 = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; write(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__write__leakignore() {
  char *p = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; munmap(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__munmap__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  munmap(p, arg2);
}

void test__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 = 1;
  if (cond) { x=100; openlog(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__openlog__leakignore() {
  char *p = malloc(10); *p=0;
  openlog(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__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 = 1;
  if (cond) { x=100; fcntl(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__fcntl__leakignore() {
  char *p = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; ioctl(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ioctl__leakignore() {
  char *p = malloc(10); *p=0;
  ioctl(p, arg2);
  // cppcheck-suppress memleak
}

void test__ioctl__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ioctl(x, arg2);
}

void test__ioctl__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ioctl(arg1, x);
}

void test__syslog__noreturn() {
  int x = 1;
  if (cond) { x=100; syslog(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__syslog__leakignore() {
  char *p = malloc(10); *p=0;
  syslog(p, arg2);
  // cppcheck-suppress memleak
}

void test__syslog__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  syslog(x, arg2);
}

void test__vsyslog__noreturn() {
  int x = 1;
  if (cond) { x=100; vsyslog(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__vsyslog__leakignore() {
  char *p = malloc(10); *p=0;
  vsyslog(p, arg2);
  // cppcheck-suppress memleak
}

void test__vsyslog__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  vsyslog(x, arg2);
}

void test__getgid__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getgid(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getgid__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getgid();
}

void test__getegid__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getegid(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getegid__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getegid();
}

void test__getuid__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getuid(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getuid__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getuid();
}

void test__getuid__leakignore() {
  char *p = malloc(10); *p=0;
  result = getuid();
  // cppcheck-suppress memleak
}

void test__getsid__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getsid(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getsid__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getsid(arg1);
}

void test__getsid__leakignore() {
  char *p = malloc(10); *p=0;
  result = getsid(p);
  // cppcheck-suppress memleak
}

void test__getsid__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = getsid(x);
}

void test__geteuid__noreturn() {
  int x = 1;
  if (cond) { x=100; result = geteuid(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__geteuid__useretval() {
  // cppcheck-suppress ignoredReturnValue
  geteuid();
}

void test__geteuid__leakignore() {
  char *p = malloc(10); *p=0;
  result = geteuid();
  // cppcheck-suppress memleak
}

void test__getppid__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getppid(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getppid__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getppid();
}

void test__getppid__leakignore() {
  char *p = malloc(10); *p=0;
  result = getppid();
  // cppcheck-suppress memleak
}

void test__getpid__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getpid(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getpid__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getpid();
}

void test__getpid__leakignore() {
  char *p = malloc(10); *p=0;
  result = getpid();
  // cppcheck-suppress memleak
}

void test__getpgrp__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getpgrp(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getpgrp__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getpgrp();
}

void test__getpgrp__leakignore() {
  char *p = malloc(10); *p=0;
  result = getpgrp();
  // cppcheck-suppress memleak
}

void test__getpgid__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getpgid(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getpgid__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getpgid(arg1);
}

void test__getpgid__leakignore() {
  char *p = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; result = setuid(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__setuid__useretval() {
  // cppcheck-suppress ignoredReturnValue
  setuid(arg1);
}

void test__setuid__leakignore() {
  char *p = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; result = seteuid(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__seteuid__useretval() {
  // cppcheck-suppress ignoredReturnValue
  seteuid(arg1);
}

void test__seteuid__leakignore() {
  char *p = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; result = setgid(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__setgid__useretval() {
  // cppcheck-suppress ignoredReturnValue
  setgid(arg1);
}

void test__setgid__leakignore() {
  char *p = malloc(10); *p=0;
  result = setgid(p);
  // cppcheck-suppress memleak
}

void test__setgid__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = setgid(x);
}

void test__setegid__noreturn() {
  int x = 1;
  if (cond) { x=100; result = setegid(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__setegid__useretval() {
  // cppcheck-suppress ignoredReturnValue
  setegid(arg1);
}

void test__setegid__leakignore() {
  char *p = malloc(10); *p=0;
  result = setegid(p);
  // cppcheck-suppress memleak
}

void test__setegid__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = setegid(x);
}

void test__setpgid__noreturn() {
  int x = 1;
  if (cond) { x=100; setpgid(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__setpgid__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setpgid(x, arg2);
}

void test__setpgid__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setpgid(arg1, x);
}

void test__pipe__noreturn() {
  int x = 1;
  if (cond) { x=100; pipe(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__setpgrp__noreturn() {
  int x = 1;
  if (cond) { x=100; setpgrp(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__setregid__noreturn() {
  int x = 1;
  if (cond) { x=100; setregid(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__setregid__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setregid(x, arg2);
}

void test__setregid__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setregid(arg1, x);
}

void test__setreuid__noreturn() {
  int x = 1;
  if (cond) { x=100; setreuid(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__setreuid__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setreuid(x, arg2);
}

void test__setreuid__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setreuid(arg1, x);
}

void test__setfsuid__noreturn() {
  int x = 1;
  if (cond) { x=100; setfsuid(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__setfsuid__leakignore() {
  char *p = malloc(10); *p=0;
  setfsuid(p);
  // cppcheck-suppress memleak
}

void test__setfsuid__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setfsuid(x);
}

void test__setfsgid__noreturn() {
  int x = 1;
  if (cond) { x=100; setfsgid(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__setfsgid__leakignore() {
  char *p = malloc(10); *p=0;
  setfsgid(p);
  // cppcheck-suppress memleak
}

void test__setfsgid__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setfsgid(x);
}

void test__setsid__noreturn() {
  int x = 1;
  if (cond) { x=100; setsid(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getwd__noreturn() {
  int x = 1;
  if (cond) { x=100; getwd(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getwd__leakignore() {
  char *p = malloc(10); *p=0;
  getwd(p);
  // cppcheck-suppress memleak
}

void test__getwd__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getwd(p);
}

void test__htonl__noreturn() {
  int x = 1;
  if (cond) { x=100; htonl(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__htonl__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  htonl(x);
}

void test__htons__noreturn() {
  int x = 1;
  if (cond) { x=100; htons(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__htons__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  htons(x);
}

void test__ntohl__noreturn() {
  int x = 1;
  if (cond) { x=100; ntohl(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ntohl__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ntohl(x);
}

void test__ntohs__noreturn() {
  int x = 1;
  if (cond) { x=100; ntohs(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ntohs__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ntohs(x);
}

void test__mq_close__noreturn() {
  int x = 1;
  if (cond) { x=100; mq_close(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__mq_close__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  mq_close(x);
}

void test__mq_getattr__noreturn() {
  int x = 1;
  if (cond) { x=100; mq_getattr(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__mq_getattr__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  mq_getattr(x, arg2);
}

void test__mq_notify__noreturn() {
  int x = 1;
  if (cond) { x=100; mq_notify(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__mq_notify__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  mq_notify(p, arg2);
}

void test__mq_notify__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  mq_notify(x, arg2);
}

void test__mq_open__noreturn() {
  int x = 1;
  if (cond) { x=100; mq_open(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__mq_receive__noreturn() {
  int x = 1;
  if (cond) { x=100; mq_receive(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__mq_receive__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  mq_receive(x, arg2, arg3, arg4);
}

void test__mq_send__noreturn() {
  int x = 1;
  if (cond) { x=100; mq_send(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__mq_send__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  mq_send(x, arg2, arg3, arg4);
}

void test__mq_setattr__noreturn() {
  int x = 1;
  if (cond) { x=100; mq_setattr(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__mq_setattr__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  mq_setattr(x, arg2, arg3);
}

void test__mq_timedreceive__noreturn() {
  int x = 1;
  if (cond) { x=100; mq_timedreceive(arg1, arg2, arg3, arg4, arg5); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__mq_timedreceive__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  mq_timedreceive(x, arg2, arg3, arg4, arg5);
}

void test__mq_timedsend__noreturn() {
  int x = 1;
  if (cond) { x=100; mq_timedsend(arg1, arg2, arg3, arg4, arg5); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__mq_timedsend__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  mq_timedsend(x, arg2, arg3, arg4, arg5);
}

void test__mq_unlink__noreturn() {
  int x = 1;
  if (cond) { x=100; mq_unlink(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__mq_unlink__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  mq_unlink(p);
}

void test__mq_unlink__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  mq_unlink(x);
}

void test__dbm_clearerr__noreturn() {
  int x = 1;
  if (cond) { x=100; dbm_clearerr(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__dbm_clearerr__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  dbm_clearerr(p);
}

void test__dbm_clearerr__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  dbm_clearerr(x);
}

void test__dbm_close__noreturn() {
  int x = 1;
  if (cond) { x=100; dbm_close(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__dbm_close__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  dbm_close(p);
}

void test__dbm_close__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  dbm_close(x);
}

void test__dbm_delete__noreturn() {
  int x = 1;
  if (cond) { x=100; dbm_delete(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__dbm_delete__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  dbm_delete(p, 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 = 1;
  if (cond) { x=100; 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() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = dbm_error(p);
}

void test__dbm_error__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = dbm_error(x);
}

void test__dbm_fetch__noreturn() {
  int x = 1;
  if (cond) { x=100; result = dbm_fetch(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__dbm_fetch__useretval() {
  // cppcheck-suppress ignoredReturnValue
  dbm_fetch(arg1, arg2);
}

void test__dbm_fetch__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = dbm_fetch(p, 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 = 1;
  if (cond) { x=100; 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() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = dbm_firstkey(p);
}

void test__dbm_firstkey__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = dbm_firstkey(x);
}

void test__dbm_nextkey__noreturn() {
  int x = 1;
  if (cond) { x=100; result = dbm_nextkey(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__dbm_nextkey__useretval() {
  // cppcheck-suppress ignoredReturnValue
  dbm_nextkey(arg1);
}

void test__dbm_nextkey__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = dbm_nextkey(p);
}

void test__dbm_nextkey__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = dbm_nextkey(x);
}

void test__dbm_open__noreturn() {
  int x = 1;
  if (cond) { x=100; dbm_open(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__dbm_open__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  dbm_open(p, 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 = 1;
  if (cond) { x=100; dbm_store(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__dbm_store__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  dbm_store(p, arg2, arg3, arg4);
}

void test__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 = 1;
  if (cond) { x=100; freeaddrinfo(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__freeaddrinfo__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  freeaddrinfo(p);
}

void test__freeaddrinfo__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  freeaddrinfo(x);
}

void test__getaddrinfo__noreturn() {
  int x = 1;
  if (cond) { x=100; getaddrinfo(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getaddrinfo__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  getaddrinfo(x, arg2, arg3, arg4);
}

void test__getaddrinfo__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  getaddrinfo(arg1, x, arg3, arg4);
}

void test__getaddrinfo__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  getaddrinfo(arg1, arg2, x, arg4);
}

void test__getaddrinfo__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  getaddrinfo(arg1, arg2, arg3, x);
}

void test__endhostent__noreturn() {
  int x = 1;
  if (cond) { x=100; endhostent(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sethostent__noreturn() {
  int x = 1;
  if (cond) { x=100; sethostent(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sethostent__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sethostent(x);
}

void test__uname__noreturn() {
  int x = 1;
  if (cond) { x=100; uname(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__uname__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  uname(p);
}

void test__endpwent__noreturn() {
  int x = 1;
  if (cond) { x=100; endpwent(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getpwent__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getpwent(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getpwent__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getpwent();
}

void test__getpwnam__noreturn() {
  int x = 1;
  if (cond) { x=100; 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 = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  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() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  strtok_r(arg1, p, arg3);
}

void test__strtok_r__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  strtok_r(arg1, x, arg3);
}

void test__strtok_r__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  strtok_r(arg1, arg2, p);
}

void test__getpwnam_r__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getpwnam_r(arg1, arg2, arg3, arg4, arg5); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__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 = 1;
  if (cond) { x=100; 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 = 1;
  if (cond) { x=100; 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 = 1;
  if (cond) { x=100; setpwent(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__catclose__noreturn() {
  int x = 1;
  if (cond) { x=100; catclose(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__catclose__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  catclose(x);
}

void test__catgets__noreturn() {
  int x = 1;
  if (cond) { x=100; 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 = 1;
  if (cond) { x=100; catopen(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__catopen__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  catopen(p, arg2);
}

void test__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 = 1;
  if (cond) { x=100; 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 = 1;
  if (cond) { x=100; regcomp(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__regcomp__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  regcomp(p, 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 = 1;
  if (cond) { x=100; 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 = 1;
  if (cond) { x=100; regexec(arg1, arg2, arg3, arg4, arg5); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__regexec__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  regexec(p, 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() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  regexec(arg1, p, 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 = 1;
  if (cond) { x=100; regfree(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__regfree__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  regfree(p);
}

void test__regfree__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  regfree(x);
}

void test__sched_get_priority_max__noreturn() {
  int x = 1;
  if (cond) { x=100; sched_get_priority_max(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__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 = 1;
  if (cond) { x=100; 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 = 1;
  if (cond) { x=100; 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() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  sched_getparam(arg1, p);
}

void test__sched_getscheduler__noreturn() {
  int x = 1;
  if (cond) { x=100; sched_getscheduler(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sched_getscheduler__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sched_getscheduler(x);
}

void test__sched_rr_get_interval__noreturn() {
  int x = 1;
  if (cond) { x=100; sched_rr_get_interval(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sched_rr_get_interval__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sched_rr_get_interval(x, arg2);
}

void test__sched_rr_get_interval__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  sched_rr_get_interval(arg1, p);
}

void test__sched_setparam__noreturn() {
  int x = 1;
  if (cond) { x=100; sched_setparam(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sched_setparam__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sched_setparam(x, arg2);
}

void test__sched_setparam__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sched_setparam(arg1, x);
}

void test__sched_setscheduler__noreturn() {
  int x = 1;
  if (cond) { x=100; 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 = 1;
  if (cond) { x=100; sched_yield(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ecvt__noreturn() {
  int x = 1;
  if (cond) { x=100; ecvt(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ecvt__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ecvt(x, arg2, arg3, arg4);
}

void test__ecvt__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ecvt(arg1, x, arg3, arg4);
}

void test__ecvt__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  ecvt(arg1, arg2, p, arg4);
}

void test__ecvt__arg4__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  ecvt(arg1, arg2, arg3, p);
}

void test__fcvt__noreturn() {
  int x = 1;
  if (cond) { x=100; 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() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  fcvt(arg1, arg2, p, arg4);
}

void test__fcvt__arg4__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  fcvt(arg1, arg2, arg3, p);
}

void test__gcvt__noreturn() {
  int x = 1;
  if (cond) { x=100; 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() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  gcvt(arg1, arg2, p);
}

void test__lseek__noreturn() {
  int x = 1;
  if (cond) { x=100; lseek(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__lseek__leakignore() {
  char *p = malloc(10); *p=0;
  lseek(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__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 = 1;
  if (cond) { x=100; nanosleep(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__nanosleep__leakignore() {
  char *p = malloc(10); *p=0;
  nanosleep(p, arg2);
  // cppcheck-suppress memleak
}

void test__nanosleep__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  nanosleep(p, arg2);
}

void test__setkey__noreturn() {
  int x = 1;
  if (cond) { x=100; setkey(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__setkey__leakignore() {
  char *p = malloc(10); *p=0;
  setkey(p);
  // cppcheck-suppress memleak
}

void test__setkey__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  setkey(p);
}

void test__setkey__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  setkey(x);
}

void test__getpass__noreturn() {
  int x = 1;
  if (cond) { x=100; getpass(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getpass__leakignore() {
  char *p = malloc(10); *p=0;
  getpass(p);
  // cppcheck-suppress memleak
}

void test__getpass__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getpass(p);
}

void test__drand48__noreturn() {
  int x = 1;
  if (cond) { x=100; result = drand48(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__drand48__useretval() {
  // cppcheck-suppress ignoredReturnValue
  drand48();
}

void test__putenv__noreturn() {
  int x = 1;
  if (cond) { x=100; putenv(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__putenv__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  putenv(p);
}

void test__putenv__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  putenv(x);
}

void test__setenv__noreturn() {
  int x = 1;
  if (cond) { x=100; setenv(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__setenv__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  setenv(p, arg2, arg3);
}

void test__setenv__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  setenv(x, arg2, arg3);
}

void test__setenv__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  setenv(arg1, p, 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 = 1;
  if (cond) { x=100; unsetenv(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__unsetenv__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  unsetenv(p);
}

void test__unsetenv__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  unsetenv(x);
}

void test__localtime__noreturn() {
  int x = 1;
  if (cond) { x=100; localtime(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__localtime__leakignore() {
  char *p = malloc(10); *p=0;
  localtime(p);
  // cppcheck-suppress memleak
}

void test__localtime__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  localtime(p);
}

void test__localtime__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  localtime(x);
}

void test__std__localtime__noreturn() {
  int x = 1;
  if (cond) { x=100; std::localtime(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__std__localtime__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  std::localtime(p);
}

void test__std__localtime__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  std::localtime(x);
}

void test__localtime_r__noreturn() {
  int x = 1;
  if (cond) { x=100; localtime_r(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__localtime_r__leakignore() {
  char *p = malloc(10); *p=0;
  localtime_r(p, arg2);
  // cppcheck-suppress memleak
}

void test__localtime_r__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  localtime_r(p, arg2);
}

void test__localtime_r__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  localtime_r(x, arg2);
}

void test__localtime_r__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  localtime_r(arg1, p);
}

void test__readdir__noreturn() {
  int x = 1;
  if (cond) { x=100; readdir(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__readdir__leakignore() {
  char *p = malloc(10); *p=0;
  readdir(p);
  // cppcheck-suppress memleak
}

void test__readdir__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  readdir(p);
}

void test__readdir__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  readdir(x);
}

void test__readdir_r__noreturn() {
  int x = 1;
  if (cond) { x=100; readdir_r(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__readdir_r__leakignore() {
  char *p = malloc(10); *p=0;
  readdir_r(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__readdir_r__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  readdir_r(p, 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() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  readdir_r(arg1, p, arg3);
}

void test__readdir_r__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  readdir_r(arg1, arg2, p);
}

void test__readlink__noreturn() {
  int x = 1;
  if (cond) { x=100; readlink(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__readlink__leakignore() {
  char *p = malloc(10); *p=0;
  readlink(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__readlink__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  readlink(p, arg2, arg3);
}

void test__readlink__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  readlink(x, arg2, arg3);
}

void test__readlink__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  readlink(arg1, p, arg3);
}

void test__readlink__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  readlink(arg1, arg2, x);
}

void test__readlinkat__noreturn() {
  int x = 1;
  if (cond) { x=100; readlinkat(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__readlinkat__leakignore() {
  char *p = malloc(10); *p=0;
  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() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  readlinkat(arg1, p, arg3, arg4);
}

void test__readlinkat__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  readlinkat(arg1, x, arg3, arg4);
}

void test__readlinkat__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  readlinkat(arg1, arg2, p, arg4);
}

void test__readlinkat__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  readlinkat(arg1, arg2, arg3, x);
}

void test__asctime_r__noreturn() {
  int x = 1;
  if (cond) { x=100; asctime_r(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__asctime_r__leakignore() {
  char *p = malloc(10); *p=0;
  asctime_r(p, arg2);
  // cppcheck-suppress memleak
}

void test__asctime_r__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  asctime_r(p, arg2);
}

void test__asctime_r__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  asctime_r(x, arg2);
}

void test__asctime_r__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  asctime_r(arg1, p);
}

void test__ctime_r__noreturn() {
  int x = 1;
  if (cond) { x=100; ctime_r(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ctime_r__leakignore() {
  char *p = malloc(10); *p=0;
  ctime_r(p, arg2);
  // cppcheck-suppress memleak
}

void test__ctime_r__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  ctime_r(p, arg2);
}

void test__ctime_r__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  ctime_r(x, arg2);
}

void test__ctime_r__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  ctime_r(arg1, p);
}

void test__gmtime_r__noreturn() {
  int x = 1;
  if (cond) { x=100; gmtime_r(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__gmtime_r__leakignore() {
  char *p = malloc(10); *p=0;
  gmtime_r(p, arg2);
  // cppcheck-suppress memleak
}

void test__gmtime_r__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  gmtime_r(p, arg2);
}

void test__gmtime_r__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  gmtime_r(x, arg2);
}

void test__gmtime_r__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  gmtime_r(arg1, p);
}

void test__gmtime__noreturn() {
  int x = 1;
  if (cond) { x=100; result = gmtime(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__gmtime__useretval() {
  // cppcheck-suppress ignoredReturnValue
  gmtime(arg1);
}

void test__gmtime__leakignore() {
  char *p = malloc(10); *p=0;
  result = gmtime(p);
  // cppcheck-suppress memleak
}

void test__gmtime__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = gmtime(p);
}

void test__gmtime__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = gmtime(x);
}

void test__clock_settime__noreturn() {
  int x = 1;
  if (cond) { x=100; clock_settime(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__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 = 1;
  if (cond) { x=100; 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 = 1;
  if (cond) { x=100; kill(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__kill__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  kill(x, arg2);
}

void test__kill__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  kill(arg1, x);
}

void test__clock_gettime__noreturn() {
  int x = 1;
  if (cond) { x=100; clock_gettime(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__clock_gettime__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  clock_gettime(x, arg2);
}

void test__clock_gettime__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  clock_gettime(arg1, p);
}

void test__clock_getres__noreturn() {
  int x = 1;
  if (cond) { x=100; 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 = 1;
  if (cond) { x=100; tmpnam(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__tmpnam__leakignore() {
  char *p = malloc(10); *p=0;
  tmpnam(p);
  // cppcheck-suppress memleak
}

void test__tmpnam__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  tmpnam(x);
}

void test__tmpnam_r__noreturn() {
  int x = 1;
  if (cond) { x=100; tmpnam_r(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__tmpnam_r__leakignore() {
  char *p = malloc(10); *p=0;
  tmpnam_r(p);
  // cppcheck-suppress memleak
}

void test__tmpnam_r__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  tmpnam_r(x);
}

void test__makecontext__noreturn() {
  int x = 1;
  if (cond) { x=100; makecontext(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__makecontext__leakignore() {
  char *p = malloc(10); *p=0;
  makecontext(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__makecontext__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  makecontext(p, arg2, arg3);
}

void test__makecontext__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  makecontext(arg1, p, 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 = 1;
  if (cond) { x=100; swapcontext(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__swapcontext__leakignore() {
  char *p = malloc(10); *p=0;
  swapcontext(p, arg2);
  // cppcheck-suppress memleak
}

void test__swapcontext__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  swapcontext(p, arg2);
}

void test__swapcontext__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  swapcontext(arg1, p);
}

void test__getcontext__noreturn() {
  int x = 1;
  if (cond) { x=100; getcontext(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getcontext__leakignore() {
  char *p = malloc(10); *p=0;
  getcontext(p);
  // cppcheck-suppress memleak
}

void test__getcontext__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getcontext(p);
}

void test__ualarm__noreturn() {
  int x = 1;
  if (cond) { x=100; ualarm(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ualarm__leakignore() {
  char *p = malloc(10); *p=0;
  ualarm(p, arg2);
  // cppcheck-suppress memleak
}

void test__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 = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; bcopy(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__bcopy__leakignore() {
  char *p = malloc(10); *p=0;
  bcopy(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__bcopy__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  bcopy(p, arg2, arg3);
}

void test__bcopy__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  bcopy(x, arg2, arg3);
}

void test__bcopy__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  bcopy(arg1, p, arg3);
}

void test__bcopy__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  bcopy(arg1, arg2, x);
}

void test__bcmp__noreturn() {
  int x = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  result = bcmp(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__bcmp__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = bcmp(p, arg2, arg3);
}

void test__bcmp__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = bcmp(x, arg2, arg3);
}

void test__bcmp__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = bcmp(arg1, p, 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 = 1;
  if (cond) { x=100; bzero(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__bzero__leakignore() {
  char *p = malloc(10); *p=0;
  bzero(p, arg2);
  // cppcheck-suppress memleak
}

void test__bzero__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  bzero(p, arg2);
}

void test__bzero__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  bzero(arg1, x);
}

void test__ftime__noreturn() {
  int x = 1;
  if (cond) { x=100; ftime(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ftime__leakignore() {
  char *p = malloc(10); *p=0;
  ftime(p);
  // cppcheck-suppress memleak
}

void test__ftime__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ftime(x);
}

void test__wcswcs__noreturn() {
  int x = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  result = wcswcs(p, arg2);
  // cppcheck-suppress memleak
}

void test__wcswcs__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = wcswcs(p, arg2);
}

void test__wcswcs__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = wcswcs(x, arg2);
}

void test__wcswcs__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = wcswcs(arg1, p);
}

void test__wcswcs__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = wcswcs(arg1, x);
}

void test__stpcpy__noreturn() {
  int x = 1;
  if (cond) { x=100; stpcpy(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__stpcpy__leakignore() {
  char *p = malloc(10); *p=0;
  stpcpy(p, arg2);
  // cppcheck-suppress memleak
}

void test__stpcpy__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  stpcpy(p, arg2);
}

void test__stpcpy__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  stpcpy(arg1, p);
}

void test__stpcpy__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  stpcpy(arg1, x);
}

void test__index__noreturn() {
  int x = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  result = index(p, arg2);
  // cppcheck-suppress memleak
}

void test__index__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = index(p, 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 = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  result = rindex(p, arg2);
  // cppcheck-suppress memleak
}

void test__rindex__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = rindex(p, 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 = 1;
  if (cond) { x=100; bsd_signal(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__bsd_signal__leakignore() {
  char *p = malloc(10); *p=0;
  bsd_signal(p, arg2);
  // cppcheck-suppress memleak
}

void test__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 = 1;
  if (cond) { x=100; fork(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__fork__leakignore() {
  char *p = malloc(10); *p=0;
  fork();
  // cppcheck-suppress memleak
}

void test__vfork__noreturn() {
  int x = 1;
  if (cond) { x=100; vfork(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__vfork__leakignore() {
  char *p = malloc(10); *p=0;
  vfork();
  // cppcheck-suppress memleak
}

void test__pthread_atfork__noreturn() {
  int x = 1;
  if (cond) { x=100; pthread_atfork(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pthread_atfork__leakignore() {
  char *p = malloc(10); *p=0;
  pthread_atfork(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__pthread_create__noreturn() {
  int x = 1;
  if (cond) { x=100; pthread_create(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pthread_create__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  pthread_create(p, arg2, arg3, arg4);
}

void test__pthread_create__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  pthread_create(arg1, arg2, p, arg4);
}

void test__pthread_detach__noreturn() {
  int x = 1;
  if (cond) { x=100; pthread_detach(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pthread_detach__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  pthread_detach(x);
}

void test__pthread_equal__noreturn() {
  int x = 1;
  if (cond) { x=100; result = pthread_equal(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pthread_equal__useretval() {
  // cppcheck-suppress ignoredReturnValue
  pthread_equal(arg1, arg2);
}

void test__pthread_equal__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = pthread_equal(x, arg2);
}

void test__pthread_equal__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = pthread_equal(arg1, x);
}

void test__pthread_exit__noreturn() {
  int x = 1;
  if (cond) { x=100; pthread_exit(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pthread_join__noreturn() {
  int x = 1;
  if (cond) { x=100; pthread_join(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pthread_join__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  pthread_join(x, arg2);
}

void test__pthread_kill__noreturn() {
  int x = 1;
  if (cond) { x=100; pthread_kill(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pthread_kill__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  pthread_kill(x, arg2);
}

void test__pthread_kill__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  pthread_kill(arg1, x);
}

void test__pthread_self__noreturn() {
  int x = 1;
  if (cond) { x=100; result = pthread_self(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pthread_self__useretval() {
  // cppcheck-suppress ignoredReturnValue
  pthread_self();
}

void test__pthread_attr_destroy__noreturn() {
  int x = 1;
  if (cond) { x=100; pthread_attr_destroy(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pthread_attr_destroy__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  pthread_attr_destroy(p);
}

void test__pthread_attr_init__noreturn() {
  int x = 1;
  if (cond) { x=100; pthread_attr_init(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pthread_attr_init__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  pthread_attr_init(p);
}

void test__pthread_attr_setstackaddr__noreturn() {
  int x = 1;
  if (cond) { x=100; pthread_attr_setstackaddr(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pthread_attr_setstackaddr__leakignore() {
  char *p = malloc(10); *p=0;
  pthread_attr_setstackaddr(p, arg2);
  // cppcheck-suppress memleak
}

void test__pthread_attr_setstackaddr__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  pthread_attr_setstackaddr(p, 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() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  pthread_attr_setstackaddr(arg1, p);
}

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 = 1;
  if (cond) { x=100; pthread_attr_getstackaddr(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pthread_attr_getstackaddr__leakignore() {
  char *p = malloc(10); *p=0;
  pthread_attr_getstackaddr(p, arg2);
  // cppcheck-suppress memleak
}

void test__pthread_attr_getstackaddr__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  pthread_attr_getstackaddr(p, 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() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  pthread_attr_getstackaddr(arg1, p);
}

void test__tempnam__noreturn() {
  int x = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  result = crypt(p, arg2);
  // cppcheck-suppress memleak
}

void test__crypt__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = crypt(p, arg2);
}

void test__crypt__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = crypt(x, arg2);
}

void test__crypt__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = crypt(arg1, p);
}

void test__crypt__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = crypt(arg1, x);
}

void test__ttyname__noreturn() {
  int x = 1;
  if (cond) { x=100; result = ttyname(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ttyname__useretval() {
  // cppcheck-suppress ignoredReturnValue
  ttyname(arg1);
}

void test__ttyname__leakignore() {
  char *p = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; result = getspnam(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getspnam__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getspnam(arg1);
}

void test__getspnam__leakignore() {
  char *p = malloc(10); *p=0;
  result = getspnam(p);
  // cppcheck-suppress memleak
}

void test__getspnam__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = getspnam(p);
}

void test__getspnam__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = getspnam(x);
}

void test__getspent__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getspent(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getspent__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getspent();
}

void test__getspent__leakignore() {
  char *p = malloc(10); *p=0;
  result = getspent();
  // cppcheck-suppress memleak
}

void test__fgetspent__noreturn() {
  int x = 1;
  if (cond) { x=100; result = fgetspent(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__fgetspent__useretval() {
  // cppcheck-suppress ignoredReturnValue
  fgetspent(arg1);
}

void test__fgetspent__leakignore() {
  char *p = malloc(10); *p=0;
  result = fgetspent(p);
  // cppcheck-suppress memleak
}

void test__fgetspent__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = fgetspent(p);
}

void test__fgetspent__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = fgetspent(x);
}

void test__sgetspent__noreturn() {
  int x = 1;
  if (cond) { x=100; result = sgetspent(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sgetspent__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sgetspent(arg1);
}

void test__sgetspent__leakignore() {
  char *p = malloc(10); *p=0;
  result = sgetspent(p);
  // cppcheck-suppress memleak
}

void test__sgetspent__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = sgetspent(p);
}

void test__sgetspent__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = sgetspent(x);
}

void test__fgetpwent__noreturn() {
  int x = 1;
  if (cond) { x=100; result = fgetpwent(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__fgetpwent__useretval() {
  // cppcheck-suppress ignoredReturnValue
  fgetpwent(arg1);
}

void test__fgetpwent__leakignore() {
  char *p = malloc(10); *p=0;
  result = fgetpwent(p);
  // cppcheck-suppress memleak
}

void test__fgetpwent__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = fgetpwent(p);
}

void test__fgetpwent__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = fgetpwent(x);
}

void test__getgrent__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getgrent(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getgrent__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getgrent();
}

void test__getgrent__leakignore() {
  char *p = malloc(10); *p=0;
  result = getgrent();
  // cppcheck-suppress memleak
}

void test__getgrent_r__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getgrent_r(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getgrent_r__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getgrent_r(arg1, arg2, arg3, arg4);
}

void test__getgrent_r__leakignore() {
  char *p = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; result = fgetgrent(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__fgetgrent__useretval() {
  // cppcheck-suppress ignoredReturnValue
  fgetgrent(arg1);
}

void test__fgetgrent__leakignore() {
  char *p = malloc(10); *p=0;
  result = fgetgrent(p);
  // cppcheck-suppress memleak
}

void test__fgetgrent__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = fgetgrent(p);
}

void test__fgetgrent__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = fgetgrent(x);
}

void test__getnetgrent__noreturn() {
  int x = 1;
  if (cond) { x=100; getnetgrent(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getnetgrent__leakignore() {
  char *p = malloc(10); *p=0;
  getnetgrent(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__getnetgrent__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getnetgrent(p, arg2, arg3);
}

void test__getnetgrent__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getnetgrent(arg1, p, arg3);
}

void test__getnetgrent__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getnetgrent(arg1, arg2, p);
}

void test__getgrnam__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getgrnam(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getgrnam__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getgrnam(arg1);
}

void test__getgrnam__leakignore() {
  char *p = malloc(10); *p=0;
  result = getgrnam(p);
  // cppcheck-suppress memleak
}

void test__getgrnam__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = getgrnam(p);
}

void test__getgrnam__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = getgrnam(x);
}

void test__getgrgid__noreturn() {
  int x = 1;
  if (cond) { x=100; result = getgrgid(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getgrgid__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getgrgid(arg1);
}

void test__getgrgid__leakignore() {
  char *p = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; result = getlogin(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getlogin__useretval() {
  // cppcheck-suppress ignoredReturnValue
  getlogin();
}

void test__getlogin__leakignore() {
  char *p = malloc(10); *p=0;
  result = getlogin();
  // cppcheck-suppress memleak
}

void test__ctermid__noreturn() {
  int x = 1;
  if (cond) { x=100; ctermid(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ctermid__leakignore() {
  char *p = malloc(10); *p=0;
  ctermid(p);
  // cppcheck-suppress memleak
}

void test__realpath__noreturn() {
  int x = 1;
  if (cond) { x=100; realpath(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__realpath__leakignore() {
  char *p = malloc(10); *p=0;
  realpath(p, arg2);
  // cppcheck-suppress memleak
}

void test__realpath__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  realpath(p, arg2);
}

void test__realpath__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  realpath(x, arg2);
}

void test__remove__noreturn() {
  int x = 1;
  if (cond) { x=100; remove(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__remove__leakignore() {
  char *p = malloc(10); *p=0;
  remove(p);
  // cppcheck-suppress memleak
}

void test__remove__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  remove(p);
}

void test__remove__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  remove(x);
}

void test__fileno__noreturn() {
  int x = 1;
  if (cond) { x=100; result = fileno(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__fileno__useretval() {
  // cppcheck-suppress ignoredReturnValue
  fileno(arg1);
}

void test__fileno__leakignore() {
  char *p = malloc(10); *p=0;
  result = fileno(p);
  // cppcheck-suppress memleak
}

void test__fileno__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = fileno(p);
}

void test__fileno__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = fileno(x);
}

void test__fseeko__noreturn() {
  int x = 1;
  if (cond) { x=100; fseeko(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__fseeko__leakignore() {
  char *p = malloc(10); *p=0;
  fseeko(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__fseeko__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  fseeko(p, 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 = 1;
  if (cond) { x=100; result = ftello(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ftello__useretval() {
  // cppcheck-suppress ignoredReturnValue
  ftello(arg1);
}

void test__ftello__leakignore() {
  char *p = malloc(10); *p=0;
  result = ftello(p);
  // cppcheck-suppress memleak
}

void test__ftello__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = ftello(p);
}

void test__ftello__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = ftello(x);
}

void test__execv__noreturn() {
  int x = 1;
  if (cond) { x=100; execv(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__execv__leakignore() {
  char *p = malloc(10); *p=0;
  execv(p, arg2);
  // cppcheck-suppress memleak
}

void test__execv__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  execv(p, 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 = 1;
  if (cond) { x=100; execvp(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__execvp__leakignore() {
  char *p = malloc(10); *p=0;
  execvp(p, arg2);
  // cppcheck-suppress memleak
}

void test__execvp__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  execvp(p, 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 = 1;
  if (cond) { x=100; wait(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wait__leakignore() {
  char *p = malloc(10); *p=0;
  wait(p);
  // cppcheck-suppress memleak
}

void test__waitpid__noreturn() {
  int x = 1;
  if (cond) { x=100; waitpid(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__waitpid__leakignore() {
  char *p = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  result = strnlen(p, arg2);
  // cppcheck-suppress memleak
}

void test__strnlen__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = strnlen(p, 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 = 1;
  if (cond) { x=100; 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 = malloc(10); *p=0;
  result = wcsnlen(p, arg2);
  // cppcheck-suppress memleak
}

void test__wcsnlen__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = wcsnlen(p, 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 = 1;
  if (cond) { x=100; result = ffs(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ffs__useretval() {
  // cppcheck-suppress ignoredReturnValue
  ffs(arg1);
}

void test__ffs__leakignore() {
  char *p = malloc(10); *p=0;
  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 = 1;
  if (cond) { x=100; shmctl(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__shmctl__leakignore() {
  char *p = malloc(10); *p=0;
  shmctl(p, arg2);
  // cppcheck-suppress memleak
}

void test__shmctl__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  shmctl(x, arg2);
}

void test__shmctl__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  shmctl(arg1, x);
}

void test__shmget__noreturn() {
  int x = 1;
  if (cond) { x=100; shmget(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__shmget__leakignore() {
  char *p = malloc(10); *p=0;
  shmget(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__shmget__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  shmget(x, arg2, arg3);
}

void test__shmget__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  shmget(arg1, x, arg3);
}

void test__shmget__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  shmget(arg1, arg2, x);
}

void test__shmat__noreturn() {
  int x = 1;
  if (cond) { x=100; shmat(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__shmat__leakignore() {
  char *p = malloc(10); *p=0;
  shmat(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__shmat__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  shmat(x, arg2, arg3);
}

void test__shmat__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  shmat(arg1, arg2, x);
}

void test__shmdt__noreturn() {
  int x = 1;
  if (cond) { x=100; shmdt(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__shmdt__leakignore() {
  char *p = malloc(10); *p=0;
  shmdt(p);
  // cppcheck-suppress memleak
}

void test__getrlimit__noreturn() {
  int x = 1;
  if (cond) { x=100; getrlimit(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getrlimit__leakignore() {
  char *p = malloc(10); *p=0;
  getrlimit(p, arg2);
  // cppcheck-suppress memleak
}

void test__getrlimit__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  getrlimit(x, arg2);
}

void test__getrlimit__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getrlimit(arg1, p);
}

void test__setrlimit__noreturn() {
  int x = 1;
  if (cond) { x=100; setrlimit(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__setrlimit__leakignore() {
  char *p = malloc(10); *p=0;
  setrlimit(p, arg2);
  // cppcheck-suppress memleak
}

void test__setrlimit__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setrlimit(x, arg2);
}

void test__setrlimit__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  setrlimit(arg1, p);
}

void test__setrlimit__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  setrlimit(arg1, x);
}

void test__glob__noreturn() {
  int x = 1;
  if (cond) { x=100; glob(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__glob__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  glob(p, arg2, arg3, arg4);
}

void test__glob__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  glob(x, arg2, arg3, arg4);
}

void test__glob__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  glob(arg1, x, arg3, arg4);
}

void test__glob__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  glob(arg1, arg2, x, arg4);
}

void test__glob__arg4__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  glob(arg1, arg2, arg3, p);
}

void test__globfree__noreturn() {
  int x = 1;
  if (cond) { x=100; globfree(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__globfree__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  globfree(p);
}

void test__globfree__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  globfree(x);
}

void test__wcpncpy__noreturn() {
  int x = 1;
  if (cond) { x=100; wcpncpy(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wcpncpy__leakignore() {
  char *p = malloc(10); *p=0;
  wcpncpy(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__wcpncpy__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  wcpncpy(p, arg2, arg3);
}

void test__wcpncpy__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  wcpncpy(arg1, p, arg3);
}

void test__wcpncpy__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wcpncpy(arg1, x, arg3);
}

void test__wcpncpy__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  wcpncpy(arg1, arg2, !x);
}

void test__wcpncpy__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wcpncpy(arg1, arg2, x);
}

void test__stpncpy__noreturn() {
  int x = 1;
  if (cond) { x=100; stpncpy(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__stpncpy__leakignore() {
  char *p = malloc(10); *p=0;
  stpncpy(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__stpncpy__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  stpncpy(p, arg2, arg3);
}

void test__stpncpy__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  stpncpy(arg1, p, arg3);
}

void test__stpncpy__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  stpncpy(arg1, x, arg3);
}

void test__stpncpy__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  stpncpy(arg1, arg2, !x);
}

void test__stpncpy__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  stpncpy(arg1, arg2, x);
}

void test__memccpy__noreturn() {
  int x = 1;
  if (cond) { x=100; memccpy(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__memccpy__leakignore() {
  char *p = malloc(10); *p=0;
  memccpy(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__memccpy__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  memccpy(p, arg2, arg3, arg4);
}

void test__memccpy__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  memccpy(arg1, p, arg3, arg4);
}

void test__memccpy__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  memccpy(arg1, x, arg3, arg4);
}

void test__memccpy__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  memccpy(arg1, arg2, x, arg4);
}

void test__memccpy__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  memccpy(arg1, arg2, arg3, x);
}

void test__getopt__noreturn() {
  int x = 1;
  if (cond) { x=100; getopt(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getopt__leakignore() {
  char *p = malloc(10); *p=0;
  getopt(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__getopt__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  getopt(x, arg2, arg3);
}

void test__getopt__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getopt(arg1, p, arg3);
}

void test__getopt__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  getopt(arg1, x, arg3);
}

void test__getopt__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getopt(arg1, arg2, p);
}

void test__getopt__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  getopt(arg1, arg2, x);
}

void test__getitimer__noreturn() {
  int x = 1;
  if (cond) { x=100; getitimer(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getitimer__leakignore() {
  char *p = malloc(10); *p=0;
  getitimer(p, arg2);
  // cppcheck-suppress memleak
}

void test__getitimer__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  getitimer(x, arg2);
}

void test__getitimer__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getitimer(arg1, p);
}

void test__getitimer__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  getitimer(arg1, x);
}

void test__setitimer__noreturn() {
  int x = 1;
  if (cond) { x=100; setitimer(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__setitimer__leakignore() {
  char *p = malloc(10); *p=0;
  setitimer(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__setitimer__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setitimer(x, arg2, arg3);
}

void test__setitimer__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setitimer(arg1, x, arg3);
}

void test__setitimer__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setitimer(arg1, arg2, x);
}

void test__sigaction__noreturn() {
  int x = 1;
  if (cond) { x=100; sigaction(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sigaction__leakignore() {
  char *p = malloc(10); *p=0;
  sigaction(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__sigaction__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sigaction(x, arg2, arg3);
}

void test__sigaltstack__noreturn() {
  int x = 1;
  if (cond) { x=100; sigaltstack(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sigaltstack__leakignore() {
  char *p = malloc(10); *p=0;
  sigaltstack(p, arg2);
  // cppcheck-suppress memleak
}

void test__sigaltstack__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sigaltstack(x, arg2);
}

void test__siglongjmp__noreturn() {
  int x = 1;
  if (cond) { x=100; siglongjmp(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__siglongjmp__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  siglongjmp(x, arg2);
}

void test__siglongjmp__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  siglongjmp(arg1, x);
}

void test___longjmp__noreturn() {
  int x = 1;
  if (cond) { x=100; _longjmp(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___longjmp__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _longjmp(x, arg2);
}

void test___longjmp__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _longjmp(arg1, x);
}

void test__sigsetjmp__noreturn() {
  int x = 1;
  if (cond) { x=100; sigsetjmp(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sigsetjmp__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sigsetjmp(arg1, x);
}

void test___setjmp__noreturn() {
  int x = 1;
  if (cond) { x=100; _setjmp(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___setjmp__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _setjmp(arg1, x);
}

void test__sigsuspend__noreturn() {
  int x = 1;
  if (cond) { x=100; sigsuspend(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sigsuspend__leakignore() {
  char *p = malloc(10); *p=0;
  sigsuspend(p);
  // cppcheck-suppress memleak
}

void test__sigsuspend__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  sigsuspend(p);
}

void test__pthread_sigmask__noreturn() {
  int x = 1;
  if (cond) { x=100; pthread_sigmask(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__pthread_sigmask__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  pthread_sigmask(x, arg2, arg3);
}

void test__pthread_sigmask__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  pthread_sigmask(arg1, x, arg3);
}

void test__pthread_sigmask__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  pthread_sigmask(arg1, arg2, x);
}

void test__sigprocmask__noreturn() {
  int x = 1;
  if (cond) { x=100; sigprocmask(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sigprocmask__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sigprocmask(x, arg2, arg3);
}

void test__sigprocmask__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sigprocmask(arg1, x, arg3);
}

void test__sigprocmask__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sigprocmask(arg1, arg2, x);
}

void test__getrusage__noreturn() {
  int x = 1;
  if (cond) { x=100; getrusage(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getrusage__leakignore() {
  char *p = malloc(10); *p=0;
  getrusage(p, arg2);
  // cppcheck-suppress memleak
}

void test__getrusage__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  getrusage(x, arg2);
}

void test__getrusage__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getrusage(arg1, p);
}

void test__sigemptyset__noreturn() {
  int x = 1;
  if (cond) { x=100; sigemptyset(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sigemptyset__leakignore() {
  char *p = malloc(10); *p=0;
  sigemptyset(p);
  // cppcheck-suppress memleak
}

void test__sigemptyset__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  sigemptyset(p);
}

void test__sigfillset__noreturn() {
  int x = 1;
  if (cond) { x=100; sigfillset(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sigfillset__leakignore() {
  char *p = malloc(10); *p=0;
  sigfillset(p);
  // cppcheck-suppress memleak
}

void test__sigfillset__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  sigfillset(p);
}

void test__sigaddset__noreturn() {
  int x = 1;
  if (cond) { x=100; sigaddset(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sigaddset__leakignore() {
  char *p = malloc(10); *p=0;
  sigaddset(p, arg2);
  // cppcheck-suppress memleak
}

void test__sigaddset__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  sigaddset(p, arg2);
}

void test__sigaddset__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sigaddset(arg1, x);
}

void test__sigdelset__noreturn() {
  int x = 1;
  if (cond) { x=100; sigdelset(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sigdelset__leakignore() {
  char *p = malloc(10); *p=0;
  sigdelset(p, arg2);
  // cppcheck-suppress memleak
}

void test__sigdelset__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  sigdelset(p, arg2);
}

void test__sigdelset__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sigdelset(arg1, x);
}

void test__sigismember__noreturn() {
  int x = 1;
  if (cond) { x=100; sigismember(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sigismember__leakignore() {
  char *p = malloc(10); *p=0;
  sigismember(p, arg2);
  // cppcheck-suppress memleak
}

void test__sigismember__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  sigismember(p, arg2);
}

void test__sigismember__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sigismember(arg1, x);
}

void test__posix_spawn__noreturn() {
  int x = 1;
  if (cond) { x=100; posix_spawn(arg1, arg2, arg3, arg4, arg5, arg6); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__posix_spawn__leakignore() {
  char *p = malloc(10); *p=0;
  posix_spawn(p, arg2, arg3, arg4, arg5, arg6);
  // cppcheck-suppress memleak
}

void test__posix_spawnp__noreturn() {
  int x = 1;
  if (cond) { x=100; posix_spawnp(arg1, arg2, arg3, arg4, arg5, arg6); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__posix_spawnp__leakignore() {
  char *p = malloc(10); *p=0;
  posix_spawnp(p, arg2, arg3, arg4, arg5, arg6);
  // cppcheck-suppress memleak
}

void test__msgctl__noreturn() {
  int x = 1;
  if (cond) { x=100; msgctl(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__msgctl__leakignore() {
  char *p = malloc(10); *p=0;
  msgctl(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__msgctl__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  msgctl(x, arg2, arg3);
}

void test__msgctl__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  msgctl(arg1, x, arg3);
}

void test__msgctl__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  msgctl(arg1, arg2, x);
}

void test__msgget__noreturn() {
  int x = 1;
  if (cond) { x=100; result = msgget(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__msgget__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 = 1;
  if (cond) { x=100; msgrcv(arg1, arg2, arg3, arg4, arg5); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__msgrcv__leakignore() {
  char *p = malloc(10); *p=0;
  msgrcv(p, arg2, arg3, arg4, arg5);
  // cppcheck-suppress memleak
}

void test__msgrcv__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  msgrcv(x, arg2, arg3, arg4, arg5);
}

void test__msgrcv__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  msgrcv(arg1, p, arg3, arg4, arg5);
}

void test__msgrcv__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 = 1;
  if (cond) { x=100; msgsnd(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__msgsnd__leakignore() {
  char *p = malloc(10); *p=0;
  msgsnd(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__msgsnd__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  msgsnd(x, arg2, arg3, arg4);
}

void test__msgsnd__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  msgsnd(arg1, p, arg3, arg4);
}

void test__msgsnd__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 = 1;
  if (cond) { x=100; tcflow(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__tcflow__leakignore() {
  char *p = malloc(10); *p=0;
  tcflow(p, arg2);
  // cppcheck-suppress memleak
}

void test__tcflow__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 = 1;
  if (cond) { x=100; tcflush(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__tcflush__leakignore() {
  char *p = malloc(10); *p=0;
  tcflush(p, arg2);
  // cppcheck-suppress memleak
}

void test__tcflush__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 = 1;
  if (cond) { x=100; tcsendbreak(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__tcsendbreak__leakignore() {
  char *p = malloc(10); *p=0;
  tcsendbreak(p, arg2);
  // cppcheck-suppress memleak
}

void test__tcsendbreak__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  tcsendbreak(x, arg2);
}

void test__tcsendbreak__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  tcsendbreak(arg1, p);
}

void test__tcgetattr__noreturn() {
  int x = 1;
  if (cond) { x=100; tcgetattr(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__tcgetattr__leakignore() {
  char *p = malloc(10); *p=0;
  tcgetattr(p, arg2);
  // cppcheck-suppress memleak
}

void test__tcgetattr__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  tcgetattr(x, arg2);
}

void test__tcgetattr__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  tcgetattr(arg1, p);
}

void test__tcsetattr__noreturn() {
  int x = 1;
  if (cond) { x=100; tcsetattr(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__tcsetattr__leakignore() {
  char *p = malloc(10); *p=0;
  tcsetattr(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__tcsetattr__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() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  tcsetattr(arg1, arg2, p);
}

void test__tcsetattr__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  tcsetattr(arg1, arg2, x);
}

void test__cfsetospeed__noreturn() {
  int x = 1;
  if (cond) { x=100; cfsetospeed(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__cfsetospeed__leakignore() {
  char *p = malloc(10); *p=0;
  cfsetospeed(p, arg2);
  // cppcheck-suppress memleak
}

void test__cfsetospeed__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  cfsetospeed(p, arg2);
}

void test__cfsetospeed__arg1__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 = 1;
  if (cond) { x=100; cfsetispeed(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__cfsetispeed__leakignore() {
  char *p = malloc(10); *p=0;
  cfsetispeed(p, arg2);
  // cppcheck-suppress memleak
}

void test__cfsetispeed__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  cfsetispeed(p, 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 = 1;
  if (cond) { x=100; tcdrain(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__tcdrain__leakignore() {
  char *p = malloc(10); *p=0;
  tcdrain(p);
  // cppcheck-suppress memleak
}

void test__tcdrain__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  tcdrain(x);
}