cppcheck/test/cfg/generated-cfg-tests-windows.cpp

// auto generated tests from cfg/windows.cfg
//
// Generated by command:
// ./generate_cfg_tests cfg/windows.cfg > generated-cfg-tests-windows.cpp
//
// Recommended cppcheck command line:
// $ cppcheck --enable=warning,information --inline-suppr --platform=unix64 generated-cfg-tests-windows.cpp
// => 'unmatched suppression' warnings are false negatives.
//

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

void test__RtlCompareMemory__useretval() {
  // cppcheck-suppress ignoredReturnValue
  RtlCompareMemory(arg1, arg2, arg3);
}

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

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

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

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

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

void test__RtlCompareMemory__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  result = RtlCompareMemory(arg1, arg2, !x);
}

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

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

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

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

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

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

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

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

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

void test__RtlFillBytes__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  RtlFillBytes(arg1, !x, arg3);
}

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

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

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

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

void test__RtlSecureZeroMemory__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  RtlSecureZeroMemory(arg1, !x);
}

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

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

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

void test__RtlZeroBytes__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  RtlZeroBytes(arg1, !x);
}

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

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

void test__CString__Format__noreturn() {
  int x = 1;
  if (cond) { x=100; CString::Format(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CString__Format__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CString::Format(x);
}

void test__CString__AppendFormat__noreturn() {
  int x = 1;
  if (cond) { x=100; CString::AppendFormat(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CString__AppendFormat__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CString::AppendFormat(x);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void test___snprintf_s__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _snprintf_s(arg1, arg2, arg3, x);
}

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

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

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

void test___snwprintf_s__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _snwprintf_s(arg1, arg2, arg3, x);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void test__vDbgPrintExWithPrefix__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  vDbgPrintExWithPrefix(arg1, arg2, arg3, x);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void test__CloseHandle__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CloseHandle(x);
}

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

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

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

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

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

void test__BuildCommDCB__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  BuildCommDCB(x, arg2);
}

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

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

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

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

void test__WriteFile__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  WriteFile(arg1, x, arg3, arg4, arg5);
}

void test__WriteFile__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  WriteFile(arg1, arg2, x, arg4, arg5);
}

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

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

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

void test__ReadFile__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ReadFile(arg1, arg2, x, arg4, arg5);
}

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

void test__CreateFile__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateFile(x, arg2, arg3, arg4, arg5, arg6, arg7);
}

void test__CreateFile__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateFile(arg1, x, arg3, arg4, arg5, arg6, arg7);
}

void test__CreateFile__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateFile(arg1, arg2, x, arg4, arg5, arg6, arg7);
}

void test__CreateFile__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateFile(arg1, arg2, arg3, x, arg5, arg6, arg7);
}

void test__CreateFile__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateFile(arg1, arg2, arg3, arg4, x, arg6, arg7);
}

void test__CreateFile__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateFile(arg1, arg2, arg3, arg4, arg5, x, arg7);
}

void test__CreateFile__arg7__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateFile(arg1, arg2, arg3, arg4, arg5, arg6, x);
}

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

void test__SetCommTimeouts__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetCommTimeouts(x, arg2);
}

void test__SetCommTimeouts__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetCommTimeouts(arg1, x);
}

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

void test__SetCommState__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetCommState(x, arg2);
}

void test__SetCommState__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetCommState(arg1, x);
}

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

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

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

void test___mbstok__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _mbstok(x, arg2);
}

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

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

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

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

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

void test___tcstok__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _tcstok(x, arg2);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void test___wgetcwd__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _wgetcwd(x, arg2);
}

void test___wgetcwd__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _wgetcwd(arg1, x);
}

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

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

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

void test__SHGetFolderPath__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SHGetFolderPath(arg1, x, arg3, arg4, arg5);
}

void test__SHGetFolderPath__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SHGetFolderPath(arg1, arg2, x, arg4, arg5);
}

void test__SHGetFolderPath__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SHGetFolderPath(arg1, arg2, arg3, x, arg5);
}

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

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

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

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

void test__SHGetFolderPathA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SHGetFolderPathA(arg1, x, arg3, arg4, arg5);
}

void test__SHGetFolderPathA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SHGetFolderPathA(arg1, arg2, x, arg4, arg5);
}

void test__SHGetFolderPathA__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SHGetFolderPathA(arg1, arg2, arg3, x, arg5);
}

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

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

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

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

void test__SHGetFolderPathW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SHGetFolderPathW(arg1, x, arg3, arg4, arg5);
}

void test__SHGetFolderPathW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SHGetFolderPathW(arg1, arg2, x, arg4, arg5);
}

void test__SHGetFolderPathW__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SHGetFolderPathW(arg1, arg2, arg3, x, arg5);
}

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

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

void test__RegQueryValueEx__leakignore() {
  char *p = malloc(10); *p=0;
  RegQueryValueEx(p, arg2, arg3, arg4, arg5, arg6);
  // cppcheck-suppress memleak
}

void test__RegQueryValueEx__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegQueryValueEx(x, arg2, arg3, arg4, arg5, arg6);
}

void test__RegQueryValueEx__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegQueryValueEx(arg1, arg2, x, arg4, arg5, arg6);
}

void test__RegQueryValueEx__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegQueryValueEx(arg1, arg2, arg3, x, arg5, arg6);
}

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

void test__RegQueryValueExA__leakignore() {
  char *p = malloc(10); *p=0;
  RegQueryValueExA(p, arg2, arg3, arg4, arg5, arg6);
  // cppcheck-suppress memleak
}

void test__RegQueryValueExA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegQueryValueExA(x, arg2, arg3, arg4, arg5, arg6);
}

void test__RegQueryValueExA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegQueryValueExA(arg1, arg2, x, arg4, arg5, arg6);
}

void test__RegQueryValueExA__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegQueryValueExA(arg1, arg2, arg3, x, arg5, arg6);
}

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

void test__RegQueryValueExW__leakignore() {
  char *p = malloc(10); *p=0;
  RegQueryValueExW(p, arg2, arg3, arg4, arg5, arg6);
  // cppcheck-suppress memleak
}

void test__RegQueryValueExW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegQueryValueExW(x, arg2, arg3, arg4, arg5, arg6);
}

void test__RegQueryValueExW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegQueryValueExW(arg1, arg2, x, arg4, arg5, arg6);
}

void test__RegQueryValueExW__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegQueryValueExW(arg1, arg2, arg3, x, arg5, arg6);
}

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

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

void test__RegCloseKey__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegCloseKey(x);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void test__GetFileAttributes__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetFileAttributes(x);
}

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

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

void test__GetFileAttributesA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetFileAttributesA(x);
}

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

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

void test__GetFileAttributesW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetFileAttributesW(x);
}

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

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

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

void test__RegOpenKeyEx__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegOpenKeyEx(arg1, arg2, x, arg4, arg5);
}

void test__RegOpenKeyEx__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegOpenKeyEx(arg1, arg2, arg3, x, arg5);
}

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

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

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

void test__RegOpenKeyExA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegOpenKeyExA(arg1, arg2, x, arg4, arg5);
}

void test__RegOpenKeyExA__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegOpenKeyExA(arg1, arg2, arg3, x, arg5);
}

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

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

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

void test__RegOpenKeyExW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegOpenKeyExW(arg1, arg2, x, arg4, arg5);
}

void test__RegOpenKeyExW__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegOpenKeyExW(arg1, arg2, arg3, x, arg5);
}

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

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

void test__wsprintf__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wsprintf(x, arg2);
}

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

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

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

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

void test__wsprintfA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wsprintfA(x, arg2);
}

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

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

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

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

void test__wsprintfW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wsprintfW(x, arg2);
}

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

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

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

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

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

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

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

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

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

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

void test___sprintf_s_l__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _sprintf_s_l(arg1, arg2, x, arg4);
}

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

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

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

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

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

void test___swprintf_s_l__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _swprintf_s_l(arg1, arg2, x, arg4);
}

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

void test__RegEnumKeyEx__noreturn() {
  int x = 1;
  if (cond) { x=100; RegEnumKeyEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__RegEnumKeyEx__leakignore() {
  char *p = malloc(10); *p=0;
  RegEnumKeyEx(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
  // cppcheck-suppress memleak
}

void test__RegEnumKeyEx__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegEnumKeyEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}

void test__RegEnumKeyEx__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegEnumKeyEx(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
}

void test__RegEnumKeyExA__noreturn() {
  int x = 1;
  if (cond) { x=100; RegEnumKeyExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__RegEnumKeyExA__leakignore() {
  char *p = malloc(10); *p=0;
  RegEnumKeyExA(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
  // cppcheck-suppress memleak
}

void test__RegEnumKeyExA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegEnumKeyExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}

void test__RegEnumKeyExA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegEnumKeyExA(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
}

void test__RegEnumKeyExW__noreturn() {
  int x = 1;
  if (cond) { x=100; RegEnumKeyExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__RegEnumKeyExW__leakignore() {
  char *p = malloc(10); *p=0;
  RegEnumKeyExW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
  // cppcheck-suppress memleak
}

void test__RegEnumKeyExW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegEnumKeyExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}

void test__RegEnumKeyExW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RegEnumKeyExW(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
}

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

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

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

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

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

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

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

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

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

void test___vsnprintf__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _vsnprintf(arg1, arg2, x, arg4);
}

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

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

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

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

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

void test___vsnwprintf__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _vsnwprintf(arg1, arg2, x, arg4);
}

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

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

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

void test___vsnprintf_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnprintf_l(arg1, x, arg3, arg4, arg5);
}

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

void test___vsnprintf_l__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _vsnprintf_l(arg1, arg2, x, arg4, arg5);
}

void test___vsnprintf_l__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnprintf_l(arg1, arg2, arg3, x, arg5);
}

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

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

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

void test___vsnwprintf_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnwprintf_l(arg1, x, arg3, arg4, arg5);
}

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

void test___vsnwprintf_l__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _vsnwprintf_l(arg1, arg2, x, arg4, arg5);
}

void test___vsnwprintf_l__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnwprintf_l(arg1, arg2, arg3, x, arg5);
}

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

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

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

void test___vswprintf_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vswprintf_l(arg1, x, arg3, arg4, arg5);
}

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

void test___vswprintf_l__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _vswprintf_l(arg1, arg2, x, arg4, arg5);
}

void test___vswprintf_l__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vswprintf_l(arg1, arg2, arg3, x, arg5);
}

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

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

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

void test__vsnprintf_s__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  vsnprintf_s(arg1, x, arg3, arg4, arg5);
}

void test__vsnprintf_s__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  vsnprintf_s(arg1, arg2, x, arg4, arg5);
}

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

void test__vsnprintf_s__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  vsnprintf_s(arg1, arg2, arg3, x, arg5);
}

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

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

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

void test___vsnprintf_s__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnprintf_s(arg1, x, arg3, arg4, arg5);
}

void test___vsnprintf_s__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnprintf_s(arg1, arg2, x, arg4, arg5);
}

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

void test___vsnprintf_s__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _vsnprintf_s(arg1, arg2, arg3, x, arg5);
}

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

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

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

void test___vsnwprintf_s__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnwprintf_s(arg1, x, arg3, arg4, arg5);
}

void test___vsnwprintf_s__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnwprintf_s(arg1, arg2, x, arg4, arg5);
}

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

void test___vsnwprintf_s__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _vsnwprintf_s(arg1, arg2, arg3, x, arg5);
}

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

void test___vsnprintf_s_l__leakignore() {
  char *p = malloc(10); *p=0;
  _vsnprintf_s_l(p, arg2, arg3, arg4, arg5, arg6);
  // cppcheck-suppress memleak
}

void test___vsnprintf_s_l__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnprintf_s_l(x, arg2, arg3, arg4, arg5, arg6);
}

void test___vsnprintf_s_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnprintf_s_l(arg1, x, arg3, arg4, arg5, arg6);
}

void test___vsnprintf_s_l__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnprintf_s_l(arg1, arg2, x, arg4, arg5, arg6);
}

void test___vsnprintf_s_l__arg4__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _vsnprintf_s_l(arg1, arg2, arg3, p, arg5, arg6);
}

void test___vsnprintf_s_l__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _vsnprintf_s_l(arg1, arg2, arg3, x, arg5, arg6);
}

void test___vsnprintf_s_l__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnprintf_s_l(arg1, arg2, arg3, arg4, x, arg6);
}

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

void test___vsnwprintf_s_l__leakignore() {
  char *p = malloc(10); *p=0;
  _vsnwprintf_s_l(p, arg2, arg3, arg4, arg5, arg6);
  // cppcheck-suppress memleak
}

void test___vsnwprintf_s_l__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnwprintf_s_l(x, arg2, arg3, arg4, arg5, arg6);
}

void test___vsnwprintf_s_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnwprintf_s_l(arg1, x, arg3, arg4, arg5, arg6);
}

void test___vsnwprintf_s_l__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnwprintf_s_l(arg1, arg2, x, arg4, arg5, arg6);
}

void test___vsnwprintf_s_l__arg4__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _vsnwprintf_s_l(arg1, arg2, arg3, p, arg5, arg6);
}

void test___vsnwprintf_s_l__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _vsnwprintf_s_l(arg1, arg2, arg3, x, arg5, arg6);
}

void test___vsnwprintf_s_l__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _vsnwprintf_s_l(arg1, arg2, arg3, arg4, x, arg6);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void test___mbscmp__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _mbscmp(arg1, arg2);
}

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

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

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

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

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

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

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

void test___tcscmp__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _tcscmp(arg1, arg2);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void test___fstat32__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _fstat32(x, arg2);
}

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

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

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

void test___fstat64__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _fstat64(x, arg2);
}

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

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

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

void test___fstati64__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _fstati64(x, arg2);
}

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

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

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

void test___fstat32i64__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _fstat32i64(x, arg2);
}

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

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

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

void test___fstat64i32__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _fstat64i32(x, arg2);
}

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

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

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

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

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

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

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

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

void test___ftelli64__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _ftelli64(arg1);
}

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

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

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

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

void test___ftell_nolock__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _ftell_nolock(arg1);
}

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

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

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

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

void test___ftelli64_nolock__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _ftelli64_nolock(arg1);
}

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

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

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

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

void test___wfopen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _wfopen(arg1, arg2);
}

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

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

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

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

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

void test___tfopen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _tfopen(arg1, arg2);
}

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

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

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

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

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

void test__strnlen_s__useretval() {
  // cppcheck-suppress ignoredReturnValue
  strnlen_s(arg1, arg2);
}

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

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

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

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

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

void test__wcsnlen_s__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wcsnlen_s(arg1, arg2);
}

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

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

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

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

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

void test___mbsnlen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _mbsnlen(arg1, arg2);
}

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

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

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

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

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

void test___mbstrnlen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _mbstrnlen(arg1, arg2);
}

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

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

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

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

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

void test___mbsnlen_l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _mbsnlen_l(arg1, arg2, arg3);
}

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

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

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

void test___mbsnlen_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _mbsnlen_l(arg1, x, arg3);
}

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

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

void test___mbstrnlen_l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _mbstrnlen_l(arg1, arg2, arg3);
}

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

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

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

void test___mbstrnlen_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _mbstrnlen_l(arg1, x, arg3);
}

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

void test__WideCharToMultiByte__noreturn() {
  int x = 1;
  if (cond) { x=100; WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__WideCharToMultiByte__leakignore() {
  char *p = malloc(10); *p=0;
  WideCharToMultiByte(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
  // cppcheck-suppress memleak
}

void test__WideCharToMultiByte__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  WideCharToMultiByte(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}

void test__WideCharToMultiByte__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  WideCharToMultiByte(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8);
}

void test__WideCharToMultiByte__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  WideCharToMultiByte(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8);
}

void test__WideCharToMultiByte__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  WideCharToMultiByte(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8);
}

void test__WideCharToMultiByte__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8);
}

void test__WideCharToMultiByte__arg7__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  WideCharToMultiByte(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8);
}

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

void test__PathIsDirectory__useretval() {
  // cppcheck-suppress ignoredReturnValue
  PathIsDirectory(arg1);
}

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

void test__PathIsDirectory__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = PathIsDirectory(x);
}

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

void test__PathIsDirectoryA__useretval() {
  // cppcheck-suppress ignoredReturnValue
  PathIsDirectoryA(arg1);
}

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

void test__PathIsDirectoryA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = PathIsDirectoryA(x);
}

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

void test__PathIsDirectoryW__useretval() {
  // cppcheck-suppress ignoredReturnValue
  PathIsDirectoryW(arg1);
}

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

void test__PathIsDirectoryW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = PathIsDirectoryW(x);
}

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

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

void test__SetConsoleTextAttribute__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetConsoleTextAttribute(x, arg2);
}

void test__SetConsoleTextAttribute__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetConsoleTextAttribute(arg1, x);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void test__DeleteFile__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  DeleteFile(x);
}

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

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

void test__DeleteFileA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  DeleteFileA(x);
}

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

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

void test__DeleteFileW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  DeleteFileW(x);
}

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

void test__GetStdHandle__useretval() {
  // cppcheck-suppress ignoredReturnValue
  GetStdHandle(arg1);
}

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

void test__GetStdHandle__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = GetStdHandle(x);
}

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

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

void test__SetStdHandle__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetStdHandle(x, arg2);
}

void test__SetStdHandle__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetStdHandle(arg1, x);
}

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

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

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

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

void test___access__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _access(arg1, x);
}

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

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

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

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

void test___waccess__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _waccess(arg1, x);
}

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

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

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

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

void test___taccess__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _taccess(arg1, x);
}

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

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

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

void test__PeekMessage__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  PeekMessage(arg1, x, arg3, arg4, arg5);
}

void test__PeekMessage__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  PeekMessage(arg1, arg2, x, arg4, arg5);
}

void test__PeekMessage__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  PeekMessage(arg1, arg2, arg3, x, arg5);
}

void test__PeekMessage__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  PeekMessage(arg1, arg2, arg3, arg4, x);
}

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

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

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

void test__PeekMessageA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  PeekMessageA(arg1, x, arg3, arg4, arg5);
}

void test__PeekMessageA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  PeekMessageA(arg1, arg2, x, arg4, arg5);
}

void test__PeekMessageA__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  PeekMessageA(arg1, arg2, arg3, x, arg5);
}

