#include <bitset>

#include <cassert>

#include <cctype>

#include <cfenv>

#include <cinttypes>

#include <clocale>

#include <cmath>

#include <complex>

#include <csetjmp>

#include <csignal>

#include <cstdarg>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#define __STDC_WANT_LIB_EXT1__ 1

#include <ctime>

#include <cwchar>

#include <fstream>

#include <functional>

#ifndef __STDC_NO_THREADS__

#include <threads.h>

#endif

#include <iomanip>

#include <ios>

#include <iostream>

#include <istream>

#include <iterator>

#include <vector>

#include <unordered_set>

#include <algorithm>

#include <numeric>

int zerodiv_ldexp()

}

int zerodiv_ilogb()

}

int zerodiv_hypot()

}

int zerodiv_fmod()

}

int zerodiv_fmin()

}

int zerodiv_fmax()

}

int zerodiv_floor()

}

int zerodiv_fabs()

}

int zerodiv_fdim()

}

int zerodiv_trunc()

}

int zerodiv_ceil()

}

int zerodiv_sqrt()

}

int zerodiv_cbrt()

}

int zerodiv_erf()

}

int zerodiv_erfc()

}

int zerodiv_asin()

}

int zerodiv_acos()

}

int zerodiv_asinh()

}

int zerodiv_acosh()

}

int zerodiv_log1p()

}

int zerodiv_nearbyint()

}

int zerodiv_round()

}

int zerodiv_sinh()

}

int zerodiv_tanh()

}

int zerodiv_atanh()

}

int zerodiv_atan()

}

int zerodiv_sin()

}

int zerodiv_expm1()

}

int moduloofone_cos()

}

int moduloofone_exp()

}

int moduloofone_exp2()

}

int moduloofone_pow()

}

char* invalidFunctionArgStr_strncpy(char * destination)

{

// Copies the first num characters of source to destination.

// If the end of the source C string (which is signaled by a null-character)

// is found before num characters have been copied, destination

// is padded with zeros until a total of num characters have been written to it.

const char source = 'x';

const std::size_t num = 1U;

return strncpy(destination, &source, num);

}

void invalidFunctionArgStr_fprintf(FILE *stream, const char *format)

}

void invalidFunctionArgStr_fopen(const char * const fileName, const char * const mode)

}

float invalidFunctionArg_remquo (float x, float y, int* quo )

}

double invalidFunctionArg_remquo (double x, double y, int* quo )

}

double invalidFunctionArg_remquo (long double x, long double y, int* quo )

}

void invalidFunctionArg_remainderl(long double f1, long double f2)

}

void invalidFunctionArg_remainder(double f1, double f2)

}

void invalidFunctionArg_remainderf(float f1, float f2)

}

void uninitvar_std_fstream_open(std::fstream &fs, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)

}

void uninitvar_std_ifstream_open(std::ifstream &ifs, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)

}

void uninitvar_std_ofstream_open(std::ofstream &os, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)

}

void uninitvar_std_ofstream_precision(std::ofstream& os)

}

void nullPointer_std_filebuf_open(std::filebuf &fb, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)

}

void nullPointer_std_ofstream_open(std::ofstream &os, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)

}

void nullPointer_std_fstream_open(std::fstream &fs, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)

}

void nullPointer_std_ifstream_open(std::ifstream &is, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)

}

void bufferAccessOutOfBounds_std_fstream_write(std::fstream &fs, const char* s, std::streamsize n)

}

void bufferAccessOutOfBounds_std_ostream_write(std::ostream &os, const char* s, std::streamsize n)

}

void bufferAccessOutOfBounds_std_ostringstream_write(std::ostringstream &oss, const char* s, std::streamsize n)

}

void bufferAccessOutOfBounds_std_ofstream_write(std::ofstream &os, const char* s, std::streamsize n)

}

void invalidFunctionArg_fesetexceptflag(fexcept_t* flagp, int excepts)

}

void invalidFunctionArg_fetestexcept(int excepts)

}

void nullPointer_fprintf(FILE *Stream, char *Format, int Argument)

}

void bufferAccessOutOfBounds_wcsftime(wchar_t* ptr, size_t maxsize, const wchar_t* format, const struct tm* timeptr)

}

int qsort_cmpfunc (const void * a, const void * b) {

return (*static_cast<const int*>(a) - *static_cast<const int*>(b));

}

void nullPointer_qsort(void *base, std::size_t n, std::size_t size, int (*cmp)(const void *, const void *))

}

void nullPointer_vfprintf(FILE *Stream, const char *Format, va_list Arg)

}

void nullPointer_vfwprintf(FILE *Stream, wchar_t *Format, va_list Arg)

}

void *bufferAccessOutOfBounds_memchr(void *s, int c, size_t n)

{

char buf[42]={0};

(void)std::memchr(buf,c,42);

// cppcheck-suppress bufferAccessOutOfBounds

(void)std::memchr(buf,c,43);

return std::memchr(s,c,n);

}

#ifdef __STDC_LIB_EXT1__

void uninitvar_localtime_s(const std::time_t *restrict time, struct tm *restrict result)

}

void nullPointer_localtime_s(const std::time_t *restrict time, struct tm *restrict result)

}

#endif // __STDC_LIB_EXT1__

size_t nullPointer_strftime(char *s, size_t max, const char *fmt, const struct tm *p)

}