void test__PeekMessageA__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  PeekMessageA(arg1, arg2, arg3, arg4, x);
}

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

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

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

void test__PeekMessageW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  PeekMessageW(arg1, x, arg3, arg4, arg5);
}

void test__PeekMessageW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  PeekMessageW(arg1, arg2, x, arg4, arg5);
}

void test__PeekMessageW__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  PeekMessageW(arg1, arg2, arg3, x, arg5);
}

void test__PeekMessageW__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  PeekMessageW(arg1, arg2, arg3, arg4, x);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void test__PostQuitMessage__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  PostQuitMessage(x);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void test__GetPrivateProfileInt__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = GetPrivateProfileInt(arg1, arg2, x, arg4);
}

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

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

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

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

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

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

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

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

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

void test__GetPrivateProfileIntA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = GetPrivateProfileIntA(arg1, arg2, x, arg4);
}

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

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

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

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

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

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

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

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

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

void test__GetPrivateProfileIntW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = GetPrivateProfileIntW(arg1, arg2, x, arg4);
}

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

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

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

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

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

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

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

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

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

void test__GetPrivateProfileSection__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  GetPrivateProfileSection(arg1, arg2, arg3, x);
}

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

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

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

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

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

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

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

void test__GetPrivateProfileSectionA__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  GetPrivateProfileSectionA(arg1, arg2, arg3, x);
}

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

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

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

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

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

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

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

void test__GetPrivateProfileSectionW__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  GetPrivateProfileSectionW(arg1, arg2, arg3, x);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void test__GetPrivateProfileString__leakignore() {
  char *p = malloc(10); *p=0;
  GetPrivateProfileString(p, arg2, arg3, arg4, arg5, arg6);
  // cppcheck-suppress memleak
}

void test__GetPrivateProfileString__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetPrivateProfileString(x, arg2, arg3, arg4, arg5, arg6);
}

void test__GetPrivateProfileString__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetPrivateProfileString(arg1, x, arg3, arg4, arg5, arg6);
}

void test__GetPrivateProfileString__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetPrivateProfileString(arg1, arg2, x, arg4, arg5, arg6);
}

void test__GetPrivateProfileString__arg4__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetPrivateProfileString(arg1, arg2, arg3, p, arg5, arg6);
}

void test__GetPrivateProfileString__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetPrivateProfileString(arg1, arg2, arg3, arg4, x, arg6);
}

void test__GetPrivateProfileString__arg6__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, p);
}

void test__GetPrivateProfileString__arg6__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  GetPrivateProfileString(arg1, arg2, arg3, arg4, arg5, x);
}

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

void test__GetPrivateProfileStringA__leakignore() {
  char *p = malloc(10); *p=0;
  GetPrivateProfileStringA(p, arg2, arg3, arg4, arg5, arg6);
  // cppcheck-suppress memleak
}

void test__GetPrivateProfileStringA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetPrivateProfileStringA(x, arg2, arg3, arg4, arg5, arg6);
}

void test__GetPrivateProfileStringA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetPrivateProfileStringA(arg1, x, arg3, arg4, arg5, arg6);
}

void test__GetPrivateProfileStringA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetPrivateProfileStringA(arg1, arg2, x, arg4, arg5, arg6);
}

void test__GetPrivateProfileStringA__arg4__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetPrivateProfileStringA(arg1, arg2, arg3, p, arg5, arg6);
}

void test__GetPrivateProfileStringA__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetPrivateProfileStringA(arg1, arg2, arg3, arg4, x, arg6);
}

void test__GetPrivateProfileStringA__arg6__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, p);
}

void test__GetPrivateProfileStringA__arg6__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  GetPrivateProfileStringA(arg1, arg2, arg3, arg4, arg5, x);
}

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

void test__GetPrivateProfileStringW__leakignore() {
  char *p = malloc(10); *p=0;
  GetPrivateProfileStringW(p, arg2, arg3, arg4, arg5, arg6);
  // cppcheck-suppress memleak
}

void test__GetPrivateProfileStringW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetPrivateProfileStringW(x, arg2, arg3, arg4, arg5, arg6);
}

void test__GetPrivateProfileStringW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetPrivateProfileStringW(arg1, x, arg3, arg4, arg5, arg6);
}

void test__GetPrivateProfileStringW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetPrivateProfileStringW(arg1, arg2, x, arg4, arg5, arg6);
}

void test__GetPrivateProfileStringW__arg4__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetPrivateProfileStringW(arg1, arg2, arg3, p, arg5, arg6);
}

void test__GetPrivateProfileStringW__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetPrivateProfileStringW(arg1, arg2, arg3, arg4, x, arg6);
}

void test__GetPrivateProfileStringW__arg6__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetPrivateProfileStringW(arg1, arg2, arg3, arg4, arg5, p);
}

void test__GetPrivateProfileStringW__arg6__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  GetPrivateProfileStringW(arg1, arg2, arg3, arg4, arg5, x);
}

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

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

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

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

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

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

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

void test__GetPrivateProfileStruct__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetPrivateProfileStruct(arg1, arg2, arg3, x, arg5);
}

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

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

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

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

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

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

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

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

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

void test__GetPrivateProfileStructA__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetPrivateProfileStructA(arg1, arg2, arg3, x, arg5);
}

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

void test__GetPrivateProfileStructA__arg5__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  GetPrivateProfileStructA(arg1, arg2, arg3, arg4, x);
}

void test__GetPrivateProfileStructW__noreturn() {
  int x = 1;
  if (cond) { x=100; GetPrivateProfileStructW(arg1, arg2, arg3, arg4, arg5); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetPrivateProfileStructW__leakignore() {
  char *p = malloc(10); *p=0;
  GetPrivateProfileStructW(p, arg2, arg3, arg4, arg5);
  // cppcheck-suppress memleak
}

void test__GetPrivateProfileStructW__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetPrivateProfileStructW(p, arg2, arg3, arg4, arg5);
}

void test__GetPrivateProfileStructW__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  GetPrivateProfileStructW(x, arg2, arg3, arg4, arg5);
}

void test__GetPrivateProfileStructW__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetPrivateProfileStructW(arg1, p, arg3, arg4, arg5);
}

void test__GetPrivateProfileStructW__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  GetPrivateProfileStructW(arg1, x, arg3, arg4, arg5);
}

void test__GetPrivateProfileStructW__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetPrivateProfileStructW(arg1, arg2, p, arg4, arg5);
}

void test__GetPrivateProfileStructW__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetPrivateProfileStructW(arg1, arg2, arg3, x, arg5);
}

void test__GetPrivateProfileStructW__arg5__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetPrivateProfileStructW(arg1, arg2, arg3, arg4, p);
}

void test__GetPrivateProfileStructW__arg5__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  GetPrivateProfileStructW(arg1, arg2, arg3, arg4, x);
}

void test__BeginPaint__noreturn() {
  int x = 1;
  if (cond) { x=100; BeginPaint(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__BeginPaint__leakignore() {
  char *p = malloc(10); *p=0;
  BeginPaint(p, arg2);
  // cppcheck-suppress memleak
}

void test__BeginPaint__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  BeginPaint(x, arg2);
}

void test__BeginPaint__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  BeginPaint(arg1, p);
}

void test__EndPaint__noreturn() {
  int x = 1;
  if (cond) { x=100; EndPaint(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__EndPaint__leakignore() {
  char *p = malloc(10); *p=0;
  EndPaint(p, arg2);
  // cppcheck-suppress memleak
}

void test__EndPaint__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  EndPaint(x, arg2);
}

void test__EndPaint__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  EndPaint(arg1, p);
}

void test__GetStockObject__noreturn() {
  int x = 1;
  if (cond) { x=100; result = GetStockObject(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetStockObject__useretval() {
  // cppcheck-suppress ignoredReturnValue
  GetStockObject(arg1);
}

void test__GetStockObject__pure(int arg1) {
  // cppcheck-suppress incorrectLogicOperator
  if ((GetStockObject(arg1) > 10) || (GetStockObject(arg1) < 100)) {}
}

void test__GetStockObject__leakignore() {
  char *p = malloc(10); *p=0;
  result = GetStockObject(p);
  // cppcheck-suppress memleak
}

void test__GetStockObject__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = GetStockObject(x);
}

void test__LoadIcon__noreturn() {
  int x = 1;
  if (cond) { x=100; result = LoadIcon(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__LoadIcon__useretval() {
  // cppcheck-suppress ignoredReturnValue
  LoadIcon(arg1, arg2);
}

void test__LoadIcon__leakignore() {
  char *p = malloc(10); *p=0;
  result = LoadIcon(p, arg2);
  // cppcheck-suppress memleak
}

void test__LoadIcon__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = LoadIcon(x, arg2);
}

void test__LoadIcon__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = LoadIcon(arg1, p);
}

void test__LoadIcon__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = LoadIcon(arg1, x);
}

void test__LoadIconA__noreturn() {
  int x = 1;
  if (cond) { x=100; result = LoadIconA(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__LoadIconA__useretval() {
  // cppcheck-suppress ignoredReturnValue
  LoadIconA(arg1, arg2);
}

void test__LoadIconA__leakignore() {
  char *p = malloc(10); *p=0;
  result = LoadIconA(p, arg2);
  // cppcheck-suppress memleak
}

void test__LoadIconA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = LoadIconA(x, arg2);
}

void test__LoadIconA__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = LoadIconA(arg1, p);
}

void test__LoadIconA__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = LoadIconA(arg1, x);
}

void test__LoadIconW__noreturn() {
  int x = 1;
  if (cond) { x=100; result = LoadIconW(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__LoadIconW__useretval() {
  // cppcheck-suppress ignoredReturnValue
  LoadIconW(arg1, arg2);
}

void test__LoadIconW__leakignore() {
  char *p = malloc(10); *p=0;
  result = LoadIconW(p, arg2);
  // cppcheck-suppress memleak
}

void test__LoadIconW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = LoadIconW(x, arg2);
}

void test__LoadIconW__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = LoadIconW(arg1, p);
}

void test__LoadIconW__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = LoadIconW(arg1, x);
}

void test__CreateSolidBrush__noreturn() {
  int x = 1;
  if (cond) { x=100; result = CreateSolidBrush(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateSolidBrush__useretval() {
  // cppcheck-suppress ignoredReturnValue
  CreateSolidBrush(arg1);
}

void test__CreateSolidBrush__leakignore() {
  char *p = malloc(10); *p=0;
  result = CreateSolidBrush(p);
  // cppcheck-suppress memleak
}

void test__CreateSolidBrush__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateSolidBrush(x);
}

void test__UpdateWindow__noreturn() {
  int x = 1;
  if (cond) { x=100; UpdateWindow(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__UpdateWindow__leakignore() {
  char *p = malloc(10); *p=0;
  UpdateWindow(p);
  // cppcheck-suppress memleak
}

void test__UpdateWindow__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  UpdateWindow(p);
}

void test__UpdateWindow__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  UpdateWindow(x);
}

void test__EnableWindow__noreturn() {
  int x = 1;
  if (cond) { x=100; EnableWindow(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__EnableWindow__leakignore() {
  char *p = malloc(10); *p=0;
  EnableWindow(p, arg2);
  // cppcheck-suppress memleak
}

void test__EnableWindow__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  EnableWindow(p, arg2);
}

void test__EnableWindow__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  EnableWindow(x, arg2);
}

void test__EnableWindow__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  EnableWindow(arg1, x);
}

void test__CreateWindow__noreturn() {
  int x = 1;
  if (cond) { x=100; result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateWindow__useretval() {
  // cppcheck-suppress ignoredReturnValue
  CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindow__leakignore() {
  char *p = malloc(10); *p=0;
  result = CreateWindow(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
  // cppcheck-suppress memleak
}

void test__CreateWindow__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindow(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindow__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindow(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindow__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindow(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindow__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindow(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindow__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindow(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindow__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindow(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindow__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindow(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
}

void test__CreateWindow__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindow(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
}

void test__CreateWindow__arg7__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
}

void test__CreateWindow__arg8__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
}

void test__CreateWindow__arg9__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindow(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
}

void test__CreateWindowA__noreturn() {
  int x = 1;
  if (cond) { x=100; result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateWindowA__useretval() {
  // cppcheck-suppress ignoredReturnValue
  CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowA__leakignore() {
  char *p = malloc(10); *p=0;
  result = CreateWindowA(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
  // cppcheck-suppress memleak
}

void test__CreateWindowA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowA(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowA(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowA__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowA(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowA__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowA(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
}

void test__CreateWindowA__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
}

void test__CreateWindowA__arg7__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
}

void test__CreateWindowA__arg8__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
}

void test__CreateWindowA__arg9__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
}

void test__CreateWindowW__noreturn() {
  int x = 1;
  if (cond) { x=100; result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateWindowW__useretval() {
  // cppcheck-suppress ignoredReturnValue
  CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowW__leakignore() {
  char *p = malloc(10); *p=0;
  result = CreateWindowW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
  // cppcheck-suppress memleak
}

void test__CreateWindowW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowW(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowW(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowW__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowW(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowW__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowW(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
}

void test__CreateWindowW__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
}

void test__CreateWindowW__arg7__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
}

void test__CreateWindowW__arg8__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
}

void test__CreateWindowW__arg9__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
}

void test__CreateWindowEx__noreturn() {
  int x = 1;
  if (cond) { x=100; result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateWindowEx__useretval() {
  // cppcheck-suppress ignoredReturnValue
  CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowEx__leakignore() {
  char *p = malloc(10); *p=0;
  result = CreateWindowEx(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
  // cppcheck-suppress memleak
}

void test__CreateWindowEx__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowEx__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowEx__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowEx__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowEx(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowEx__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowEx(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowEx__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowEx(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowEx__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowEx(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowEx__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowEx(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
}

void test__CreateWindowEx__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
}

void test__CreateWindowEx__arg7__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
}

void test__CreateWindowEx__arg8__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
}

void test__CreateWindowEx__arg9__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowEx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
}

void test__CreateWindowExA__noreturn() {
  int x = 1;
  if (cond) { x=100; result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateWindowExA__useretval() {
  // cppcheck-suppress ignoredReturnValue
  CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExA__leakignore() {
  char *p = malloc(10); *p=0;
  result = CreateWindowExA(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
  // cppcheck-suppress memleak
}

void test__CreateWindowExA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExA(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExA(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExA(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExA__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExA(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExA__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExA(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExA__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
}

void test__CreateWindowExA__arg7__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
}

void test__CreateWindowExA__arg8__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
}

void test__CreateWindowExA__arg9__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
}

void test__CreateWindowExW__noreturn() {
  int x = 1;
  if (cond) { x=100; result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateWindowExW__useretval() {
  // cppcheck-suppress ignoredReturnValue
  CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExW__leakignore() {
  char *p = malloc(10); *p=0;
  result = CreateWindowExW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
  // cppcheck-suppress memleak
}

void test__CreateWindowExW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExW(x, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExW(arg1, x, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExW(arg1, arg2, x, arg4, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExW__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExW(arg1, arg2, arg3, x, arg5, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExW__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExW(arg1, arg2, arg3, arg4, x, arg6, arg7, arg8, arg9);
}

void test__CreateWindowExW__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, x, arg7, arg8, arg9);
}

void test__CreateWindowExW__arg7__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, x, arg8, arg9);
}

void test__CreateWindowExW__arg8__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, x, arg9);
}

void test__CreateWindowExW__arg9__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWindowExW(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, x);
}

void test__SetWindowText__noreturn() {
  int x = 1;
  if (cond) { x=100; SetWindowText(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SetWindowText__leakignore() {
  char *p = malloc(10); *p=0;
  SetWindowText(p, arg2);
  // cppcheck-suppress memleak
}

void test__SetWindowText__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  SetWindowText(p, arg2);
}

void test__SetWindowText__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  SetWindowText(x, arg2);
}

void test__SetWindowText__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  SetWindowText(arg1, p);
}

void test__SetWindowText__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  SetWindowText(arg1, x);
}

void test__SetWindowTextA__noreturn() {
  int x = 1;
  if (cond) { x=100; SetWindowTextA(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SetWindowTextA__leakignore() {
  char *p = malloc(10); *p=0;
  SetWindowTextA(p, arg2);
  // cppcheck-suppress memleak
}

void test__SetWindowTextA__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  SetWindowTextA(p, arg2);
}

void test__SetWindowTextA__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  SetWindowTextA(x, arg2);
}

void test__SetWindowTextA__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  SetWindowTextA(arg1, p);
}

void test__SetWindowTextA__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  SetWindowTextA(arg1, x);
}

void test__SetWindowTextW__noreturn() {
  int x = 1;
  if (cond) { x=100; SetWindowTextW(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SetWindowTextW__leakignore() {
  char *p = malloc(10); *p=0;
  SetWindowTextW(p, arg2);
  // cppcheck-suppress memleak
}

void test__SetWindowTextW__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  SetWindowTextW(p, arg2);
}

void test__SetWindowTextW__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  SetWindowTextW(x, arg2);
}

void test__SetWindowTextW__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  SetWindowTextW(arg1, p);
}

void test__SetWindowTextW__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  SetWindowTextW(arg1, x);
}

void test__RegisterClass__noreturn() {
  int x = 1;
  if (cond) { x=100; RegisterClass(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__RegisterClass__leakignore() {
  char *p = malloc(10); *p=0;
  RegisterClass(p);
  // cppcheck-suppress memleak
}

void test__RegisterClass__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  RegisterClass(p);
}

void test__RegisterClass__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  RegisterClass(x);
}

void test__RegisterClassEx__noreturn() {
  int x = 1;
  if (cond) { x=100; RegisterClassEx(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__RegisterClassEx__leakignore() {
  char *p = malloc(10); *p=0;
  RegisterClassEx(p);
  // cppcheck-suppress memleak
}

void test__RegisterClassEx__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  RegisterClassEx(p);
}

void test__RegisterClassEx__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  RegisterClassEx(x);
}

void test__UnregisterClass__noreturn() {
  int x = 1;
  if (cond) { x=100; UnregisterClass(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__UnregisterClass__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  UnregisterClass(x, arg2);
}

void test__UnregisterClass__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  UnregisterClass(arg1, x);
}

void test__UnregisterClassA__noreturn() {
  int x = 1;
  if (cond) { x=100; UnregisterClassA(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__UnregisterClassA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  UnregisterClassA(x, arg2);
}

void test__UnregisterClassA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  UnregisterClassA(arg1, x);
}

void test__UnregisterClassW__noreturn() {
  int x = 1;
  if (cond) { x=100; UnregisterClassW(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__UnregisterClassW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  UnregisterClassW(x, arg2);
}

void test__UnregisterClassW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  UnregisterClassW(arg1, x);
}

void test__MessageBox__noreturn() {
  int x = 1;
  if (cond) { x=100; MessageBox(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__MessageBox__leakignore() {
  char *p = malloc(10); *p=0;
  MessageBox(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__MessageBox__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  MessageBox(x, arg2, arg3, arg4);
}

void test__MessageBox__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  MessageBox(arg1, x, arg3, arg4);
}

void test__MessageBox__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  MessageBox(arg1, arg2, x, arg4);
}

void test__MessageBox__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  MessageBox(arg1, arg2, arg3, x);
}

void test__MessageBoxA__noreturn() {
  int x = 1;
  if (cond) { x=100; MessageBoxA(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__MessageBoxA__leakignore() {
  char *p = malloc(10); *p=0;
  MessageBoxA(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__MessageBoxA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  MessageBoxA(x, arg2, arg3, arg4);
}

void test__MessageBoxA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  MessageBoxA(arg1, x, arg3, arg4);
}

void test__MessageBoxA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  MessageBoxA(arg1, arg2, x, arg4);
}

void test__MessageBoxA__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  MessageBoxA(arg1, arg2, arg3, x);
}

void test__MessageBoxW__noreturn() {
  int x = 1;
  if (cond) { x=100; MessageBoxW(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__MessageBoxW__leakignore() {
  char *p = malloc(10); *p=0;
  MessageBoxW(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__MessageBoxW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  MessageBoxW(x, arg2, arg3, arg4);
}

void test__MessageBoxW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  MessageBoxW(arg1, x, arg3, arg4);
}

void test__MessageBoxW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  MessageBoxW(arg1, arg2, x, arg4);
}

void test__MessageBoxW__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  MessageBoxW(arg1, arg2, arg3, x);
}

void test__GlobalLock__noreturn() {
  int x = 1;
  if (cond) { x=100; GlobalLock(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GlobalLock__leakignore() {
  char *p = malloc(10); *p=0;
  GlobalLock(p);
  // cppcheck-suppress memleak
}

void test__GlobalLock__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GlobalLock(p);
}

void test__GlobalLock__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  GlobalLock(x);
}

void test__GlobalUnlock__noreturn() {
  int x = 1;
  if (cond) { x=100; GlobalUnlock(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GlobalUnlock__leakignore() {
  char *p = malloc(10); *p=0;
  GlobalUnlock(p);
  // cppcheck-suppress memleak
}

void test__GlobalUnlock__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GlobalUnlock(p);
}

void test__GlobalUnlock__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  GlobalUnlock(x);
}

void test__OpenClipboard__noreturn() {
  int x = 1;
  if (cond) { x=100; OpenClipboard(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__OpenClipboard__leakignore() {
  char *p = malloc(10); *p=0;
  OpenClipboard(p);
  // cppcheck-suppress memleak
}

void test__OpenClipboard__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenClipboard(x);
}

void test__EmptyClipboard__noreturn() {
  int x = 1;
  if (cond) { x=100; EmptyClipboard(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__EmptyClipboard__leakignore() {
  char *p = malloc(10); *p=0;
  EmptyClipboard();
  // cppcheck-suppress memleak
}

void test__CloseClipboard__noreturn() {
  int x = 1;
  if (cond) { x=100; CloseClipboard(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CloseClipboard__leakignore() {
  char *p = malloc(10); *p=0;
  CloseClipboard();
  // cppcheck-suppress memleak
}

void test__SetClipboardData__noreturn() {
  int x = 1;
  if (cond) { x=100; SetClipboardData(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SetClipboardData__leakignore() {
  char *p = malloc(10); *p=0;
  SetClipboardData(p, arg2);
  // cppcheck-suppress memleak
}

void test__SetClipboardData__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetClipboardData(x, arg2);
}

void test__SetClipboardData__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetClipboardData(arg1, x);
}

void test___rmdir__noreturn() {
  int x = 1;
  if (cond) { x=100; _rmdir(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___rmdir__leakignore() {
  char *p = malloc(10); *p=0;
  _rmdir(p);
  // cppcheck-suppress memleak
}

void test___rmdir__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _rmdir(p);
}

void test___rmdir__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _rmdir(x);
}

void test___wrmdir__noreturn() {
  int x = 1;
  if (cond) { x=100; _wrmdir(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___wrmdir__leakignore() {
  char *p = malloc(10); *p=0;
  _wrmdir(p);
  // cppcheck-suppress memleak
}

void test___wrmdir__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _wrmdir(p);
}

void test___wrmdir__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _wrmdir(x);
}

void test___mkdir__noreturn() {
  int x = 1;
  if (cond) { x=100; _mkdir(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___mkdir__leakignore() {
  char *p = malloc(10); *p=0;
  _mkdir(p);
  // cppcheck-suppress memleak
}

void test___mkdir__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _mkdir(p);
}

void test___mkdir__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _mkdir(x);
}

void test___wmkdir__noreturn() {
  int x = 1;
  if (cond) { x=100; _wmkdir(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___wmkdir__leakignore() {
  char *p = malloc(10); *p=0;
  _wmkdir(p);
  // cppcheck-suppress memleak
}

void test___wmkdir__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _wmkdir(p);
}

void test___wmkdir__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _wmkdir(x);
}

void test___abs64__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _abs64(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___abs64__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _abs64(arg1);
}

void test___abs64__pure(int arg1) {
  // cppcheck-suppress incorrectLogicOperator
  if ((_abs64(arg1) > 10) || (_abs64(arg1) < 100)) {}
}

void test___abs64__leakignore() {
  char *p = malloc(10); *p=0;
  result = _abs64(p);
  // cppcheck-suppress memleak
}

void test___abs64__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  result = _abs64(!x);
}

void test___abs64__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _abs64(x);
}

void test__CreateWaitableTimer__noreturn() {
  int x = 1;
  if (cond) { x=100; result = CreateWaitableTimer(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateWaitableTimer__useretval() {
  // cppcheck-suppress ignoredReturnValue
  CreateWaitableTimer(arg1, arg2, arg3);
}

void test__CreateWaitableTimer__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWaitableTimer(x, arg2, arg3);
}

void test__CreateWaitableTimer__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWaitableTimer(arg1, x, arg3);
}

void test__CreateWaitableTimer__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateWaitableTimer(arg1, arg2, x);
}

void test__SetWaitableTimer__noreturn() {
  int x = 1;
  if (cond) { x=100; SetWaitableTimer(arg1, arg2, arg3, arg4, arg5, arg6); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SetWaitableTimer__leakignore() {
  char *p = malloc(10); *p=0;
  SetWaitableTimer(p, arg2, arg3, arg4, arg5, arg6);
  // cppcheck-suppress memleak
}

void test__SetWaitableTimer__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetWaitableTimer(x, arg2, arg3, arg4, arg5, arg6);
}

void test__SetWaitableTimer__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  SetWaitableTimer(arg1, p, arg3, arg4, arg5, arg6);
}

void test__SetWaitableTimer__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  SetWaitableTimer(arg1, x, arg3, arg4, arg5, arg6);
}

void test__SetWaitableTimer__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetWaitableTimer(arg1, arg2, x, arg4, arg5, arg6);
}

void test__SetWaitableTimer__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetWaitableTimer(arg1, arg2, arg3, x, arg5, arg6);
}

void test__SetWaitableTimer__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetWaitableTimer(arg1, arg2, arg3, arg4, x, arg6);
}

void test__SetWaitableTimer__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetWaitableTimer(arg1, arg2, arg3, arg4, arg5, x);
}

void test__WaitForSingleObject__noreturn() {
  int x = 1;
  if (cond) { x=100; WaitForSingleObject(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__WaitForSingleObject__leakignore() {
  char *p = malloc(10); *p=0;
  WaitForSingleObject(p, arg2);
  // cppcheck-suppress memleak
}

void test__WaitForSingleObject__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  WaitForSingleObject(x, arg2);
}

void test__WaitForSingleObject__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  WaitForSingleObject(arg1, x);
}

void test___pclose__noreturn() {
  int x = 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___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___wpopen__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _wpopen(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___wpopen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _wpopen(arg1, arg2);
}

void test___wpopen__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _wpopen(p, arg2);
}

void test___wpopen__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _wpopen(x, arg2);
}

void test___wpopen__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _wpopen(arg1, p);
}

void test___wpopen__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _wpopen(arg1, x);
}

void test___tpopen__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _tpopen(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tpopen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _tpopen(arg1, arg2);
}

void test___tpopen__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tpopen(p, arg2);
}

void test___tpopen__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tpopen(x, arg2);
}

void test___tpopen__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tpopen(arg1, p);
}

void test___tpopen__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tpopen(arg1, 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___wmktemp__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _wmktemp(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___wmktemp__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _wmktemp(arg1);
}

void test___wmktemp__leakignore() {
  char *p = malloc(10); *p=0;
  result = _wmktemp(p);
  // cppcheck-suppress memleak
}

void test___wmktemp__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _wmktemp(p);
}

void test___wmktemp__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _wmktemp(x);
}

void test__FindFirstFileEx__noreturn() {
  int x = 1;
  if (cond) { x=100; result = FindFirstFileEx(arg1, arg2, arg3, arg4, arg5, arg6); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FindFirstFileEx__useretval() {
  // cppcheck-suppress ignoredReturnValue
  FindFirstFileEx(arg1, arg2, arg3, arg4, arg5, arg6);
}

void test__FindFirstFileEx__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindFirstFileEx(p, arg2, arg3, arg4, arg5, arg6);
}

void test__FindFirstFileEx__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = FindFirstFileEx(x, arg2, arg3, arg4, arg5, arg6);
}

void test__FindFirstFileEx__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = FindFirstFileEx(arg1, x, arg3, arg4, arg5, arg6);
}

void test__FindFirstFileEx__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindFirstFileEx(arg1, arg2, p, arg4, arg5, arg6);
}

void test__FindFirstFileEx__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = FindFirstFileEx(arg1, arg2, arg3, x, arg5, arg6);
}

void test__FindFirstFileEx__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = FindFirstFileEx(arg1, arg2, arg3, arg4, arg5, x);
}

void test__FindFirstFileExA__noreturn() {
  int x = 1;
  if (cond) { x=100; result = FindFirstFileExA(arg1, arg2, arg3, arg4, arg5, arg6); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FindFirstFileExA__useretval() {
  // cppcheck-suppress ignoredReturnValue
  FindFirstFileExA(arg1, arg2, arg3, arg4, arg5, arg6);
}

void test__FindFirstFileExA__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindFirstFileExA(p, arg2, arg3, arg4, arg5, arg6);
}

void test__FindFirstFileExA__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = FindFirstFileExA(x, arg2, arg3, arg4, arg5, arg6);
}

void test__FindFirstFileExA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = FindFirstFileExA(arg1, x, arg3, arg4, arg5, arg6);
}

void test__FindFirstFileExA__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindFirstFileExA(arg1, arg2, p, arg4, arg5, arg6);
}

void test__FindFirstFileExA__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = FindFirstFileExA(arg1, arg2, arg3, x, arg5, arg6);
}

void test__FindFirstFileExA__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = FindFirstFileExA(arg1, arg2, arg3, arg4, arg5, x);
}

void test__FindFirstFileExW__noreturn() {
  int x = 1;
  if (cond) { x=100; result = FindFirstFileExW(arg1, arg2, arg3, arg4, arg5, arg6); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FindFirstFileExW__useretval() {
  // cppcheck-suppress ignoredReturnValue
  FindFirstFileExW(arg1, arg2, arg3, arg4, arg5, arg6);
}

void test__FindFirstFileExW__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindFirstFileExW(p, arg2, arg3, arg4, arg5, arg6);
}

void test__FindFirstFileExW__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = FindFirstFileExW(x, arg2, arg3, arg4, arg5, arg6);
}

void test__FindFirstFileExW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = FindFirstFileExW(arg1, x, arg3, arg4, arg5, arg6);
}

void test__FindFirstFileExW__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindFirstFileExW(arg1, arg2, p, arg4, arg5, arg6);
}

void test__FindFirstFileExW__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = FindFirstFileExW(arg1, arg2, arg3, x, arg5, arg6);
}

void test__FindFirstFileExW__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = FindFirstFileExW(arg1, arg2, arg3, arg4, arg5, x);
}

void test__FindFirstFile__noreturn() {
  int x = 1;
  if (cond) { x=100; result = FindFirstFile(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FindFirstFile__useretval() {
  // cppcheck-suppress ignoredReturnValue
  FindFirstFile(arg1, arg2);
}

void test__FindFirstFile__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindFirstFile(p, arg2);
}

void test__FindFirstFile__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = FindFirstFile(x, arg2);
}

void test__FindFirstFile__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindFirstFile(arg1, p);
}

void test__FindFirstFileW__noreturn() {
  int x = 1;
  if (cond) { x=100; result = FindFirstFileW(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FindFirstFileW__useretval() {
  // cppcheck-suppress ignoredReturnValue
  FindFirstFileW(arg1, arg2);
}

void test__FindFirstFileW__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindFirstFileW(p, arg2);
}

void test__FindFirstFileW__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = FindFirstFileW(x, arg2);
}

void test__FindFirstFileW__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindFirstFileW(arg1, p);
}

void test__FindFirstFileA__noreturn() {
  int x = 1;
  if (cond) { x=100; result = FindFirstFileA(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FindFirstFileA__useretval() {
  // cppcheck-suppress ignoredReturnValue
  FindFirstFileA(arg1, arg2);
}

void test__FindFirstFileA__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindFirstFileA(p, arg2);
}

void test__FindFirstFileA__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = FindFirstFileA(x, arg2);
}

void test__FindFirstFileA__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindFirstFileA(arg1, p);
}

void test__FindClose__noreturn() {
  int x = 1;
  if (cond) { x=100; FindClose(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FindClose__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  FindClose(p);
}

void test__FindClose__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  FindClose(x);
}

void test__CreateThread__noreturn() {
  int x = 1;
  if (cond) { x=100; result = CreateThread(arg1, arg2, arg3, arg4, arg5, arg6); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateThread__useretval() {
  // cppcheck-suppress ignoredReturnValue
  CreateThread(arg1, arg2, arg3, arg4, arg5, arg6);
}

void test__CreateThread__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateThread(x, arg2, arg3, arg4, arg5, arg6);
}

void test__CreateThread__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateThread(arg1, x, arg3, arg4, arg5, arg6);
}

void test__CreateThread__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateThread(arg1, arg2, x, arg4, arg5, arg6);
}

void test__CreateThread__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateThread(arg1, arg2, arg3, x, arg5, arg6);
}

void test__CreateThread__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = CreateThread(arg1, arg2, arg3, arg4, x, arg6);
}

void test__FindNextFile__noreturn() {
  int x = 1;
  if (cond) { x=100; result = FindNextFile(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FindNextFile__useretval() {
  // cppcheck-suppress ignoredReturnValue
  FindNextFile(arg1, arg2);
}

void test__FindNextFile__leakignore() {
  char *p = malloc(10); *p=0;
  result = FindNextFile(p, arg2);
  // cppcheck-suppress memleak
}

void test__FindNextFile__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindNextFile(p, arg2);
}

void test__FindNextFile__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = FindNextFile(x, arg2);
}

void test__FindNextFile__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindNextFile(arg1, p);
}

void test__FindNextFileW__noreturn() {
  int x = 1;
  if (cond) { x=100; result = FindNextFileW(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FindNextFileW__useretval() {
  // cppcheck-suppress ignoredReturnValue
  FindNextFileW(arg1, arg2);
}

void test__FindNextFileW__leakignore() {
  char *p = malloc(10); *p=0;
  result = FindNextFileW(p, arg2);
  // cppcheck-suppress memleak
}

void test__FindNextFileW__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindNextFileW(p, arg2);
}

void test__FindNextFileW__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = FindNextFileW(x, arg2);
}

void test__FindNextFileW__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindNextFileW(arg1, p);
}

void test__FindNextFileA__noreturn() {
  int x = 1;
  if (cond) { x=100; result = FindNextFileA(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FindNextFileA__useretval() {
  // cppcheck-suppress ignoredReturnValue
  FindNextFileA(arg1, arg2);
}

void test__FindNextFileA__leakignore() {
  char *p = malloc(10); *p=0;
  result = FindNextFileA(p, arg2);
  // cppcheck-suppress memleak
}

void test__FindNextFileA__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindNextFileA(p, arg2);
}

void test__FindNextFileA__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = FindNextFileA(x, arg2);
}

void test__FindNextFileA__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = FindNextFileA(arg1, p);
}

void test__SetEnvironmentVariable__noreturn() {
  int x = 1;
  if (cond) { x=100; SetEnvironmentVariable(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SetEnvironmentVariable__leakignore() {
  char *p = malloc(10); *p=0;
  SetEnvironmentVariable(p, arg2);
  // cppcheck-suppress memleak
}

void test__SetEnvironmentVariable__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetEnvironmentVariable(x, arg2);
}

void test__SetEnvironmentVariableW__noreturn() {
  int x = 1;
  if (cond) { x=100; SetEnvironmentVariableW(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SetEnvironmentVariableW__leakignore() {
  char *p = malloc(10); *p=0;
  SetEnvironmentVariableW(p, arg2);
  // cppcheck-suppress memleak
}

void test__SetEnvironmentVariableW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetEnvironmentVariableW(x, arg2);
}

void test__SetEnvironmentVariableA__noreturn() {
  int x = 1;
  if (cond) { x=100; SetEnvironmentVariableA(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SetEnvironmentVariableA__leakignore() {
  char *p = malloc(10); *p=0;
  SetEnvironmentVariableA(p, arg2);
  // cppcheck-suppress memleak
}

void test__SetEnvironmentVariableA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetEnvironmentVariableA(x, arg2);
}

void test__QueryDosDevice__noreturn() {
  int x = 1;
  if (cond) { x=100; result = QueryDosDevice(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__QueryDosDevice__useretval() {
  // cppcheck-suppress ignoredReturnValue
  QueryDosDevice(arg1, arg2, arg3);
}

void test__QueryDosDevice__leakignore() {
  char *p = malloc(10); *p=0;
  result = QueryDosDevice(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__QueryDosDevice__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = QueryDosDevice(x, arg2, arg3);
}

void test__QueryDosDevice__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = QueryDosDevice(arg1, arg2, x);
}

void test__QueryDosDeviceW__noreturn() {
  int x = 1;
  if (cond) { x=100; result = QueryDosDeviceW(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__QueryDosDeviceW__useretval() {
  // cppcheck-suppress ignoredReturnValue
  QueryDosDeviceW(arg1, arg2, arg3);
}

void test__QueryDosDeviceW__leakignore() {
  char *p = malloc(10); *p=0;
  result = QueryDosDeviceW(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__QueryDosDeviceW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = QueryDosDeviceW(x, arg2, arg3);
}

void test__QueryDosDeviceW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = QueryDosDeviceW(arg1, arg2, x);
}

void test__QueryDosDeviceA__noreturn() {
  int x = 1;
  if (cond) { x=100; result = QueryDosDeviceA(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__QueryDosDeviceA__useretval() {
  // cppcheck-suppress ignoredReturnValue
  QueryDosDeviceA(arg1, arg2, arg3);
}

void test__QueryDosDeviceA__leakignore() {
  char *p = malloc(10); *p=0;
  result = QueryDosDeviceA(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__QueryDosDeviceA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = QueryDosDeviceA(x, arg2, arg3);
}

void test__QueryDosDeviceA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = QueryDosDeviceA(arg1, arg2, x);
}

void test__GetDefaultCommConfig__noreturn() {
  int x = 1;
  if (cond) { x=100; result = GetDefaultCommConfig(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetDefaultCommConfig__useretval() {
  // cppcheck-suppress ignoredReturnValue
  GetDefaultCommConfig(arg1, arg2, arg3);
}

void test__GetDefaultCommConfig__leakignore() {
  char *p = malloc(10); *p=0;
  result = GetDefaultCommConfig(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__GetDefaultCommConfig__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = GetDefaultCommConfig(x, arg2, arg3);
}

void test__GetDefaultCommConfig__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = GetDefaultCommConfig(arg1, p, arg3);
}

void test__GetDefaultCommConfigW__noreturn() {
  int x = 1;
  if (cond) { x=100; result = GetDefaultCommConfigW(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetDefaultCommConfigW__useretval() {
  // cppcheck-suppress ignoredReturnValue
  GetDefaultCommConfigW(arg1, arg2, arg3);
}

void test__GetDefaultCommConfigW__leakignore() {
  char *p = malloc(10); *p=0;
  result = GetDefaultCommConfigW(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__GetDefaultCommConfigW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = GetDefaultCommConfigW(x, arg2, arg3);
}

void test__GetDefaultCommConfigW__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = GetDefaultCommConfigW(arg1, p, arg3);
}

void test__GetDefaultCommConfigA__noreturn() {
  int x = 1;
  if (cond) { x=100; result = GetDefaultCommConfigA(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetDefaultCommConfigA__useretval() {
  // cppcheck-suppress ignoredReturnValue
  GetDefaultCommConfigA(arg1, arg2, arg3);
}

void test__GetDefaultCommConfigA__leakignore() {
  char *p = malloc(10); *p=0;
  result = GetDefaultCommConfigA(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__GetDefaultCommConfigA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = GetDefaultCommConfigA(x, arg2, arg3);
}

void test__GetDefaultCommConfigA__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = GetDefaultCommConfigA(arg1, p, arg3);
}

void test__GetTempPath__noreturn() {
  int x = 1;
  if (cond) { x=100; GetTempPath(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetTempPath__leakignore() {
  char *p = malloc(10); *p=0;
  GetTempPath(p, arg2);
  // cppcheck-suppress memleak
}

void test__GetTempPath__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetTempPath(x, arg2);
}

void test__GetTempPathW__noreturn() {
  int x = 1;
  if (cond) { x=100; GetTempPathW(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetTempPathW__leakignore() {
  char *p = malloc(10); *p=0;
  GetTempPathW(p, arg2);
  // cppcheck-suppress memleak
}

void test__GetTempPathW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetTempPathW(x, arg2);
}

void test__GetTempPathA__noreturn() {
  int x = 1;
  if (cond) { x=100; GetTempPathA(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetTempPathA__leakignore() {
  char *p = malloc(10); *p=0;
  GetTempPathA(p, arg2);
  // cppcheck-suppress memleak
}

void test__GetTempPathA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetTempPathA(x, arg2);
}

void test__SetupDiDestroyDeviceInfoList__noreturn() {
  int x = 1;
  if (cond) { x=100; SetupDiDestroyDeviceInfoList(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SetupDiDestroyDeviceInfoList__leakignore() {
  char *p = malloc(10); *p=0;
  SetupDiDestroyDeviceInfoList(p);
  // cppcheck-suppress memleak
}

void test__SetupDiDestroyDeviceInfoList__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetupDiDestroyDeviceInfoList(x);
}

void test__SetupDiGetDeviceInstanceId__noreturn() {
  int x = 1;
  if (cond) { x=100; SetupDiGetDeviceInstanceId(arg1, arg2, arg3, arg4, arg5); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SetupDiGetDeviceInstanceId__leakignore() {
  char *p = malloc(10); *p=0;
  SetupDiGetDeviceInstanceId(p, arg2, arg3, arg4, arg5);
  // cppcheck-suppress memleak
}

void test__SetupDiGetDeviceInstanceId__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetupDiGetDeviceInstanceId(x, arg2, arg3, arg4, arg5);
}

void test__SetupDiGetDeviceInstanceId__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetupDiGetDeviceInstanceId(arg1, x, arg3, arg4, arg5);
}

void test__SetupDiGetDeviceInstanceId__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetupDiGetDeviceInstanceId(arg1, arg2, arg3, x, arg5);
}

void test__SetupDiEnumDeviceInfo__noreturn() {
  int x = 1;
  if (cond) { x=100; SetupDiEnumDeviceInfo(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SetupDiEnumDeviceInfo__leakignore() {
  char *p = malloc(10); *p=0;
  SetupDiEnumDeviceInfo(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__SetupDiEnumDeviceInfo__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetupDiEnumDeviceInfo(x, arg2, arg3);
}

void test__SetupDiEnumDeviceInfo__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetupDiEnumDeviceInfo(arg1, x, arg3);
}

void test__SetupDiGetClassDevs__noreturn() {
  int x = 1;
  if (cond) { x=100; SetupDiGetClassDevs(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SetupDiGetClassDevs__leakignore() {
  char *p = malloc(10); *p=0;
  SetupDiGetClassDevs(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__SetupDiGetClassDevs__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetupDiGetClassDevs(arg1, x, arg3, arg4);
}

void test__SetupDiGetClassDevs__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetupDiGetClassDevs(arg1, arg2, x, arg4);
}

void test__SetupDiGetClassDevs__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetupDiGetClassDevs(arg1, arg2, arg3, x);
}

void test___mbsstr__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _mbsstr(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___mbsstr__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _mbsstr(arg1, arg2);
}

void test___mbsstr__leakignore() {
  char *p = malloc(10); *p=0;
  result = _mbsstr(p, arg2);
  // cppcheck-suppress memleak
}

void test___mbsstr__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _mbsstr(p, arg2);
}

void test___mbsstr__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _mbsstr(x, arg2);
}

void test___mbsstr__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _mbsstr(arg1, p);
}

void test___mbsstr__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _mbsstr(arg1, x);
}

void test___tcsstr__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _tcsstr(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tcsstr__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _tcsstr(arg1, arg2);
}

void test___tcsstr__leakignore() {
  char *p = malloc(10); *p=0;
  result = _tcsstr(p, arg2);
  // cppcheck-suppress memleak
}

void test___tcsstr__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tcsstr(p, arg2);
}

void test___tcsstr__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tcsstr(x, arg2);
}

void test___tcsstr__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tcsstr(arg1, p);
}

void test___tcsstr__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tcsstr(arg1, x);
}

void test___mbsstr_l__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _mbsstr_l(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___mbsstr_l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _mbsstr_l(arg1, arg2, arg3);
}

void test___mbsstr_l__leakignore() {
  char *p = malloc(10); *p=0;
  result = _mbsstr_l(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test___mbsstr_l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _mbsstr_l(p, arg2, arg3);
}

void test___mbsstr_l__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _mbsstr_l(x, arg2, arg3);
}

void test___mbsstr_l__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _mbsstr_l(arg1, p, arg3);
}

void test___mbsstr_l__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _mbsstr_l(arg1, x, arg3);
}

void test___mbsstr_l__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _mbsstr_l(arg1, arg2, x);
}

void test___memccpy__noreturn() {
  int x = 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___fcloseall__noreturn() {
  int x = 1;
  if (cond) { x=100; _fcloseall(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___open__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _open(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___open__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _open(arg1, arg2, arg3);
}

void test___open__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _open(p, arg2, arg3);
}

void test___open__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _open(x, arg2, arg3);
}

void test___open__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _open(arg1, x, arg3);
}

void test___open__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _open(arg1, arg2, x);
}

void test___wopen__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _wopen(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___wopen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _wopen(arg1, arg2, arg3);
}

void test___wopen__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _wopen(p, arg2, arg3);
}

void test___wopen__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _wopen(x, arg2, arg3);
}

void test___wopen__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _wopen(arg1, x, arg3);
}

void test___wopen__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _wopen(arg1, arg2, x);
}

void test___topen__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _topen(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___topen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _topen(arg1, arg2, arg3);
}

void test___topen__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _topen(p, arg2, arg3);
}

void test___topen__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _topen(x, arg2, arg3);
}

void test___topen__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _topen(arg1, x, arg3);
}

void test___topen__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _topen(arg1, arg2, x);
}

void test___close__noreturn() {
  int x = 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___swab__noreturn() {
  int x = 1;
  if (cond) { x=100; _swab(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___swab__leakignore() {
  char *p = malloc(10); *p=0;
  _swab(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test___swab__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _swab(p, arg2, arg3);
}

void test___swab__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _swab(arg1, p, arg3);
}

void test___swab__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _swab(arg1, x, arg3);
}

void test___swab__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  _swab(arg1, arg2, !x);
}

void test___swab__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _swab(arg1, arg2, x);
}

void test___strnicmp__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _strnicmp(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___strnicmp__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _strnicmp(arg1, arg2, arg3);
}

void test___strnicmp__leakignore() {
  char *p = malloc(10); *p=0;
  result = _strnicmp(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test___strnicmp__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _strnicmp(p, arg2, arg3);
}

void test___strnicmp__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _strnicmp(x, arg2, arg3);
}

void test___strnicmp__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _strnicmp(arg1, p, arg3);
}

void test___strnicmp__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _strnicmp(arg1, x, arg3);
}

void test___strnicmp__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  result = _strnicmp(arg1, arg2, !x);
}

void test___strnicmp__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _strnicmp(arg1, arg2, x);
}

void test___wcsnicmp__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _wcsnicmp(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___wcsnicmp__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _wcsnicmp(arg1, arg2, arg3);
}

void test___wcsnicmp__leakignore() {
  char *p = malloc(10); *p=0;
  result = _wcsnicmp(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test___wcsnicmp__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _wcsnicmp(p, arg2, arg3);
}

void test___wcsnicmp__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _wcsnicmp(x, arg2, arg3);
}

void test___wcsnicmp__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _wcsnicmp(arg1, p, arg3);
}

void test___wcsnicmp__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _wcsnicmp(arg1, x, arg3);
}

void test___wcsnicmp__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  result = _wcsnicmp(arg1, arg2, !x);
}

void test___wcsnicmp__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _wcsnicmp(arg1, arg2, x);
}

void test___mbsnicmp__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _mbsnicmp(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___mbsnicmp__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _mbsnicmp(arg1, arg2, arg3);
}

void test___mbsnicmp__leakignore() {
  char *p = malloc(10); *p=0;
  result = _mbsnicmp(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test___mbsnicmp__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _mbsnicmp(p, arg2, arg3);
}

void test___mbsnicmp__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _mbsnicmp(x, arg2, arg3);
}

void test___mbsnicmp__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _mbsnicmp(arg1, p, arg3);
}

void test___mbsnicmp__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _mbsnicmp(arg1, x, arg3);
}

void test___mbsnicmp__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  result = _mbsnicmp(arg1, arg2, !x);
}

void test___mbsnicmp__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _mbsnicmp(arg1, arg2, x);
}

void test___tcsncicmp__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _tcsncicmp(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tcsncicmp__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _tcsncicmp(arg1, arg2, arg3);
}

void test___tcsncicmp__leakignore() {
  char *p = malloc(10); *p=0;
  result = _tcsncicmp(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test___tcsncicmp__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tcsncicmp(p, arg2, arg3);
}

void test___tcsncicmp__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tcsncicmp(x, arg2, arg3);
}

void test___tcsncicmp__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tcsncicmp(arg1, p, arg3);
}

void test___tcsncicmp__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tcsncicmp(arg1, x, arg3);
}

void test___tcsncicmp__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  result = _tcsncicmp(arg1, arg2, !x);
}

void test___tcsncicmp__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _tcsncicmp(arg1, arg2, x);
}

void test___tcsnicmp__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _tcsnicmp(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tcsnicmp__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _tcsnicmp(arg1, arg2, arg3);
}

void test___tcsnicmp__leakignore() {
  char *p = malloc(10); *p=0;
  result = _tcsnicmp(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test___tcsnicmp__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tcsnicmp(p, arg2, arg3);
}

void test___tcsnicmp__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tcsnicmp(x, arg2, arg3);
}

void test___tcsnicmp__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tcsnicmp(arg1, p, arg3);
}

void test___tcsnicmp__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tcsnicmp(arg1, x, arg3);
}

void test___tcsnicmp__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  result = _tcsnicmp(arg1, arg2, !x);
}

void test___tcsnicmp__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _tcsnicmp(arg1, arg2, x);
}

void test___strnicmp_l__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _strnicmp_l(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___strnicmp_l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _strnicmp_l(arg1, arg2, arg3, arg4);
}

void test___strnicmp_l__leakignore() {
  char *p = malloc(10); *p=0;
  result = _strnicmp_l(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test___strnicmp_l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _strnicmp_l(p, arg2, arg3, arg4);
}

void test___strnicmp_l__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _strnicmp_l(x, arg2, arg3, arg4);
}

void test___strnicmp_l__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _strnicmp_l(arg1, p, arg3, arg4);
}

void test___strnicmp_l__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _strnicmp_l(arg1, x, arg3, arg4);
}

void test___strnicmp_l__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  result = _strnicmp_l(arg1, arg2, !x, arg4);
}

void test___strnicmp_l__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _strnicmp_l(arg1, arg2, x, arg4);
}

void test___strnicmp_l__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _strnicmp_l(arg1, arg2, arg3, x);
}

void test___wcsnicmp_l__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _wcsnicmp_l(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___wcsnicmp_l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _wcsnicmp_l(arg1, arg2, arg3, arg4);
}

void test___wcsnicmp_l__leakignore() {
  char *p = malloc(10); *p=0;
  result = _wcsnicmp_l(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test___wcsnicmp_l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _wcsnicmp_l(p, arg2, arg3, arg4);
}

void test___wcsnicmp_l__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _wcsnicmp_l(x, arg2, arg3, arg4);
}

void test___wcsnicmp_l__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _wcsnicmp_l(arg1, p, arg3, arg4);
}

void test___wcsnicmp_l__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _wcsnicmp_l(arg1, x, arg3, arg4);
}

void test___wcsnicmp_l__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  result = _wcsnicmp_l(arg1, arg2, !x, arg4);
}

void test___wcsnicmp_l__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _wcsnicmp_l(arg1, arg2, x, arg4);
}

void test___wcsnicmp_l__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _wcsnicmp_l(arg1, arg2, arg3, x);
}

void test___mbsnicmp_l__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _mbsnicmp_l(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___mbsnicmp_l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _mbsnicmp_l(arg1, arg2, arg3, arg4);
}

void test___mbsnicmp_l__leakignore() {
  char *p = malloc(10); *p=0;
  result = _mbsnicmp_l(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test___mbsnicmp_l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _mbsnicmp_l(p, arg2, arg3, arg4);
}

void test___mbsnicmp_l__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _mbsnicmp_l(x, arg2, arg3, arg4);
}

void test___mbsnicmp_l__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _mbsnicmp_l(arg1, p, arg3, arg4);
}

void test___mbsnicmp_l__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _mbsnicmp_l(arg1, x, arg3, arg4);
}

void test___mbsnicmp_l__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  result = _mbsnicmp_l(arg1, arg2, !x, arg4);
}

void test___mbsnicmp_l__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _mbsnicmp_l(arg1, arg2, x, arg4);
}

void test___mbsnicmp_l__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _mbsnicmp_l(arg1, arg2, arg3, x);
}

void test___tcsncicmp_l__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _tcsncicmp_l(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tcsncicmp_l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _tcsncicmp_l(arg1, arg2, arg3, arg4);
}

void test___tcsncicmp_l__leakignore() {
  char *p = malloc(10); *p=0;
  result = _tcsncicmp_l(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test___tcsncicmp_l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tcsncicmp_l(p, arg2, arg3, arg4);
}

void test___tcsncicmp_l__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tcsncicmp_l(x, arg2, arg3, arg4);
}

void test___tcsncicmp_l__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tcsncicmp_l(arg1, p, arg3, arg4);
}

void test___tcsncicmp_l__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tcsncicmp_l(arg1, x, arg3, arg4);
}

void test___tcsncicmp_l__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  result = _tcsncicmp_l(arg1, arg2, !x, arg4);
}

void test___tcsncicmp_l__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _tcsncicmp_l(arg1, arg2, x, arg4);
}