size_t bufferAccessOutOfBounds_wcsrtombs(char * dest, const wchar_t ** src, size_t len, mbstate_t * ps)

}

void invalidFunctionArg_std_string_substr(const std::string &str, std::size_t pos, std::size_t len) {

}

void invalidFunctionArg_std_wstring_substr(const std::wstring &str, std::size_t pos, std::size_t len) {

}

double invalidFunctionArg_log10(double d = 0.0) {

// cppcheck-suppress invalidFunctionArg

return log10(d);

}

void uninitvar_std_next(const std::vector<int> &v, int count)

}

void uninitvar_std_prev(const std::vector<int> &v, int count)

}

void overlappingWriteFunction_wcscat(wchar_t *src, wchar_t *dest)

}

void overlappingWriteFunction_wcsxfrm(wchar_t *s1, wchar_t *s2, size_t n)

}

char * overlappingWriteFunction_strcat(char *src, char *dest)

{

// No warning shall be shown:

(void)strcat(dest, src);

// cppcheck-suppress overlappingWriteFunction

return strcat(src, src);

}

int nullPointer_wcsncmp(const wchar_t* s1, const wchar_t* s2, size_t n)

}

wchar_t* nullPointer_wcsncpy(wchar_t *s, const wchar_t *cs, size_t n)

{

// cppcheck-suppress nullPointer

(void) std::wcsncpy(NULL,cs,n);

// cppcheck-suppress nullPointer

(void) std::wcsncpy(s,NULL,n);

return std::wcsncpy(s,cs,n);

}

char * overlappingWriteFunction_strncat(char *src, char *dest, const std::size_t count)

{

// No warning shall be shown:

(void)strncat(dest, src, 42);

(void)strncat(dest, src, count);

(void)strncat(dest, dest, count);

// cppcheck-suppress overlappingWriteFunction

(void)strncat(dest, dest+1, 2);

char buffer[] = "strncat";

// cppcheck-suppress overlappingWriteFunction

return strncat(buffer, buffer + 1, 3);

}

wchar_t * overlappingWriteFunction_wcsncat(wchar_t *src, wchar_t *dest, const std::size_t count)

{

// No warning shall be shown:

(void)wcsncat(dest, src, 42);

(void)wcsncat(dest, src, count);

(void)wcsncat(dest, dest, count);

// cppcheck-suppress overlappingWriteFunction

(void)wcsncat(dest, dest+1, 2);

wchar_t buffer[] = L"strncat";

// cppcheck-suppress overlappingWriteFunction

return wcsncat(buffer, buffer + 1, 3);

}

wchar_t * overlappingWriteFunction_wcscpy(wchar_t *src, wchar_t *dest)

{

// No warning shall be shown:

(void)wcscpy(dest, src);

const wchar_t * destBuf = dest;

// TODO-cppcheck-suppress overlappingWriteFunction #10355

(void)wcscpy(dest, destBuf);

// cppcheck-suppress overlappingWriteFunction

return wcscpy(src, src);

}

wchar_t * overlappingWriteFunction_wcsncpy(wchar_t *buf, const std::size_t count)

{

// No warning shall be shown:

(void)wcsncpy(&buf[0], &buf[3], count); // size is not known

(void)wcsncpy(&buf[0], &buf[3], 3U); // no-overlap

// cppcheck-suppress overlappingWriteFunction

return wcsncpy(&buf[0], &buf[3], 4U);

}

char * overlappingWriteFunction_strncpy(char *buf, const std::size_t count)

{

// No warning shall be shown:

(void)strncpy(&buf[0], &buf[3], count); // size is not known

(void)strncpy(&buf[0], &buf[3], 3U); // no-overlap

// cppcheck-suppress overlappingWriteFunction

return strncpy(&buf[0], &buf[3], 4U);

}

void * overlappingWriteFunction_memmove(void)

{

// No warning shall be shown:

char str[] = "memmove handles overlapping data well";

return memmove(str,str+3,4);

}

std::bitset<10> std_bitset_test_ignoredReturnValue()

}

std::bitset<10> std_bitset_all_ignoredReturnValue()

}

std::bitset<10> std_bitset_none_ignoredReturnValue()

}

std::bitset<10> std_bitset_any_ignoredReturnValue()

}

std::bitset<10> std_bitset_size_ignoredReturnValue()

}

std::bitset<10> std_bitset_count_ignoredReturnValue()

}

void std_unordered_set_count_ignoredReturnValue(const std::unordered_set<int>& u)

}

void valid_code()

}

void returnValue_std_isgreater(void)

}

void returnValue_std_isgreaterequal(void)

}

void returnValue_std_isless(void)

}

void returnValue_std_islessequal(void)

}

void returnValue_std_islessgreater(void)

}

void bufferAccessOutOfBounds(void)

}

void uninitvar_abs(void)

}

void uninivar_imaxabs(void)

}

void uninitvar_isalnum(void)

}

void uninitvar_isalpha(void)

}

void uninitvar_iscntrl(void)

}

void uninitvar_isdigit(void)

}

void uninitvar_isgraph(void)

}

void uninitvar_islower(void)

}

void uninitvar_isprint(void)

}

void uninitvar_isspace(void)

}

void uninitvar_isupper(void)

}

void uninitvar_isxdigit(void)

}

void uninitvar_proj(void)