void test___tcsncicmp_l__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _tcsncicmp_l(arg1, arg2, arg3, x);
}

void test___malloc_dbg__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _malloc_dbg(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___malloc_dbg__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _malloc_dbg(arg1, arg2, arg3, arg4);
}

void test___malloc_dbg__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _malloc_dbg(x, arg2, arg3, arg4);
}

void test___malloc_dbg__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _malloc_dbg(arg1, x, arg3, arg4);
}

void test___malloc_dbg__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _malloc_dbg(arg1, arg2, x, arg4);
}

void test___malloc_dbg__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _malloc_dbg(arg1, arg2, arg3, x);
}

void test___aligned_malloc_dbg__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _aligned_malloc_dbg(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___aligned_malloc_dbg__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _aligned_malloc_dbg(arg1, arg2, arg3, arg4);
}

void test___aligned_malloc_dbg__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _aligned_malloc_dbg(x, arg2, arg3, arg4);
}

void test___aligned_malloc_dbg__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _aligned_malloc_dbg(arg1, x, arg3, arg4);
}

void test___aligned_malloc_dbg__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _aligned_malloc_dbg(arg1, arg2, x, arg4);
}

void test___aligned_malloc_dbg__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _aligned_malloc_dbg(arg1, arg2, arg3, x);
}

void test___aligned_malloc__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _aligned_malloc(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___aligned_malloc__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _aligned_malloc(arg1, arg2);
}

void test___aligned_malloc__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _aligned_malloc(x, arg2);
}

void test___aligned_malloc__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _aligned_malloc(arg1, x);
}

void test___mbslen_l__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _mbslen_l(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___mbslen_l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _mbslen_l(arg1, arg2);
}

void test___mbslen_l__pure(int arg1,int arg2) {
  // cppcheck-suppress incorrectLogicOperator
  if ((_mbslen_l(arg1, arg2) > 10) || (_mbslen_l(arg1, arg2) < 100)) {}
}

void test___mbslen_l__leakignore() {
  char *p = malloc(10); *p=0;
  result = _mbslen_l(p, arg2);
  // cppcheck-suppress memleak
}

void test___mbslen_l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _mbslen_l(p, arg2);
}

void test___mbslen_l__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _mbslen_l(x, arg2);
}

void test___mbslen_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _mbslen_l(arg1, x);
}

void test___mbstrlen_l__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _mbstrlen_l(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___mbstrlen_l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _mbstrlen_l(arg1, arg2);
}

void test___mbstrlen_l__pure(int arg1,int arg2) {
  // cppcheck-suppress incorrectLogicOperator
  if ((_mbstrlen_l(arg1, arg2) > 10) || (_mbstrlen_l(arg1, arg2) < 100)) {}
}

void test___mbstrlen_l__leakignore() {
  char *p = malloc(10); *p=0;
  result = _mbstrlen_l(p, arg2);
  // cppcheck-suppress memleak
}

void test___mbstrlen_l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _mbstrlen_l(p, arg2);
}

void test___mbstrlen_l__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _mbstrlen_l(x, arg2);
}

void test___mbstrlen_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _mbstrlen_l(arg1, x);
}

void test___tcsclen_l__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _tcsclen_l(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tcsclen_l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _tcsclen_l(arg1, arg2);
}

void test___tcsclen_l__pure(int arg1,int arg2) {
  // cppcheck-suppress incorrectLogicOperator
  if ((_tcsclen_l(arg1, arg2) > 10) || (_tcsclen_l(arg1, arg2) < 100)) {}
}

void test___tcsclen_l__leakignore() {
  char *p = malloc(10); *p=0;
  result = _tcsclen_l(p, arg2);
  // cppcheck-suppress memleak
}

void test___tcsclen_l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tcsclen_l(p, arg2);
}

void test___tcsclen_l__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tcsclen_l(x, arg2);
}

void test___tcsclen_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _tcsclen_l(arg1, x);
}

void test___mbslen__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _mbslen(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___mbslen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _mbslen(arg1);
}

void test___mbslen__pure(int arg1) {
  // cppcheck-suppress incorrectLogicOperator
  if ((_mbslen(arg1) > 10) || (_mbslen(arg1) < 100)) {}
}

void test___mbslen__leakignore() {
  char *p = malloc(10); *p=0;
  result = _mbslen(p);
  // cppcheck-suppress memleak
}

void test___mbslen__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _mbslen(p);
}

void test___mbslen__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _mbslen(x);
}

void test___mbstrlen__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _mbstrlen(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___mbstrlen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _mbstrlen(arg1);
}

void test___mbstrlen__pure(int arg1) {
  // cppcheck-suppress incorrectLogicOperator
  if ((_mbstrlen(arg1) > 10) || (_mbstrlen(arg1) < 100)) {}
}

void test___mbstrlen__leakignore() {
  char *p = malloc(10); *p=0;
  result = _mbstrlen(p);
  // cppcheck-suppress memleak
}

void test___mbstrlen__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _mbstrlen(p);
}

void test___mbstrlen__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _mbstrlen(x);
}

void test___tcslen__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _tcslen(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tcslen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _tcslen(arg1);
}

void test___tcslen__pure(int arg1) {
  // cppcheck-suppress incorrectLogicOperator
  if ((_tcslen(arg1) > 10) || (_tcslen(arg1) < 100)) {}
}

void test___tcslen__leakignore() {
  char *p = malloc(10); *p=0;
  result = _tcslen(p);
  // cppcheck-suppress memleak
}

void test___tcslen__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tcslen(p);
}

void test___tcslen__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tcslen(x);
}

void test___tcsclen__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _tcsclen(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tcsclen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _tcsclen(arg1);
}

void test___tcsclen__pure(int arg1) {
  // cppcheck-suppress incorrectLogicOperator
  if ((_tcsclen(arg1) > 10) || (_tcsclen(arg1) < 100)) {}
}

void test___tcsclen__leakignore() {
  char *p = malloc(10); *p=0;
  result = _tcsclen(p);
  // cppcheck-suppress memleak
}

void test___tcsclen__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tcsclen(p);
}

void test___tcsclen__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tcsclen(x);
}

void test___mbsrchr_l__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _mbsrchr_l(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___mbsrchr_l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _mbsrchr_l(arg1, arg2, arg3);
}

void test___mbsrchr_l__leakignore() {
  char *p = malloc(10); *p=0;
  result = _mbsrchr_l(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test___mbsrchr_l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _mbsrchr_l(p, arg2, arg3);
}

void test___mbsrchr_l__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _mbsrchr_l(x, arg2, arg3);
}

void test___mbsrchr_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _mbsrchr_l(arg1, x, arg3);
}

void test___mbsrchr_l__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _mbsrchr_l(arg1, arg2, x);
}

void test___mbsrchr__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _mbsrchr(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___mbsrchr__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _mbsrchr(arg1, arg2);
}

void test___mbsrchr__leakignore() {
  char *p = malloc(10); *p=0;
  result = _mbsrchr(p, arg2);
  // cppcheck-suppress memleak
}

void test___mbsrchr__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _mbsrchr(p, arg2);
}

void test___mbsrchr__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _mbsrchr(x, arg2);
}

void test___mbsrchr__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _mbsrchr(arg1, x);
}

void test___tcsrchr__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _tcsrchr(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tcsrchr__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _tcsrchr(arg1, arg2);
}

void test___tcsrchr__leakignore() {
  char *p = malloc(10); *p=0;
  result = _tcsrchr(p, arg2);
  // cppcheck-suppress memleak
}

void test___tcsrchr__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tcsrchr(p, arg2);
}

void test___tcsrchr__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tcsrchr(x, arg2);
}

void test___tcsrchr__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _tcsrchr(arg1, x);
}

void test___strftime_l__noreturn() {
  int x = 1;
  if (cond) { x=100; _strftime_l(arg1, arg2, arg3, arg4, arg5); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___strftime_l__leakignore() {
  char *p = malloc(10); *p=0;
  _strftime_l(p, arg2, arg3, arg4, arg5);
  // cppcheck-suppress memleak
}

void test___strftime_l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _strftime_l(p, arg2, arg3, arg4, arg5);
}

void test___strftime_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _strftime_l(arg1, x, arg3, arg4, arg5);
}

void test___strftime_l__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _strftime_l(arg1, arg2, p, arg4, arg5);
}

void test___strftime_l__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _strftime_l(arg1, arg2, x, arg4, arg5);
}

void test___strftime_l__arg4__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _strftime_l(arg1, arg2, arg3, p, arg5);
}

void test___strftime_l__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _strftime_l(arg1, arg2, arg3, x, arg5);
}

void test___strftime_l__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _strftime_l(arg1, arg2, arg3, arg4, x);
}

void test___wcsftime_l__noreturn() {
  int x = 1;
  if (cond) { x=100; _wcsftime_l(arg1, arg2, arg3, arg4, arg5); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___wcsftime_l__leakignore() {
  char *p = malloc(10); *p=0;
  _wcsftime_l(p, arg2, arg3, arg4, arg5);
  // cppcheck-suppress memleak
}

void test___wcsftime_l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _wcsftime_l(p, arg2, arg3, arg4, arg5);
}

void test___wcsftime_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _wcsftime_l(arg1, x, arg3, arg4, arg5);
}

void test___wcsftime_l__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _wcsftime_l(arg1, arg2, p, arg4, arg5);
}

void test___wcsftime_l__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _wcsftime_l(arg1, arg2, x, arg4, arg5);
}

void test___wcsftime_l__arg4__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _wcsftime_l(arg1, arg2, arg3, p, arg5);
}

void test___wcsftime_l__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _wcsftime_l(arg1, arg2, arg3, x, arg5);
}

void test___wcsftime_l__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _wcsftime_l(arg1, arg2, arg3, arg4, x);
}

void test___tcsftime__noreturn() {
  int x = 1;
  if (cond) { x=100; _tcsftime(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tcsftime__leakignore() {
  char *p = malloc(10); *p=0;
  _tcsftime(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test___tcsftime__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _tcsftime(p, arg2, arg3, arg4);
}

void test___tcsftime__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _tcsftime(arg1, x, arg3, arg4);
}

void test___tcsftime__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _tcsftime(arg1, arg2, p, arg4);
}

void test___tcsftime__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _tcsftime(arg1, arg2, x, arg4);
}

void test___tcsftime__arg4__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _tcsftime(arg1, arg2, arg3, p);
}

void test___tcsftime__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _tcsftime(arg1, arg2, arg3, x);
}

void test___wfreopen_s__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _wfreopen_s(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___wfreopen_s__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _wfreopen_s(arg1, arg2, arg3, arg4);
}

void test___wfreopen_s__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _wfreopen_s(x, arg2, arg3, arg4);
}

void test___wfreopen_s__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _wfreopen_s(arg1, x, arg3, arg4);
}

void test___wfreopen_s__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _wfreopen_s(arg1, arg2, p, arg4);
}

void test___wfreopen_s__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _wfreopen_s(arg1, arg2, x, arg4);
}

void test___wfreopen_s__arg4__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _wfreopen_s(arg1, arg2, arg3, p);
}

void test___wfreopen_s__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _wfreopen_s(arg1, arg2, arg3, x);
}

void test___tfreopen_s__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _tfreopen_s(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tfreopen_s__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _tfreopen_s(arg1, arg2, arg3, arg4);
}

void test___tfreopen_s__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _tfreopen_s(x, arg2, arg3, arg4);
}

void test___tfreopen_s__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _tfreopen_s(arg1, x, arg3, arg4);
}

void test___tfreopen_s__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tfreopen_s(arg1, arg2, p, arg4);
}

void test___tfreopen_s__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tfreopen_s(arg1, arg2, x, arg4);
}

void test___tfreopen_s__arg4__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tfreopen_s(arg1, arg2, arg3, p);
}

void test___tfreopen_s__arg4__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tfreopen_s(arg1, arg2, arg3, x);
}

void test___wfreopen__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _wfreopen(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___wfreopen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _wfreopen(arg1, arg2, arg3);
}

void test___wfreopen__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _wfreopen(x, arg2, arg3);
}

void test___wfreopen__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _wfreopen(arg1, p, arg3);
}

void test___wfreopen__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _wfreopen(arg1, x, arg3);
}

void test___wfreopen__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _wfreopen(arg1, arg2, p);
}

void test___wfreopen__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _wfreopen(arg1, arg2, x);
}

void test___tfreopen__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _tfreopen(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tfreopen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _tfreopen(arg1, arg2, arg3);
}

void test___tfreopen__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _tfreopen(x, arg2, arg3);
}

void test___tfreopen__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tfreopen(arg1, p, arg3);
}

void test___tfreopen__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tfreopen(arg1, x, arg3);
}

void test___tfreopen__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _tfreopen(arg1, arg2, p);
}

void test___tfreopen__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _tfreopen(arg1, arg2, x);
}

void test___mbsncpy__noreturn() {
  int x = 1;
  if (cond) { x=100; _mbsncpy(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___mbsncpy__leakignore() {
  char *p = malloc(10); *p=0;
  _mbsncpy(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test___mbsncpy__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _mbsncpy(p, arg2, arg3);
}

void test___mbsncpy__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _mbsncpy(arg1, p, arg3);
}

void test___mbsncpy__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _mbsncpy(arg1, x, arg3);
}

void test___mbsncpy__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  _mbsncpy(arg1, arg2, !x);
}

void test___mbsncpy__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _mbsncpy(arg1, arg2, x);
}

void test___mbsnbcpy__noreturn() {
  int x = 1;
  if (cond) { x=100; _mbsnbcpy(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___mbsnbcpy__leakignore() {
  char *p = malloc(10); *p=0;
  _mbsnbcpy(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test___mbsnbcpy__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _mbsnbcpy(p, arg2, arg3);
}

void test___mbsnbcpy__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _mbsnbcpy(arg1, p, arg3);
}

void test___mbsnbcpy__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _mbsnbcpy(arg1, x, arg3);
}

void test___mbsnbcpy__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  _mbsnbcpy(arg1, arg2, !x);
}

void test___mbsnbcpy__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _mbsnbcpy(arg1, arg2, x);
}

void test___tcsncpy__noreturn() {
  int x = 1;
  if (cond) { x=100; _tcsncpy(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tcsncpy__leakignore() {
  char *p = malloc(10); *p=0;
  _tcsncpy(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test___tcsncpy__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _tcsncpy(p, arg2, arg3);
}

void test___tcsncpy__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _tcsncpy(arg1, p, arg3);
}

void test___tcsncpy__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _tcsncpy(arg1, x, arg3);
}

void test___tcsncpy__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  _tcsncpy(arg1, arg2, !x);
}

void test___tcsncpy__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _tcsncpy(arg1, arg2, x);
}

void test___strncpy_l__noreturn() {
  int x = 1;
  if (cond) { x=100; _strncpy_l(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___strncpy_l__leakignore() {
  char *p = malloc(10); *p=0;
  _strncpy_l(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test___strncpy_l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _strncpy_l(p, arg2, arg3, arg4);
}

void test___strncpy_l__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _strncpy_l(arg1, p, arg3, arg4);
}

void test___strncpy_l__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _strncpy_l(arg1, x, arg3, arg4);
}

void test___strncpy_l__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  _strncpy_l(arg1, arg2, !x, arg4);
}

void test___strncpy_l__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _strncpy_l(arg1, arg2, x, arg4);
}

void test___strncpy_l__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _strncpy_l(arg1, arg2, arg3, x);
}

void test___wcsncpy_l__noreturn() {
  int x = 1;
  if (cond) { x=100; _wcsncpy_l(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___wcsncpy_l__leakignore() {
  char *p = malloc(10); *p=0;
  _wcsncpy_l(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test___wcsncpy_l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _wcsncpy_l(p, arg2, arg3, arg4);
}

void test___wcsncpy_l__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _wcsncpy_l(arg1, p, arg3, arg4);
}

void test___wcsncpy_l__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _wcsncpy_l(arg1, x, arg3, arg4);
}

void test___wcsncpy_l__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  _wcsncpy_l(arg1, arg2, !x, arg4);
}

void test___wcsncpy_l__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _wcsncpy_l(arg1, arg2, x, arg4);
}

void test___wcsncpy_l__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _wcsncpy_l(arg1, arg2, arg3, x);
}

void test___mbsncpy_l__noreturn() {
  int x = 1;
  if (cond) { x=100; _mbsncpy_l(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___mbsncpy_l__leakignore() {
  char *p = malloc(10); *p=0;
  _mbsncpy_l(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test___mbsncpy_l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _mbsncpy_l(p, arg2, arg3, arg4);
}

void test___mbsncpy_l__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _mbsncpy_l(arg1, p, arg3, arg4);
}

void test___mbsncpy_l__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _mbsncpy_l(arg1, x, arg3, arg4);
}

void test___mbsncpy_l__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  _mbsncpy_l(arg1, arg2, !x, arg4);
}

void test___mbsncpy_l__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _mbsncpy_l(arg1, arg2, x, arg4);
}

void test___mbsncpy_l__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _mbsncpy_l(arg1, arg2, arg3, x);
}

void test___tcsncpy_l__noreturn() {
  int x = 1;
  if (cond) { x=100; _tcsncpy_l(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tcsncpy_l__leakignore() {
  char *p = malloc(10); *p=0;
  _tcsncpy_l(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test___tcsncpy_l__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _tcsncpy_l(p, arg2, arg3, arg4);
}

void test___tcsncpy_l__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _tcsncpy_l(arg1, p, arg3, arg4);
}

void test___tcsncpy_l__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  _tcsncpy_l(arg1, x, arg3, arg4);
}

void test___tcsncpy_l__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  _tcsncpy_l(arg1, arg2, !x, arg4);
}

void test___tcsncpy_l__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _tcsncpy_l(arg1, arg2, x, arg4);
}

void test___tcsncpy_l__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _tcsncpy_l(arg1, arg2, arg3, x);
}

void test___localtime32_s__noreturn() {
  int x = 1;
  if (cond) { x=100; _localtime32_s(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___localtime32_s__leakignore() {
  char *p = malloc(10); *p=0;
  _localtime32_s(p, arg2);
  // cppcheck-suppress memleak
}

void test___localtime32_s__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _localtime32_s(p, arg2);
}

void test___localtime32_s__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _localtime32_s(arg1, p);
}

void test___localtime64_s__noreturn() {
  int x = 1;
  if (cond) { x=100; _localtime64_s(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___localtime64_s__leakignore() {
  char *p = malloc(10); *p=0;
  _localtime64_s(p, arg2);
  // cppcheck-suppress memleak
}

void test___localtime64_s__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _localtime64_s(p, arg2);
}

void test___localtime64_s__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  _localtime64_s(arg1, p);
}

void test__CreateDirectory__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateDirectory(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateDirectory__leakignore() {
  char *p = malloc(10); *p=0;
  CreateDirectory(p, arg2);
  // cppcheck-suppress memleak
}

void test__CreateDirectory__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateDirectory(x, arg2);
}

void test__CreateDirectory__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateDirectory(arg1, x);
}

void test__CreateDirectoryA__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateDirectoryA(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateDirectoryA__leakignore() {
  char *p = malloc(10); *p=0;
  CreateDirectoryA(p, arg2);
  // cppcheck-suppress memleak
}

void test__CreateDirectoryA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateDirectoryA(x, arg2);
}

void test__CreateDirectoryA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateDirectoryA(arg1, x);
}

void test__CreateDirectoryW__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateDirectoryW(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateDirectoryW__leakignore() {
  char *p = malloc(10); *p=0;
  CreateDirectoryW(p, arg2);
  // cppcheck-suppress memleak
}

void test__CreateDirectoryW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateDirectoryW(x, arg2);
}

void test__CreateDirectoryW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateDirectoryW(arg1, x);
}

void test__RemoveDirectory__noreturn() {
  int x = 1;
  if (cond) { x=100; RemoveDirectory(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__RemoveDirectory__leakignore() {
  char *p = malloc(10); *p=0;
  RemoveDirectory(p);
  // cppcheck-suppress memleak
}

void test__RemoveDirectory__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RemoveDirectory(x);
}

void test__RemoveDirectoryA__noreturn() {
  int x = 1;
  if (cond) { x=100; RemoveDirectoryA(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__RemoveDirectoryA__leakignore() {
  char *p = malloc(10); *p=0;
  RemoveDirectoryA(p);
  // cppcheck-suppress memleak
}

void test__RemoveDirectoryA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RemoveDirectoryA(x);
}

void test__RemoveDirectoryW__noreturn() {
  int x = 1;
  if (cond) { x=100; RemoveDirectoryW(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__RemoveDirectoryW__leakignore() {
  char *p = malloc(10); *p=0;
  RemoveDirectoryW(p);
  // cppcheck-suppress memleak
}

void test__RemoveDirectoryW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  RemoveDirectoryW(x);
}

void test____isascii__noreturn() {
  int x = 1;
  if (cond) { x=100; __isascii(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test____isascii__leakignore() {
  char *p = malloc(10); *p=0;
  __isascii(p);
  // cppcheck-suppress memleak
}

void test____isascii__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  __isascii(x);
}

void test__iswascii__noreturn() {
  int x = 1;
  if (cond) { x=100; iswascii(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__iswascii__leakignore() {
  char *p = malloc(10); *p=0;
  iswascii(p);
  // cppcheck-suppress memleak
}

void test__iswascii__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  iswascii(x);
}

void test___getchar__noreturn() {
  int x = 1;
  if (cond) { x=100; _getchar(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___getchar__leakignore() {
  char *p = malloc(10); *p=0;
  _getchar();
  // cppcheck-suppress memleak
}

void test___getch_nolock__noreturn() {
  int x = 1;
  if (cond) { x=100; _getch_nolock(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___getch_nolock__leakignore() {
  char *p = malloc(10); *p=0;
  _getch_nolock();
  // cppcheck-suppress memleak
}

void test___getwch__noreturn() {
  int x = 1;
  if (cond) { x=100; _getwch(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___getwch__leakignore() {
  char *p = malloc(10); *p=0;
  _getwch();
  // cppcheck-suppress memleak
}

void test___getwch_nolock__noreturn() {
  int x = 1;
  if (cond) { x=100; _getwch_nolock(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___getwch_nolock__leakignore() {
  char *p = malloc(10); *p=0;
  _getwch_nolock();
  // cppcheck-suppress memleak
}

void test__Sleep__noreturn() {
  int x = 1;
  if (cond) { x=100; Sleep(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__Sleep__leakignore() {
  char *p = malloc(10); *p=0;
  Sleep(p);
  // cppcheck-suppress memleak
}

void test__Sleep__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  Sleep(!x);
}

void test__Sleep__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  Sleep(x);
}

void test__SleepEx__noreturn() {
  int x = 1;
  if (cond) { x=100; SleepEx(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SleepEx__leakignore() {
  char *p = malloc(10); *p=0;
  SleepEx(p, arg2);
  // cppcheck-suppress memleak
}

void test__SleepEx__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  SleepEx(!x, arg2);
}

void test__SleepEx__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SleepEx(x, arg2);
}

void test__SleepEx__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SleepEx(arg1, x);
}

void test__LoadLibrary__noreturn() {
  int x = 1;
  if (cond) { x=100; LoadLibrary(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__LoadLibrary__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  LoadLibrary(p);
}

void test__LoadLibrary__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  LoadLibrary(x);
}

void test__LoadLibraryA__noreturn() {
  int x = 1;
  if (cond) { x=100; LoadLibraryA(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__LoadLibraryA__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  LoadLibraryA(p);
}

void test__LoadLibraryA__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  LoadLibraryA(x);
}

void test__LoadLibraryW__noreturn() {
  int x = 1;
  if (cond) { x=100; LoadLibraryW(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__LoadLibraryW__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  LoadLibraryW(p);
}

void test__LoadLibraryW__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  LoadLibraryW(x);
}

void test__LoadLibraryEx__noreturn() {
  int x = 1;
  if (cond) { x=100; LoadLibraryEx(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__LoadLibraryEx__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  LoadLibraryEx(x, arg2, arg3);
}

void test__LoadLibraryEx__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  LoadLibraryEx(arg1, arg2, x);
}

void test__LoadLibraryExA__noreturn() {
  int x = 1;
  if (cond) { x=100; LoadLibraryExA(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__LoadLibraryExA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  LoadLibraryExA(x, arg2, arg3);
}

void test__LoadLibraryExA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  LoadLibraryExA(arg1, arg2, x);
}

void test__LoadLibraryExW__noreturn() {
  int x = 1;
  if (cond) { x=100; LoadLibraryExW(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__LoadLibraryExW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  LoadLibraryExW(x, arg2, arg3);
}

void test__LoadLibraryExW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  LoadLibraryExW(arg1, arg2, x);
}

void test__GetModuleHandle__noreturn() {
  int x = 1;
  if (cond) { x=100; result = GetModuleHandle(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetModuleHandle__useretval() {
  // cppcheck-suppress ignoredReturnValue
  GetModuleHandle(arg1);
}

void test__GetModuleHandle__leakignore() {
  char *p = malloc(10); *p=0;
  result = GetModuleHandle(p);
  // cppcheck-suppress memleak
}

void test__GetModuleHandle__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = GetModuleHandle(x);
}

void test__GetModuleHandleA__noreturn() {
  int x = 1;
  if (cond) { x=100; result = GetModuleHandleA(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetModuleHandleA__useretval() {
  // cppcheck-suppress ignoredReturnValue
  GetModuleHandleA(arg1);
}

void test__GetModuleHandleA__leakignore() {
  char *p = malloc(10); *p=0;
  result = GetModuleHandleA(p);
  // cppcheck-suppress memleak
}

void test__GetModuleHandleA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = GetModuleHandleA(x);
}

void test__GetModuleHandleW__noreturn() {
  int x = 1;
  if (cond) { x=100; result = GetModuleHandleW(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetModuleHandleW__useretval() {
  // cppcheck-suppress ignoredReturnValue
  GetModuleHandleW(arg1);
}

void test__GetModuleHandleW__leakignore() {
  char *p = malloc(10); *p=0;
  result = GetModuleHandleW(p);
  // cppcheck-suppress memleak
}

void test__GetModuleHandleW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = GetModuleHandleW(x);
}

void test__GetModuleHandleEx__noreturn() {
  int x = 1;
  if (cond) { x=100; GetModuleHandleEx(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetModuleHandleEx__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetModuleHandleEx(x, arg2, arg3);
}

void test__GetModuleHandleEx__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetModuleHandleEx(arg1, x, arg3);
}

void test__GetModuleHandleEx__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetModuleHandleEx(arg1, arg2, p);
}

void test__GetModuleHandleExA__noreturn() {
  int x = 1;
  if (cond) { x=100; GetModuleHandleExA(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetModuleHandleExA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetModuleHandleExA(x, arg2, arg3);
}

void test__GetModuleHandleExA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetModuleHandleExA(arg1, x, arg3);
}

void test__GetModuleHandleExA__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetModuleHandleExA(arg1, arg2, p);
}

void test__GetModuleHandleExW__noreturn() {
  int x = 1;
  if (cond) { x=100; GetModuleHandleExW(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetModuleHandleExW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetModuleHandleExW(x, arg2, arg3);
}

void test__GetModuleHandleExW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetModuleHandleExW(arg1, x, arg3);
}

void test__GetModuleHandleExW__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetModuleHandleExW(arg1, arg2, p);
}

void test__FreeLibrary__noreturn() {
  int x = 1;
  if (cond) { x=100; FreeLibrary(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FreeLibrary__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  FreeLibrary(!x);
}

void test__FreeLibrary__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  FreeLibrary(x);
}

void test__FreeLibraryAndExitThread__noreturn() {
  int x = 1;
  if (cond) { x=100; FreeLibraryAndExitThread(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FreeLibraryAndExitThread__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  FreeLibraryAndExitThread(!x, arg2);
}

void test__FreeLibraryAndExitThread__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  FreeLibraryAndExitThread(x, arg2);
}

void test__FreeLibraryAndExitThread__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  FreeLibraryAndExitThread(arg1, !x);
}

void test__FreeLibraryAndExitThread__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  FreeLibraryAndExitThread(arg1, x);
}

void test__GetProcAddress__noreturn() {
  int x = 1;
  if (cond) { x=100; result = GetProcAddress(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetProcAddress__useretval() {
  // cppcheck-suppress ignoredReturnValue
  GetProcAddress(arg1, arg2);
}

void test__GetProcAddress__leakignore() {
  char *p = malloc(10); *p=0;
  result = GetProcAddress(p, arg2);
  // cppcheck-suppress memleak
}

void test__GetProcAddress__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  result = GetProcAddress(!x, arg2);
}

void test__GetProcAddress__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = GetProcAddress(p, arg2);
}

void test__GetProcAddress__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = GetProcAddress(x, arg2);
}

void test__GetProcAddress__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = GetProcAddress(arg1, x);
}

void test__CreateEvent__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateEvent(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateEvent__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEvent(!x, arg2, arg3, arg4);
}

void test__CreateEvent__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEvent(x, arg2, arg3, arg4);
}

void test__CreateEvent__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEvent(arg1, x, arg3, arg4);
}

void test__CreateEvent__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEvent(arg1, arg2, x, arg4);
}

void test__CreateEvent__arg4__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEvent(arg1, arg2, arg3, !x);
}

void test__CreateEvent__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEvent(arg1, arg2, arg3, x);
}

void test__CreateEventA__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateEventA(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateEventA__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventA(!x, arg2, arg3, arg4);
}

void test__CreateEventA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventA(x, arg2, arg3, arg4);
}

void test__CreateEventA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventA(arg1, x, arg3, arg4);
}

void test__CreateEventA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventA(arg1, arg2, x, arg4);
}

void test__CreateEventA__arg4__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventA(arg1, arg2, arg3, !x);
}

void test__CreateEventA__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventA(arg1, arg2, arg3, x);
}

void test__CreateEventW__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateEventW(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateEventW__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventW(!x, arg2, arg3, arg4);
}

void test__CreateEventW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventW(x, arg2, arg3, arg4);
}

void test__CreateEventW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventW(arg1, x, arg3, arg4);
}

void test__CreateEventW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventW(arg1, arg2, x, arg4);
}

void test__CreateEventW__arg4__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventW(arg1, arg2, arg3, !x);
}

void test__CreateEventW__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventW(arg1, arg2, arg3, x);
}

void test__CreateEventEx__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateEventEx(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateEventEx__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventEx(!x, arg2, arg3, arg4);
}

void test__CreateEventEx__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventEx(x, arg2, arg3, arg4);
}

void test__CreateEventEx__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventEx(arg1, !x, arg3, arg4);
}

void test__CreateEventEx__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventEx(arg1, x, arg3, arg4);
}

void test__CreateEventEx__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventEx(arg1, arg2, !x, arg4);
}

void test__CreateEventEx__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventEx(arg1, arg2, x, arg4);
}

void test__CreateEventEx__arg4__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventEx(arg1, arg2, arg3, !x);
}

void test__CreateEventEx__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventEx(arg1, arg2, arg3, x);
}

void test__CreateEventExA__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateEventExA(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateEventExA__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventExA(!x, arg2, arg3, arg4);
}

void test__CreateEventExA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventExA(x, arg2, arg3, arg4);
}

void test__CreateEventExA__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventExA(arg1, !x, arg3, arg4);
}

void test__CreateEventExA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventExA(arg1, x, arg3, arg4);
}

void test__CreateEventExA__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventExA(arg1, arg2, !x, arg4);
}

void test__CreateEventExA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventExA(arg1, arg2, x, arg4);
}

void test__CreateEventExA__arg4__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventExA(arg1, arg2, arg3, !x);
}

void test__CreateEventExA__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventExA(arg1, arg2, arg3, x);
}

void test__CreateEventExW__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateEventExW(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateEventExW__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventExW(!x, arg2, arg3, arg4);
}

void test__CreateEventExW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventExW(x, arg2, arg3, arg4);
}

void test__CreateEventExW__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventExW(arg1, !x, arg3, arg4);
}

void test__CreateEventExW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventExW(arg1, x, arg3, arg4);
}

void test__CreateEventExW__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventExW(arg1, arg2, !x, arg4);
}

void test__CreateEventExW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventExW(arg1, arg2, x, arg4);
}

void test__CreateEventExW__arg4__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateEventExW(arg1, arg2, arg3, !x);
}

void test__CreateEventExW__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateEventExW(arg1, arg2, arg3, x);
}

void test__OpenEvent__noreturn() {
  int x = 1;
  if (cond) { x=100; OpenEvent(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__OpenEvent__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  OpenEvent(!x, arg2, arg3);
}

void test__OpenEvent__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenEvent(x, arg2, arg3);
}

void test__OpenEvent__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenEvent(arg1, x, arg3);
}

void test__OpenEvent__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  OpenEvent(arg1, arg2, p);
}

void test__OpenEvent__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  OpenEvent(arg1, arg2, x);
}

void test__OpenEventA__noreturn() {
  int x = 1;
  if (cond) { x=100; OpenEventA(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__OpenEventA__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  OpenEventA(!x, arg2, arg3);
}

void test__OpenEventA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenEventA(x, arg2, arg3);
}

void test__OpenEventA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenEventA(arg1, x, arg3);
}

void test__OpenEventA__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  OpenEventA(arg1, arg2, p);
}

void test__OpenEventA__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  OpenEventA(arg1, arg2, x);
}

void test__OpenEventW__noreturn() {
  int x = 1;
  if (cond) { x=100; OpenEventW(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__OpenEventW__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  OpenEventW(!x, arg2, arg3);
}

void test__OpenEventW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenEventW(x, arg2, arg3);
}

void test__OpenEventW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenEventW(arg1, x, arg3);
}

void test__OpenEventW__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  OpenEventW(arg1, arg2, p);
}

void test__OpenEventW__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  OpenEventW(arg1, arg2, x);
}

void test__PulseEvent__noreturn() {
  int x = 1;
  if (cond) { x=100; PulseEvent(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__PulseEvent__leakignore() {
  char *p = malloc(10); *p=0;
  PulseEvent(p);
  // cppcheck-suppress memleak
}

void test__PulseEvent__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  PulseEvent(p);
}

void test__PulseEvent__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  PulseEvent(x);
}

void test__ResetEvent__noreturn() {
  int x = 1;
  if (cond) { x=100; ResetEvent(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ResetEvent__leakignore() {
  char *p = malloc(10); *p=0;
  ResetEvent(p);
  // cppcheck-suppress memleak
}

void test__ResetEvent__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  ResetEvent(p);
}

void test__ResetEvent__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  ResetEvent(x);
}

void test__SetEvent__noreturn() {
  int x = 1;
  if (cond) { x=100; SetEvent(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SetEvent__leakignore() {
  char *p = malloc(10); *p=0;
  SetEvent(p);
  // cppcheck-suppress memleak
}

void test__SetEvent__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  SetEvent(p);
}

void test__SetEvent__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  SetEvent(x);
}

void test__InitializeCriticalSection__noreturn() {
  int x = 1;
  if (cond) { x=100; InitializeCriticalSection(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__InitializeCriticalSection__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  InitializeCriticalSection(!x);
}

void test__InitializeCriticalSection__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  InitializeCriticalSection(p);
}

void test__InitializeCriticalSectionAndSpinCount__noreturn() {
  int x = 1;
  if (cond) { x=100; InitializeCriticalSectionAndSpinCount(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__InitializeCriticalSectionAndSpinCount__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  InitializeCriticalSectionAndSpinCount(!x, arg2);
}

void test__InitializeCriticalSectionAndSpinCount__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  InitializeCriticalSectionAndSpinCount(p, arg2);
}

void test__InitializeCriticalSectionAndSpinCount__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  InitializeCriticalSectionAndSpinCount(arg1, !x);
}

void test__InitializeCriticalSectionAndSpinCount__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  InitializeCriticalSectionAndSpinCount(arg1, x);
}

void test__InitializeCriticalSectionEx__noreturn() {
  int x = 1;
  if (cond) { x=100; InitializeCriticalSectionEx(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__InitializeCriticalSectionEx__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  InitializeCriticalSectionEx(!x, arg2, arg3);
}

void test__InitializeCriticalSectionEx__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  InitializeCriticalSectionEx(p, arg2, arg3);
}

void test__InitializeCriticalSectionEx__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  InitializeCriticalSectionEx(arg1, !x, arg3);
}

void test__InitializeCriticalSectionEx__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  InitializeCriticalSectionEx(arg1, x, arg3);
}

void test__InitializeCriticalSectionEx__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  InitializeCriticalSectionEx(arg1, arg2, !x);
}

void test__InitializeCriticalSectionEx__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  InitializeCriticalSectionEx(arg1, arg2, x);
}

void test__SetCriticalSectionSpinCount__noreturn() {
  int x = 1;
  if (cond) { x=100; SetCriticalSectionSpinCount(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SetCriticalSectionSpinCount__leakignore() {
  char *p = malloc(10); *p=0;
  SetCriticalSectionSpinCount(p, arg2);
  // cppcheck-suppress memleak
}

void test__SetCriticalSectionSpinCount__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  SetCriticalSectionSpinCount(!x, arg2);
}

void test__SetCriticalSectionSpinCount__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  SetCriticalSectionSpinCount(p, arg2);
}

void test__SetCriticalSectionSpinCount__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  SetCriticalSectionSpinCount(arg1, !x);
}

void test__SetCriticalSectionSpinCount__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetCriticalSectionSpinCount(arg1, x);
}

void test__DeleteCriticalSection__noreturn() {
  int x = 1;
  if (cond) { x=100; DeleteCriticalSection(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__DeleteCriticalSection__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  DeleteCriticalSection(!x);
}

void test__DeleteCriticalSection__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  DeleteCriticalSection(p);
}

void test__DeleteCriticalSection__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  DeleteCriticalSection(x);
}

void test__EnterCriticalSection__noreturn() {
  int x = 1;
  if (cond) { x=100; EnterCriticalSection(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__EnterCriticalSection__leakignore() {
  char *p = malloc(10); *p=0;
  EnterCriticalSection(p);
  // cppcheck-suppress memleak
}

void test__EnterCriticalSection__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  EnterCriticalSection(!x);
}

void test__EnterCriticalSection__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  EnterCriticalSection(p);
}

void test__EnterCriticalSection__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  EnterCriticalSection(x);
}

void test__TryEnterCriticalSection__noreturn() {
  int x = 1;
  if (cond) { x=100; TryEnterCriticalSection(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__TryEnterCriticalSection__leakignore() {
  char *p = malloc(10); *p=0;
  TryEnterCriticalSection(p);
  // cppcheck-suppress memleak
}

void test__TryEnterCriticalSection__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  TryEnterCriticalSection(!x);
}

void test__TryEnterCriticalSection__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  TryEnterCriticalSection(p);
}

void test__TryEnterCriticalSection__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  TryEnterCriticalSection(x);
}

void test__LeaveCriticalSection__noreturn() {
  int x = 1;
  if (cond) { x=100; LeaveCriticalSection(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__LeaveCriticalSection__leakignore() {
  char *p = malloc(10); *p=0;
  LeaveCriticalSection(p);
  // cppcheck-suppress memleak
}

void test__LeaveCriticalSection__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  LeaveCriticalSection(!x);
}

void test__LeaveCriticalSection__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  LeaveCriticalSection(p);
}

void test__LeaveCriticalSection__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  LeaveCriticalSection(x);
}

void test__lstrcat__noreturn() {
  int x = 1;
  if (cond) { x=100; lstrcat(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__lstrcat__leakignore() {
  char *p = malloc(10); *p=0;
  lstrcat(p, arg2);
  // cppcheck-suppress memleak
}

void test__lstrcat__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  lstrcat(p, arg2);
}

void test__lstrcat__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  lstrcat(x, arg2);
}

void test__lstrcat__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  lstrcat(arg1, p);
}

void test__lstrcat__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  lstrcat(arg1, x);
}

void test__CreateSemaphore__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateSemaphore(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateSemaphore__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphore(x, arg2, arg3, arg4);
}

void test__CreateSemaphore__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphore(arg1, x, arg3, arg4);
}

void test__CreateSemaphore__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphore(arg1, arg2, x, arg4);
}

void test__CreateSemaphore__arg4__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateSemaphore(arg1, arg2, arg3, !x);
}

void test__CreateSemaphore__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphore(arg1, arg2, arg3, x);
}

void test__CreateSemaphoreA__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateSemaphoreA(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateSemaphoreA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreA(x, arg2, arg3, arg4);
}

void test__CreateSemaphoreA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreA(arg1, x, arg3, arg4);
}

void test__CreateSemaphoreA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreA(arg1, arg2, x, arg4);
}

void test__CreateSemaphoreA__arg4__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateSemaphoreA(arg1, arg2, arg3, !x);
}

void test__CreateSemaphoreA__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreA(arg1, arg2, arg3, x);
}

void test__CreateSemaphoreW__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateSemaphoreW(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateSemaphoreW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreW(x, arg2, arg3, arg4);
}

void test__CreateSemaphoreW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreW(arg1, x, arg3, arg4);
}

void test__CreateSemaphoreW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreW(arg1, arg2, x, arg4);
}

void test__CreateSemaphoreW__arg4__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateSemaphoreW(arg1, arg2, arg3, !x);
}

void test__CreateSemaphoreW__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreW(arg1, arg2, arg3, x);
}

void test__CreateSemaphoreEx__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateSemaphoreEx(arg1, arg2, arg3, arg4, arg5, arg6); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateSemaphoreEx__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreEx(x, arg2, arg3, arg4, arg5, arg6);
}

void test__CreateSemaphoreEx__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreEx(arg1, x, arg3, arg4, arg5, arg6);
}

void test__CreateSemaphoreEx__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreEx(arg1, arg2, x, arg4, arg5, arg6);
}

void test__CreateSemaphoreEx__arg4__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateSemaphoreEx(arg1, arg2, arg3, !x, arg5, arg6);
}

void test__CreateSemaphoreEx__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreEx(arg1, arg2, arg3, x, arg5, arg6);
}

void test__CreateSemaphoreEx__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreEx(arg1, arg2, arg3, arg4, x, arg6);
}

void test__CreateSemaphoreEx__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreEx(arg1, arg2, arg3, arg4, arg5, x);
}

void test__CreateSemaphoreExA__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateSemaphoreExA(arg1, arg2, arg3, arg4, arg5, arg6); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateSemaphoreExA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreExA(x, arg2, arg3, arg4, arg5, arg6);
}

void test__CreateSemaphoreExA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreExA(arg1, x, arg3, arg4, arg5, arg6);
}

void test__CreateSemaphoreExA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreExA(arg1, arg2, x, arg4, arg5, arg6);
}

void test__CreateSemaphoreExA__arg4__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateSemaphoreExA(arg1, arg2, arg3, !x, arg5, arg6);
}

void test__CreateSemaphoreExA__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreExA(arg1, arg2, arg3, x, arg5, arg6);
}

void test__CreateSemaphoreExA__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreExA(arg1, arg2, arg3, arg4, x, arg6);
}

void test__CreateSemaphoreExA__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreExA(arg1, arg2, arg3, arg4, arg5, x);
}

void test__CreateSemaphoreExW__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateSemaphoreExW(arg1, arg2, arg3, arg4, arg5, arg6); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateSemaphoreExW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreExW(x, arg2, arg3, arg4, arg5, arg6);
}

void test__CreateSemaphoreExW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreExW(arg1, x, arg3, arg4, arg5, arg6);
}

void test__CreateSemaphoreExW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreExW(arg1, arg2, x, arg4, arg5, arg6);
}

void test__CreateSemaphoreExW__arg4__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateSemaphoreExW(arg1, arg2, arg3, !x, arg5, arg6);
}

void test__CreateSemaphoreExW__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreExW(arg1, arg2, arg3, x, arg5, arg6);
}

void test__CreateSemaphoreExW__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreExW(arg1, arg2, arg3, arg4, x, arg6);
}

void test__CreateSemaphoreExW__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateSemaphoreExW(arg1, arg2, arg3, arg4, arg5, x);
}

void test__OpenSemaphore__noreturn() {
  int x = 1;
  if (cond) { x=100; OpenSemaphore(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__OpenSemaphore__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenSemaphore(x, arg2, arg3);
}

void test__OpenSemaphore__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenSemaphore(arg1, x, arg3);
}

void test__OpenSemaphore__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  OpenSemaphore(arg1, arg2, !x);
}

void test__OpenSemaphore__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  OpenSemaphore(arg1, arg2, p);
}

void test__OpenSemaphore__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  OpenSemaphore(arg1, arg2, x);
}

void test__OpenSemaphoreA__noreturn() {
  int x = 1;
  if (cond) { x=100; OpenSemaphoreA(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__OpenSemaphoreA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenSemaphoreA(x, arg2, arg3);
}

void test__OpenSemaphoreA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenSemaphoreA(arg1, x, arg3);
}

void test__OpenSemaphoreA__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  OpenSemaphoreA(arg1, arg2, !x);
}

void test__OpenSemaphoreA__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  OpenSemaphoreA(arg1, arg2, p);
}

void test__OpenSemaphoreA__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  OpenSemaphoreA(arg1, arg2, x);
}

void test__OpenSemaphoreW__noreturn() {
  int x = 1;
  if (cond) { x=100; OpenSemaphoreW(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__OpenSemaphoreW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenSemaphoreW(x, arg2, arg3);
}

void test__OpenSemaphoreW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenSemaphoreW(arg1, x, arg3);
}

void test__OpenSemaphoreW__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  OpenSemaphoreW(arg1, arg2, !x);
}

void test__OpenSemaphoreW__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  OpenSemaphoreW(arg1, arg2, p);
}

void test__OpenSemaphoreW__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  OpenSemaphoreW(arg1, arg2, x);
}

void test__ReleaseSemaphore__noreturn() {
  int x = 1;
  if (cond) { x=100; ReleaseSemaphore(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ReleaseSemaphore__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  ReleaseSemaphore(!x, arg2, arg3);
}

void test__ReleaseSemaphore__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ReleaseSemaphore(x, arg2, arg3);
}

void test__ReleaseSemaphore__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  ReleaseSemaphore(arg1, !x, arg3);
}

void test__ReleaseSemaphore__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ReleaseSemaphore(arg1, x, arg3);
}

void test__ReleaseSemaphore__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  ReleaseSemaphore(arg1, arg2, !x);
}

void test__ReleaseSemaphore__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ReleaseSemaphore(arg1, arg2, x);
}

void test__CreateMutex__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateMutex(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateMutex__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateMutex(!x, arg2, arg3);
}

void test__CreateMutex__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutex(x, arg2, arg3);
}

void test__CreateMutex__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutex(arg1, x, arg3);
}

void test__CreateMutex__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateMutex(arg1, arg2, !x);
}

void test__CreateMutex__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutex(arg1, arg2, x);
}

void test__CreateMutexA__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateMutexA(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateMutexA__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateMutexA(!x, arg2, arg3);
}

void test__CreateMutexA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexA(x, arg2, arg3);
}

void test__CreateMutexA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexA(arg1, x, arg3);
}

void test__CreateMutexA__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateMutexA(arg1, arg2, !x);
}

void test__CreateMutexA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexA(arg1, arg2, x);
}

void test__CreateMutexW__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateMutexW(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateMutexW__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateMutexW(!x, arg2, arg3);
}

void test__CreateMutexW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexW(x, arg2, arg3);
}

void test__CreateMutexW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexW(arg1, x, arg3);
}

void test__CreateMutexW__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateMutexW(arg1, arg2, !x);
}

void test__CreateMutexW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexW(arg1, arg2, x);
}

void test__CreateMutexEx__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateMutexEx(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateMutexEx__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateMutexEx(!x, arg2, arg3, arg4);
}

void test__CreateMutexEx__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexEx(x, arg2, arg3, arg4);
}

void test__CreateMutexEx__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateMutexEx(arg1, !x, arg3, arg4);
}

void test__CreateMutexEx__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexEx(arg1, x, arg3, arg4);
}

void test__CreateMutexEx__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexEx(arg1, arg2, x, arg4);
}

void test__CreateMutexEx__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexEx(arg1, arg2, arg3, x);
}

void test__CreateMutexExA__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateMutexExA(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateMutexExA__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateMutexExA(!x, arg2, arg3, arg4);
}

void test__CreateMutexExA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexExA(x, arg2, arg3, arg4);
}

void test__CreateMutexExA__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateMutexExA(arg1, !x, arg3, arg4);
}

void test__CreateMutexExA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexExA(arg1, x, arg3, arg4);
}

void test__CreateMutexExA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexExA(arg1, arg2, x, arg4);
}

void test__CreateMutexExA__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexExA(arg1, arg2, arg3, x);
}

void test__CreateMutexExW__noreturn() {
  int x = 1;
  if (cond) { x=100; CreateMutexExW(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__CreateMutexExW__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateMutexExW(!x, arg2, arg3, arg4);
}

void test__CreateMutexExW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexExW(x, arg2, arg3, arg4);
}

void test__CreateMutexExW__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  CreateMutexExW(arg1, !x, arg3, arg4);
}

void test__CreateMutexExW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexExW(arg1, x, arg3, arg4);
}

void test__CreateMutexExW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexExW(arg1, arg2, x, arg4);
}

void test__CreateMutexExW__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  CreateMutexExW(arg1, arg2, arg3, x);
}

void test__OpenMutex__noreturn() {
  int x = 1;
  if (cond) { x=100; OpenMutex(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__OpenMutex__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenMutex(x, arg2, arg3);
}

void test__OpenMutex__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenMutex(arg1, x, arg3);
}

void test__OpenMutex__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  OpenMutex(arg1, arg2, !x);
}

void test__OpenMutex__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  OpenMutex(arg1, arg2, p);
}

void test__OpenMutex__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  OpenMutex(arg1, arg2, x);
}

void test__OpenMutexA__noreturn() {
  int x = 1;
  if (cond) { x=100; OpenMutexA(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__OpenMutexA__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenMutexA(x, arg2, arg3);
}

void test__OpenMutexA__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenMutexA(arg1, x, arg3);
}

void test__OpenMutexA__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  OpenMutexA(arg1, arg2, !x);
}

void test__OpenMutexA__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  OpenMutexA(arg1, arg2, p);
}

void test__OpenMutexA__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  OpenMutexA(arg1, arg2, x);
}

void test__OpenMutexW__noreturn() {
  int x = 1;
  if (cond) { x=100; OpenMutexW(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__OpenMutexW__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenMutexW(x, arg2, arg3);
}

void test__OpenMutexW__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  OpenMutexW(arg1, x, arg3);
}

void test__OpenMutexW__arg3__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  OpenMutexW(arg1, arg2, !x);
}

void test__OpenMutexW__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  OpenMutexW(arg1, arg2, p);
}

void test__OpenMutexW__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  OpenMutexW(arg1, arg2, x);
}

void test__ReleaseMutex__noreturn() {
  int x = 1;
  if (cond) { x=100; ReleaseMutex(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ReleaseMutex__leakignore() {
  char *p = malloc(10); *p=0;
  ReleaseMutex(p);
  // cppcheck-suppress memleak
}

void test__ReleaseMutex__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  ReleaseMutex(!x);
}

void test__ReleaseMutex__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ReleaseMutex(x);
}

void test___malloca__noreturn() {
  int x = 1;
  if (cond) { x=100; _malloca(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___malloca__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _malloca(x);
}

void test___alloca__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _alloca(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___alloca__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _alloca(arg1);
}

void test___alloca__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _alloca(x);
}

void test___freea__noreturn() {
  int x = 1;
  if (cond) { x=100; _freea(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___freea__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  _freea(x);
}

void test__strlwr__noreturn() {
  int x = 1;
  if (cond) { x=100; strlwr(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__strlwr__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  strlwr(p);
}

void test__strlwr__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  strlwr(x);
}

void test__strupr__noreturn() {
  int x = 1;
  if (cond) { x=100; strupr(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__strupr__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  strupr(p);
}

void test__strupr__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  strupr(x);
}

void test__GetLocalTime__noreturn() {
  int x = 1;
  if (cond) { x=100; GetLocalTime(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetLocalTime__leakignore() {
  char *p = malloc(10); *p=0;
  GetLocalTime(p);
  // cppcheck-suppress memleak
}

void test__GetLocalTime__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetLocalTime(p);
}

void test__GetSystemTime__noreturn() {
  int x = 1;
  if (cond) { x=100; GetSystemTime(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetSystemTime__leakignore() {
  char *p = malloc(10); *p=0;
  GetSystemTime(p);
  // cppcheck-suppress memleak
}

void test__GetSystemTime__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetSystemTime(p);
}

void test__GetLastError__noreturn() {
  int x = 1;
  if (cond) { x=100; result = GetLastError(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetLastError__useretval() {
  // cppcheck-suppress ignoredReturnValue
  GetLastError();
}

void test__SetLastError__noreturn() {
  int x = 1;
  if (cond) { x=100; SetLastError(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__SetLastError__leakignore() {
  char *p = malloc(10); *p=0;
  SetLastError(p);
  // cppcheck-suppress memleak
}

void test__SetLastError__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  SetLastError(x);
}

void test__AllocateAndInitializeSid__noreturn() {
  int x = 1;
  if (cond) { x=100; AllocateAndInitializeSid(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__AllocateAndInitializeSid__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  AllocateAndInitializeSid(p);
}

void test__AllocateAndInitializeSid__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  AllocateAndInitializeSid(p);
}

void test__FreeSid__noreturn() {
  int x = 1;
  if (cond) { x=100; FreeSid(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__FreeSid__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  FreeSid(x);
}

void test__HeapAlloc__noreturn() {
  int x = 1;
  if (cond) { x=100; HeapAlloc(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__HeapAlloc__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  HeapAlloc(x, arg2, arg3);
}

void test__HeapAlloc__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  HeapAlloc(arg1, x, arg3);
}

void test__HeapAlloc__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  HeapAlloc(arg1, arg2, x);
}

void test__HeapReAlloc__noreturn() {
  int x = 1;
  if (cond) { x=100; HeapReAlloc(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__HeapReAlloc__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  HeapReAlloc(x, arg2, arg3, arg4);
}

void test__HeapReAlloc__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  HeapReAlloc(arg1, x, arg3, arg4);
}

void test__HeapReAlloc__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  HeapReAlloc(arg1, arg2, p, arg4);
}

void test__HeapReAlloc__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  HeapReAlloc(arg1, arg2, x, arg4);
}

void test__HeapReAlloc__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  HeapReAlloc(arg1, arg2, arg3, x);
}

void test__HeapFree__noreturn() {
  int x = 1;
  if (cond) { x=100; HeapFree(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__HeapFree__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  HeapFree(x, arg2, arg3);
}

void test__HeapFree__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  HeapFree(arg1, x, arg3);
}

void test__HeapFree__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  HeapFree(arg1, arg2, p);
}

void test__HeapFree__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  HeapFree(arg1, arg2, x);
}

void test__HeapSize__noreturn() {
  int x = 1;
  if (cond) { x=100; result = HeapSize(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__HeapSize__useretval() {
  // cppcheck-suppress ignoredReturnValue
  HeapSize(arg1, arg2, arg3);
}

void test__HeapSize__leakignore() {
  char *p = malloc(10); *p=0;
  result = HeapSize(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__HeapSize__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = HeapSize(x, arg2, arg3);
}

void test__HeapSize__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = HeapSize(arg1, x, arg3);
}

void test__HeapSize__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = HeapSize(arg1, arg2, x);
}

void test__HeapValidate__noreturn() {
  int x = 1;
  if (cond) { x=100; HeapValidate(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__HeapValidate__leakignore() {
  char *p = malloc(10); *p=0;
  HeapValidate(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__HeapValidate__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  HeapValidate(x, arg2, arg3);
}

void test__HeapValidate__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  HeapValidate(arg1, x, arg3);
}

void test__HeapValidate__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  HeapValidate(arg1, arg2, x);
}

void test__GetProcessHeap__noreturn() {
  int x = 1;
  if (cond) { x=100; result = GetProcessHeap(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetProcessHeap__useretval() {
  // cppcheck-suppress ignoredReturnValue
  GetProcessHeap();
}

void test__GetUserName__noreturn() {
  int x = 1;
  if (cond) { x=100; GetUserName(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetUserName__leakignore() {
  char *p = malloc(10); *p=0;
  GetUserName(p, arg2);
  // cppcheck-suppress memleak
}

void test__GetUserName__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetUserName(arg1, p);
}

void test__GetUserName__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  GetUserName(arg1, x);
}

void test__GetUserNameA__noreturn() {
  int x = 1;
  if (cond) { x=100; GetUserNameA(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetUserNameA__leakignore() {
  char *p = malloc(10); *p=0;
  GetUserNameA(p, arg2);
  // cppcheck-suppress memleak
}

void test__GetUserNameA__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetUserNameA(arg1, p);
}

void test__GetUserNameA__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  GetUserNameA(arg1, x);
}

void test__GetUserNameW__noreturn() {
  int x = 1;
  if (cond) { x=100; GetUserNameW(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetUserNameW__leakignore() {
  char *p = malloc(10); *p=0;
  GetUserNameW(p, arg2);
  // cppcheck-suppress memleak
}

void test__GetUserNameW__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetUserNameW(arg1, p);
}

void test__GetUserNameW__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  GetUserNameW(arg1, x);
}

void test__GetWindowText__noreturn() {
  int x = 1;
  if (cond) { x=100; GetWindowText(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetWindowText__leakignore() {
  char *p = malloc(10); *p=0;
  GetWindowText(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__GetWindowText__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetWindowText(p, arg2, arg3);
}

void test__GetWindowText__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetWindowText(arg1, p, arg3);
}

void test__GetWindowText__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetWindowText(arg1, arg2, x);
}

void test__GetWindowTextA__noreturn() {
  int x = 1;
  if (cond) { x=100; GetWindowTextA(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetWindowTextA__leakignore() {
  char *p = malloc(10); *p=0;
  GetWindowTextA(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__GetWindowTextA__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetWindowTextA(p, arg2, arg3);
}

void test__GetWindowTextA__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetWindowTextA(arg1, p, arg3);
}

void test__GetWindowTextA__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetWindowTextA(arg1, arg2, x);
}

void test__GetWindowTextW__noreturn() {
  int x = 1;
  if (cond) { x=100; GetWindowTextW(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__GetWindowTextW__leakignore() {
  char *p = malloc(10); *p=0;
  GetWindowTextW(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__GetWindowTextW__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetWindowTextW(p, arg2, arg3);
}

void test__GetWindowTextW__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  GetWindowTextW(arg1, p, arg3);
}

void test__GetWindowTextW__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  GetWindowTextW(arg1, arg2, 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__closesocket__noreturn() {
  int x = 1;
  if (cond) { x=100; closesocket(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__closesocket__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  closesocket(x);
}

void test__accept__noreturn() {
  int x = 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__bind__noreturn() {
  int x = 1;
  if (cond) { x=100; bind(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__bind__leakignore() {
  char *p = malloc(10); *p=0;
  bind(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__bind__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  bind(x, arg2, arg3);
}

void test__bind__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  bind(arg1, p, arg3);
}

void test__bind__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  bind(arg1, arg2, x);
}

void test__connect__noreturn() {
  int x = 1;
  if (cond) { x=100; connect(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__connect__leakignore() {
  char *p = malloc(10); *p=0;
  connect(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__connect__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  connect(x, arg2, arg3);
}

void test__connect__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  connect(arg1, p, arg3);
}

void test__connect__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  connect(arg1, arg2, x);
}

void test__getpeername__noreturn() {
  int x = 1;
  if (cond) { x=100; getpeername(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getpeername__leakignore() {
  char *p = malloc(10); *p=0;
  getpeername(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__getpeername__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  getpeername(x, arg2, arg3);
}

void test__getpeername__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getpeername(arg1, p, arg3);
}

void test__getpeername__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getpeername(arg1, arg2, p);
}

void test__getpeername__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  getpeername(arg1, arg2, x);
}

void test__getsockname__noreturn() {
  int x = 1;
  if (cond) { x=100; getsockname(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getsockname__leakignore() {
  char *p = malloc(10); *p=0;
  getsockname(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__getsockname__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  getsockname(x, arg2, arg3);
}

void test__getsockname__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getsockname(arg1, p, arg3);
}

void test__getsockname__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getsockname(arg1, arg2, p);
}

void test__getsockname__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  getsockname(arg1, arg2, x);
}

void test__getsockopt__noreturn() {
  int x = 1;
  if (cond) { x=100; getsockopt(arg1, arg2, arg3, arg4, arg5); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__getsockopt__leakignore() {
  char *p = malloc(10); *p=0;
  getsockopt(p, arg2, arg3, arg4, arg5);
  // cppcheck-suppress memleak
}

void test__getsockopt__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  getsockopt(x, arg2, arg3, arg4, arg5);
}

void test__getsockopt__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  getsockopt(arg1, x, arg3, arg4, arg5);
}

void test__getsockopt__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  getsockopt(arg1, arg2, x, arg4, arg5);
}

void test__getsockopt__arg4__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getsockopt(arg1, arg2, arg3, p, arg5);
}

void test__getsockopt__arg5__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  getsockopt(arg1, arg2, arg3, arg4, p);
}

void test__getsockopt__arg5__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  getsockopt(arg1, arg2, arg3, arg4, x);
}

void test__htonl__noreturn() {
  int x = 1;
  if (cond) { x=100; result = htonl(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__htonl__useretval() {
  // cppcheck-suppress ignoredReturnValue
  htonl(arg1);
}

void test__htonl__leakignore() {
  char *p = malloc(10); *p=0;
  result = htonl(p);
  // cppcheck-suppress memleak
}

void test__htonl__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = htonl(x);
}

void test__htons__noreturn() {
  int x = 1;
  if (cond) { x=100; result = htons(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__htons__useretval() {
  // cppcheck-suppress ignoredReturnValue
  htons(arg1);
}

void test__htons__leakignore() {
  char *p = malloc(10); *p=0;
  result = htons(p);
  // cppcheck-suppress memleak
}

void test__htons__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = htons(x);
}

void test__inet_addr__noreturn() {
  int x = 1;
  if (cond) { x=100; result = inet_addr(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__inet_addr__useretval() {
  // cppcheck-suppress ignoredReturnValue
  inet_addr(arg1);
}

void test__inet_addr__leakignore() {
  char *p = malloc(10); *p=0;
  result = inet_addr(p);
  // cppcheck-suppress memleak
}

void test__inet_addr__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = inet_addr(p);
}

void test__inet_addr__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = inet_addr(x);
}

void test__inet_ntoa__noreturn() {
  int x = 1;
  if (cond) { x=100; result = inet_ntoa(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__inet_ntoa__useretval() {
  // cppcheck-suppress ignoredReturnValue
  inet_ntoa(arg1);
}

void test__inet_ntoa__leakignore() {
  char *p = malloc(10); *p=0;
  result = inet_ntoa(p);
  // cppcheck-suppress memleak
}

void test__inet_ntoa__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = inet_ntoa(x);
}

void test__ioctlsocket__noreturn() {
  int x = 1;
  if (cond) { x=100; ioctlsocket(arg1, arg2, arg3); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ioctlsocket__leakignore() {
  char *p = malloc(10); *p=0;
  ioctlsocket(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__ioctlsocket__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ioctlsocket(x, arg2, arg3);
}

void test__ioctlsocket__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  ioctlsocket(arg1, x, arg3);
}

void test__ioctlsocket__arg3__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  ioctlsocket(arg1, arg2, p);
}

void test__listen__noreturn() {
  int x = 1;
  if (cond) { x=100; listen(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__listen__leakignore() {
  char *p = malloc(10); *p=0;
  listen(p, arg2);
  // cppcheck-suppress memleak
}

void test__listen__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  listen(x, arg2);
}

void test__listen__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  listen(arg1, x);
}

void test__ntohl__noreturn() {
  int x = 1;
  if (cond) { x=100; result = ntohl(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ntohl__useretval() {
  // cppcheck-suppress ignoredReturnValue
  ntohl(arg1);
}

void test__ntohl__leakignore() {
  char *p = malloc(10); *p=0;
  result = ntohl(p);
  // cppcheck-suppress memleak
}

void test__ntohl__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = ntohl(x);
}

void test__ntohs__noreturn() {
  int x = 1;
  if (cond) { x=100; result = ntohs(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__ntohs__useretval() {
  // cppcheck-suppress ignoredReturnValue
  ntohs(arg1);
}

void test__ntohs__leakignore() {
  char *p = malloc(10); *p=0;
  result = ntohs(p);
  // cppcheck-suppress memleak
}

void test__ntohs__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = ntohs(x);
}

void test__recv__noreturn() {
  int x = 1;
  if (cond) { x=100; recv(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__recv__leakignore() {
  char *p = malloc(10); *p=0;
  recv(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__recv__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  recv(x, arg2, arg3, arg4);
}

void test__recv__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  recv(arg1, p, arg3, arg4);
}

void test__recv__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  recv(arg1, arg2, x, arg4);
}

void test__recv__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  recv(arg1, arg2, arg3, x);
}

void test__recvfrom__noreturn() {
  int x = 1;
  if (cond) { x=100; recvfrom(arg1, arg2, arg3, arg4, arg5, arg6); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__recvfrom__leakignore() {
  char *p = malloc(10); *p=0;
  recvfrom(p, arg2, arg3, arg4, arg5, arg6);
  // cppcheck-suppress memleak
}

void test__recvfrom__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  recvfrom(x, arg2, arg3, arg4, arg5, arg6);
}

void test__recvfrom__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  recvfrom(arg1, p, arg3, arg4, arg5, arg6);
}

void test__recvfrom__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  recvfrom(arg1, arg2, x, arg4, arg5, arg6);
}

void test__recvfrom__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  recvfrom(arg1, arg2, arg3, x, arg5, arg6);
}

void test__select__noreturn() {
  int x = 1;
  if (cond) { x=100; select(arg1, arg2, arg3, arg4, arg5); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__select__leakignore() {
  char *p = malloc(10); *p=0;
  select(p, arg2, arg3, arg4, arg5);
  // cppcheck-suppress memleak
}

void test__select__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  select(arg1, arg2, arg3, arg4, x);
}

void test__send__noreturn() {
  int x = 1;
  if (cond) { x=100; send(arg1, arg2, arg3, arg4); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__send__leakignore() {
  char *p = malloc(10); *p=0;
  send(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__send__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  send(x, arg2, arg3, arg4);
}

void test__send__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  send(arg1, p, arg3, arg4);
}

void test__send__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  send(arg1, arg2, x, arg4);
}

void test__send__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  send(arg1, arg2, arg3, x);
}

void test__sendto__noreturn() {
  int x = 1;
  if (cond) { x=100; sendto(arg1, arg2, arg3, arg4, arg5, arg6); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sendto__leakignore() {
  char *p = malloc(10); *p=0;
  sendto(p, arg2, arg3, arg4, arg5, arg6);
  // cppcheck-suppress memleak
}

void test__sendto__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sendto(x, arg2, arg3, arg4, arg5, arg6);
}

void test__sendto__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  sendto(arg1, p, arg3, arg4, arg5, arg6);
}

void test__sendto__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sendto(arg1, arg2, x, arg4, arg5, arg6);
}

void test__sendto__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sendto(arg1, arg2, arg3, x, arg5, arg6);
}

void test__sendto__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sendto(arg1, arg2, arg3, arg4, x, arg6);
}

void test__sendto__arg6__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sendto(arg1, arg2, arg3, arg4, arg5, x);
}

void test__setsockopt__noreturn() {
  int x = 1;
  if (cond) { x=100; setsockopt(arg1, arg2, arg3, arg4, arg5); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__setsockopt__leakignore() {
  char *p = malloc(10); *p=0;
  setsockopt(p, arg2, arg3, arg4, arg5);
  // cppcheck-suppress memleak
}

void test__setsockopt__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setsockopt(x, arg2, arg3, arg4, arg5);
}

void test__setsockopt__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setsockopt(arg1, x, arg3, arg4, arg5);
}

void test__setsockopt__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setsockopt(arg1, arg2, x, arg4, arg5);
}

void test__setsockopt__arg4__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  setsockopt(arg1, arg2, arg3, p, arg5);
}

void test__setsockopt__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  setsockopt(arg1, arg2, arg3, arg4, x);
}

void test__shutdown__noreturn() {
  int x = 1;
  if (cond) { x=100; shutdown(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__shutdown__leakignore() {
  char *p = malloc(10); *p=0;
  shutdown(p, arg2);
  // cppcheck-suppress memleak
}

void test__shutdown__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  shutdown(x, arg2);
}

void test__shutdown__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  shutdown(arg1, x);
}

void test__WSAStartup__noreturn() {
  int x = 1;
  if (cond) { x=100; WSAStartup(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__WSAStartup__leakignore() {
  char *p = malloc(10); *p=0;
  WSAStartup(p, arg2);
  // cppcheck-suppress memleak
}

void test__WSAStartup__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  WSAStartup(x, arg2);
}

void test__WSAStartup__arg2__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  WSAStartup(arg1, p);
}

void test__WSACleanup__noreturn() {
  int x = 1;
  if (cond) { x=100; WSACleanup(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__WSAGetLastError__noreturn() {
  int x = 1;
  if (cond) { x=100; result = WSAGetLastError(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__WSAGetLastError__useretval() {
  // cppcheck-suppress ignoredReturnValue
  WSAGetLastError();
}

void test__WSASetLastError__noreturn() {
  int x = 1;
  if (cond) { x=100; WSASetLastError(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__WSASetLastError__leakignore() {
  char *p = malloc(10); *p=0;
  WSASetLastError(p);
  // cppcheck-suppress memleak
}

void test__WSASetLastError__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  WSASetLastError(x);
}

void test___fileno__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _fileno(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___fileno__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _fileno(arg1);
}

void test___fileno__leakignore() {
  char *p = malloc(10); *p=0;
  result = _fileno(p);
  // cppcheck-suppress memleak
}

void test___fileno__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  result = _fileno(!x);
}

void test___fileno__arg1__notnull() {
  const char *p = NULL;
  // cppcheck-suppress nullPointer
  result = _fileno(p);
}

void test___fileno__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  result = _fileno(x);
}

void test___tolower__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _tolower(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tolower__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _tolower(arg1);
}

void test___tolower__leakignore() {
  char *p = malloc(10); *p=0;
  result = _tolower(p);
  // cppcheck-suppress memleak
}

void test___tolower__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _tolower(x);
}

void test___tolower_l__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _tolower_l(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___tolower_l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _tolower_l(arg1, arg2);
}

void test___tolower_l__leakignore() {
  char *p = malloc(10); *p=0;
  result = _tolower_l(p, arg2);
  // cppcheck-suppress memleak
}

void test___tolower_l__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _tolower_l(x, arg2);
}

void test___tolower_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _tolower_l(arg1, x);
}

void test___towlower_l__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _towlower_l(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___towlower_l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _towlower_l(arg1, arg2);
}

void test___towlower_l__leakignore() {
  char *p = malloc(10); *p=0;
  result = _towlower_l(p, arg2);
  // cppcheck-suppress memleak
}

void test___towlower_l__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _towlower_l(x, arg2);
}

void test___towlower_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _towlower_l(arg1, x);
}

void test___toupper__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _toupper(arg1); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___toupper__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _toupper(arg1);
}

void test___toupper__leakignore() {
  char *p = malloc(10); *p=0;
  result = _toupper(p);
  // cppcheck-suppress memleak
}

void test___toupper__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _toupper(x);
}

void test___toupper_l__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _toupper_l(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___toupper_l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _toupper_l(arg1, arg2);
}

void test___toupper_l__leakignore() {
  char *p = malloc(10); *p=0;
  result = _toupper_l(p, arg2);
  // cppcheck-suppress memleak
}

void test___toupper_l__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _toupper_l(x, arg2);
}

void test___toupper_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _toupper_l(arg1, x);
}

void test___towupper_l__noreturn() {
  int x = 1;
  if (cond) { x=100; result = _towupper_l(arg1, arg2); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test___towupper_l__useretval() {
  // cppcheck-suppress ignoredReturnValue
  _towupper_l(arg1, arg2);
}

void test___towupper_l__leakignore() {
  char *p = malloc(10); *p=0;
  result = _towupper_l(p, arg2);
  // cppcheck-suppress memleak
}

void test___towupper_l__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _towupper_l(x, arg2);
}

void test___towupper_l__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = _towupper_l(arg1, x);
}

void test____noop__noreturn() {
  int x = 1;
  if (cond) { x=100; __noop(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test____noop__leakignore() {
  char *p = malloc(10); *p=0;
  __noop();
  // cppcheck-suppress memleak
}

void test____nop__noreturn() {
  int x = 1;
  if (cond) { x=100; __nop(); }
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}