#include <iostream>
#include <string>
#include <cstring>
#include <cstdint>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <cmath>

#define INITS_bool(...) __VA_ARGS__ 
#define INITS10_bool INITS_bool(false, true, false, true, true, true, false, false, true, true)
#define INITS100_bool INITS_bool(INITS10_bool, INITS10_bool, INITS10_bool, INITS10_bool, INITS10_bool, INITS10_bool, INITS10_bool, INITS10_bool, INITS10_bool, INITS10_bool)
#define INITS1000_bool INITS_bool(INITS100_bool, INITS100_bool, INITS100_bool, INITS100_bool, INITS100_bool, INITS100_bool, INITS100_bool, INITS100_bool, INITS100_bool, INITS100_bool)

#define INITS_int8_t(...) __VA_ARGS__ 
#define INITS10_int8_t INITS_int8_t(-6, -26, 1, -4, -2, -4, 2, 10, -11, -4)
#define INITS100_int8_t INITS_int8_t(INITS10_int8_t, INITS10_int8_t, INITS10_int8_t, INITS10_int8_t, INITS10_int8_t, INITS10_int8_t, INITS10_int8_t, INITS10_int8_t, INITS10_int8_t, INITS10_int8_t)
#define INITS1000_int8_t INITS_int8_t(INITS100_int8_t, INITS100_int8_t, INITS100_int8_t, INITS100_int8_t, INITS100_int8_t, INITS100_int8_t, INITS100_int8_t, INITS100_int8_t, INITS100_int8_t, INITS100_int8_t)

#define INITS_uint8_t(...) __VA_ARGS__ 
#define INITS10_uint8_t INITS_uint8_t(106, 115, 121, 113, 107, 123, 123, 111, 118, 122)
#define INITS100_uint8_t INITS_uint8_t(INITS10_uint8_t, INITS10_uint8_t, INITS10_uint8_t, INITS10_uint8_t, INITS10_uint8_t, INITS10_uint8_t, INITS10_uint8_t, INITS10_uint8_t, INITS10_uint8_t, INITS10_uint8_t)
#define INITS1000_uint8_t INITS_uint8_t(INITS100_uint8_t, INITS100_uint8_t, INITS100_uint8_t, INITS100_uint8_t, INITS100_uint8_t, INITS100_uint8_t, INITS100_uint8_t, INITS100_uint8_t, INITS100_uint8_t, INITS100_uint8_t)

#define INITS_int16_t(...) __VA_ARGS__ 
#define INITS10_int16_t INITS_int16_t(177, 264, -948, 190, 280, 52, 136, -71, 63, 290)
#define INITS100_int16_t INITS_int16_t(INITS10_int16_t, INITS10_int16_t, INITS10_int16_t, INITS10_int16_t, INITS10_int16_t, INITS10_int16_t, INITS10_int16_t, INITS10_int16_t, INITS10_int16_t, INITS10_int16_t)
#define INITS1000_int16_t INITS_int16_t(INITS100_int16_t, INITS100_int16_t, INITS100_int16_t, INITS100_int16_t, INITS100_int16_t, INITS100_int16_t, INITS100_int16_t, INITS100_int16_t, INITS100_int16_t, INITS100_int16_t)

#define INITS_uint16_t(...) __VA_ARGS__ 
#define INITS10_uint16_t INITS_uint16_t(3173, 5076, 2808, 5790, 208, 216, 5536, 4703, 119, 5943)
#define INITS100_uint16_t INITS_uint16_t(INITS10_uint16_t, INITS10_uint16_t, INITS10_uint16_t, INITS10_uint16_t, INITS10_uint16_t, INITS10_uint16_t, INITS10_uint16_t, INITS10_uint16_t, INITS10_uint16_t, INITS10_uint16_t)
#define INITS1000_uint16_t INITS_uint16_t(INITS100_uint16_t, INITS100_uint16_t, INITS100_uint16_t, INITS100_uint16_t, INITS100_uint16_t, INITS100_uint16_t, INITS100_uint16_t, INITS100_uint16_t, INITS100_uint16_t, INITS100_uint16_t)

#define INITS_int32_t(...) __VA_ARGS__ 
#define INITS10_int32_t INITS_int32_t(-14640, 1992, -13715, 818, -16507, -11518, -3985, 16028, 21260, -12097)
#define INITS100_int32_t INITS_int32_t(INITS10_int32_t, INITS10_int32_t, INITS10_int32_t, INITS10_int32_t, INITS10_int32_t, INITS10_int32_t, INITS10_int32_t, INITS10_int32_t, INITS10_int32_t, INITS10_int32_t)
#define INITS1000_int32_t INITS_int32_t(INITS100_int32_t, INITS100_int32_t, INITS100_int32_t, INITS100_int32_t, INITS100_int32_t, INITS100_int32_t, INITS100_int32_t, INITS100_int32_t, INITS100_int32_t, INITS100_int32_t)

#define INITS_uint32_t(...) __VA_ARGS__ 
#define INITS10_uint32_t INITS_uint32_t(21846, 21729, 21795, 21946, 21773, 21823, 21758, 21597, 21787, 21759)
#define INITS100_uint32_t INITS_uint32_t(INITS10_uint32_t, INITS10_uint32_t, INITS10_uint32_t, INITS10_uint32_t, INITS10_uint32_t, INITS10_uint32_t, INITS10_uint32_t, INITS10_uint32_t, INITS10_uint32_t, INITS10_uint32_t)
#define INITS1000_uint32_t INITS_uint32_t(INITS100_uint32_t, INITS100_uint32_t, INITS100_uint32_t, INITS100_uint32_t, INITS100_uint32_t, INITS100_uint32_t, INITS100_uint32_t, INITS100_uint32_t, INITS100_uint32_t, INITS100_uint32_t)

#define INITS_int64_t(...) __VA_ARGS__ 
#define INITS10_int64_t INITS_int64_t(-13881, -7121, 13969, 13063, 43314, -40568, -37678, 37262, 6428, 18082)
#define INITS100_int64_t INITS_int64_t(INITS10_int64_t, INITS10_int64_t, INITS10_int64_t, INITS10_int64_t, INITS10_int64_t, INITS10_int64_t, INITS10_int64_t, INITS10_int64_t, INITS10_int64_t, INITS10_int64_t)
#define INITS1000_int64_t INITS_int64_t(INITS100_int64_t, INITS100_int64_t, INITS100_int64_t, INITS100_int64_t, INITS100_int64_t, INITS100_int64_t, INITS100_int64_t, INITS100_int64_t, INITS100_int64_t, INITS100_int64_t)

#define INITS_uint64_t(...) __VA_ARGS__ 
#define INITS10_uint64_t INITS_uint64_t(4619417, 4618594, 4611741, 4614799, 4621401, 4613745, 4617370, 4622980, 4621127, 4611945)
#define INITS100_uint64_t INITS_uint64_t(INITS10_uint64_t, INITS10_uint64_t, INITS10_uint64_t, INITS10_uint64_t, INITS10_uint64_t, INITS10_uint64_t, INITS10_uint64_t, INITS10_uint64_t, INITS10_uint64_t, INITS10_uint64_t)
#define INITS1000_uint64_t INITS_uint64_t(INITS100_uint64_t, INITS100_uint64_t, INITS100_uint64_t, INITS100_uint64_t, INITS100_uint64_t, INITS100_uint64_t, INITS100_uint64_t, INITS100_uint64_t, INITS100_uint64_t, INITS100_uint64_t)

using namespace std;

class Test {
private:

uint64_t seed = 10072001;

uint64_t random() {
    seed = (uint32_t)(seed * 73129 + 95121);
    return seed;
}


template <typename T, uint32_t N>
size_t lengthArray(T (&Array)[N]) {
    return N;
}


template <typename T, uint32_t N>
uint64_t print(T (&Array)[N]) {
    const uint64_t num = 17;
    uint64_t sum = 0;
    for (auto i = 0; i < N; ++i)
        sum = (uint64_t) ((uint64_t) (sum * 17) + Array[i]);
    return sum;
}


template <typename T, uint32_t N>
void fillArray(T (&Array)[N]) {
    for (auto i = 0; i < N; ++i)
        Array[i] = (T) random();
}


template <typename T>
void fillVector(vector <T> &Vector, size_t size) {
    for (auto i = 0; i < size; ++i)
        Vector.push_back((T) random());
}


template <typename T>
void fillSet(set <T> &Set, size_t size) {
    for (auto i = 0; i < size; ++i)
        Set.insert((T) random());
}


template <typename T, typename R>
void fillMap(map <T, R> &Map, size_t size) {
    for (auto i = 0; i < size; ++i) {
        auto key = (T) random();
        auto value = (R) random();
        Map.emplace(key, value);
    }
}


template <typename T>
uint64_t print(vector <T> &Vector) {
    const uint64_t num = 3;
    uint64_t sum = 0;
    for (auto i = 0; i < Vector.size(); ++i)
        sum = (uint64_t) ((uint64_t) (sum * num) + Vector[i]);
    return sum;
}


template <typename T>
uint64_t print(set <T> &Set) {
    const uint64_t num = 3;
    uint64_t sum = 0;
    for (const auto &it : Set)
        sum = (uint64_t) ((uint64_t) (sum * num) + it);
    return sum;
}


template <typename T, typename R>
uint64_t print(map <T, R> &Map) {
    const uint64_t num = 3;    uint64_t sum = 0;
    for (const auto &it : Map)
        sum = (uint64_t) ((uint64_t) ((uint64_t) (sum * num) * it.first) + it.second);
    return sum;
}

template <typename T>
bool checksum_bool(T x) {
T y = x;
bool  z = 0; 
bool  sum = 0; 
while (y>0) { 
z = y % 10;
sum += z;
y = (y - z)/10;
}
   return sum;
}template <typename T>
int8_t checksum_int8_t(T x) {
T y = x;
int8_t  z = 0; 
int8_t  sum = 0; 
while (y>0) { 
z = y % 10;
sum += z;
y = (y - z)/10;
}
   return sum;
}template <typename T>
uint8_t checksum_uint8_t(T x) {
T y = x;
uint8_t  z = 0; 
uint8_t  sum = 0; 
while (y>0) { 
z = y % 10;
sum += z;
y = (y - z)/10;
}
   return sum;
}template <typename T>
int16_t checksum_int16_t(T x) {
T y = x;
int16_t  z = 0; 
int16_t  sum = 0; 
while (y>0) { 
z = y % 10;
sum += z;
y = (y - z)/10;
}
   return sum;
}template <typename T>
uint16_t checksum_uint16_t(T x) {
T y = x;
uint16_t  z = 0; 
uint16_t  sum = 0; 
while (y>0) { 
z = y % 10;
sum += z;
y = (y - z)/10;
}
   return sum;
}template <typename T>
int32_t checksum_int32_t(T x) {
T y = x;
int32_t  z = 0; 
int32_t  sum = 0; 
while (y>0) { 
z = y % 10;
sum += z;
y = (y - z)/10;
}
   return sum;
}template <typename T>
uint32_t checksum_uint32_t(T x) {
T y = x;
uint32_t  z = 0; 
uint32_t  sum = 0; 
while (y>0) { 
z = y % 10;
sum += z;
y = (y - z)/10;
}
   return sum;
}template <typename T>
int64_t checksum_int64_t(T x) {
T y = x;
int64_t  z = 0; 
int64_t  sum = 0; 
while (y>0) { 
z = y % 10;
sum += z;
y = (y - z)/10;
}
   return sum;
}template <typename T>
uint64_t checksum_uint64_t(T x) {
T y = x;
uint64_t  z = 0; 
uint64_t  sum = 0; 
while (y>0) { 
z = y % 10;
sum += z;
y = (y - z)/10;
}
   return sum;
}public:
uint8_t uint8_tArrayFieldVar_0[1000] = {INITS1000_uint8_t};
uint32_t uint32_tFieldVar_1 = 21523; 
uint16_t uint16_tArrayFieldVar_2[1000] = {INITS1000_uint16_t};


 uint16_t func_uint16_t_uint16_t_3( uint16_t uint16_tVar_4) { 
// function body 
bool boolVar_5 = false; 
int8_t int8_tArrayVar_6[1000];
fillArray(int8_tArrayVar_6);
map <uint16_t, int32_t> uint16_tint32_tMap_7;
fillMap(uint16_tint32_tMap_7, random() % 1000);
int16_t int16_tArrayVar_8[1000];
fillArray(int16_tArrayVar_8);
uint64_t uint64_tVar_9 = 4618562; 



uint16_tVar_4 = 3280; 
  for ( uint64_t uint64_tIndArraySafeVar_10 = 9; 
uint64_tIndArraySafeVar_10 < 468; ++uint64_tIndArraySafeVar_10) { 
for ( uint8_t uint8_tIndVar_11 = 10; 
uint8_tIndVar_11 >= 16; uint8_tIndVar_11--) { 
if ( (uint64_t)(21632) ) { 
for ( uint32_t uint32_tIndVar_12 = 120; 
uint32_tIndVar_12 >= 121; uint32_tIndVar_12--) { 
if ( (((((int64_t)(115)) + (boolVar_5)))  <<  0 ) ) { 
if ( (uint8_t)( max((bool)((uint64_t)(112)), (bool)((uint32_t)(uint16_tVar_4))) ) ) { 
 uint32_t uint32_tIndVar_13 = 298; 
 while ( uint32_tIndVar_13 > 121 ){ 
uint32_tIndVar_13 = uint32_tIndVar_13 - 11; 
if ( (uint8_t)((((boolVar_5) ? (((104) | ((uint8_t)110))) : ((uint8_t)((((uint16_t)(uint16_tVar_4))  <=  ((bool)boolVar_5))))) - ((uint8_t)108))) ) { 
if ((uint64_t)(boolVar_5)) {

 int16_t int16_tIndArraySafeVar_14 = 54; 
do { 
uint16_tint32_tMap_7.emplace(( max((uint16_t)( min((uint16_t)(uint16_tVar_4), (uint16_t)(uint16_tVar_4)) ), (uint16_t)(uint16_tVar_4++)) ), (((-516)  >>  16 ))); 
  

--int16_tIndArraySafeVar_14; 
}  while ( int16_tIndArraySafeVar_14 >= 8 ); 
  uint64_tVar_9 -= ((uint64_tVar_9) + (boolVar_5)); 
  
break;
 } 
  boolVar_5 -= (int64_t)(6516); 
  uint16_tVar_4 |= uint16_tVar_4; 
  uint16_tint32_tMap_7.insert({(((uint16_t)uint16_tint32_tMap_7.size())), (((true) + (abs(-12071))))}); 
  
 } else { 

 } 
  if ( (int64_t)((((int16_t)(boolVar_5)) * (int16_tArrayVar_8[ uint64_tIndArraySafeVar_10 + 2]))) ) { 
uint16_tint32_tMap_7.insert({(((uint16_t)uint16_tint32_tMap_7.size())), (-2855)}); 
  uint16_tVar_4 -= uint16_tVar_4; 
  uint64_tVar_9 += ((uint64_tVar_9) | (uint64_tVar_9)); 
  uint16_tint32_tMap_7.insert({(((uint16_tVar_4) * (uint16_tVar_4))), (-3650)}); 
  uint16_tint32_tMap_7.insert({(uint16_tVar_4), (((((uint8_t)(boolVar_5)) ? (((6810) - (-1358))) : (boolVar_5)) * (((((4600)  <  (-8339))) - (-8514)))))}); 
  uint16_tArrayFieldVar_2[(uint16_tVar_4 ) % 734] /= boolVar_5; 
  uint16_tint32_tMap_7.insert({(uint16_tVar_4), (21210)}); 
  
 } 
  boolVar_5 += (uint64_t)((( max((uint8_t)( min((uint8_t)(111), (uint8_t)(113)) ), (uint8_t)(((int64_t)(uint16_tVar_4)) ? (123) : (118))) ) / (104))); 
  

 } 
  
 } else { 

 } 
  
 } else { 

 } 
  

 } 
  
 } else { 

 } 
  

 } 
  

 } 
  return (uint16_t)(0 + 
(boolVar_5)  + 
 0   + 
 0   + 
 0   + 
(uint16_tVar_4)  + 
 0   + 
 0   + 
 0   + 
(uint64_tVar_9)  + 
  0) ; 

 } 



 uint8_t pointer_func_uint8_t_uint8_t_15( uint8_t *uint8_tPointer_16) { 
// function body 
vector <int32_t> int32_tVector_17;
fillVector(int32_tVector_17, random() % 1000);
map <int8_t, uint64_t> int8_tuint64_tMap_18;
fillMap(int8_tuint64_tMap_18, random() % 1000);
map <uint16_t, uint16_t> uint16_tuint16_tMap_19;
fillMap(uint16_tuint16_tMap_19, random() % 1000);
int64_t int64_tVar_20 = 19855; 
set <bool> boolSet_21;
fillSet(boolSet_21, random() % 1000);
int32_t int32_tArrayVar_22[1000];
fillArray(int32_tArrayVar_22);
int16_t int16_tArrayVar_23[1000];
fillArray(int16_tArrayVar_23);
uint64_t uint64_tVar_24 = 4622915; 
set <bool> boolSet_25;
fillSet(boolSet_25, random() % 1000);
int16_t int16_tVar_26 = -169; 
int64_t int64_tArrayVar_27[1000];
fillArray(int64_tArrayVar_27);
int32_t int32_tArrayVar_28[1000];
fillArray(int32_tArrayVar_28);
uint64_t uint64_tVar_29 = 4613514; 
int8_t int8_tVar_30 = -4; 
vector <int16_t> int16_tVector_31;
fillVector(int16_tVector_31, random() % 1000);
bool boolArrayVar_32[1000];
fillArray(boolArrayVar_32);
uint8_t uint8_tArrayVar_33[1000];
fillArray(uint8_tArrayVar_33);
uint16_t uint16_tVar_34 = 4343; 
vector <uint16_t> uint16_tVector_35;
fillVector(uint16_tVector_35, random() % 1000);
int8_t int8_tVar_36 = 7; 
map <int8_t, uint16_t> int8_tuint16_tMap_37;
fillMap(int8_tuint16_tMap_37, random() % 1000);
uint8_t uint8_tArrayVar_38[1000];
fillArray(uint8_tArrayVar_38);
vector <uint32_t> uint32_tVector_39;
fillVector(uint32_tVector_39, random() % 1000);
map <int8_t, int16_t> int8_tint16_tMap_40;
fillMap(int8_tint16_tMap_40, random() % 1000);
int16_t int16_tVar_41 = -201; 
int32_t int32_tArrayVar_42[1000];
fillArray(int32_tArrayVar_42);
int8_t int8_tVar_43 = 4; 

uint64_t *uint64_tPointer_44 = &uint64_tVar_29; 


for ( uint16_t uint16_tIndVar_45 = 121; 
uint16_tIndVar_45 < 75; uint16_tIndVar_45++) { 
if ( (uint8_t)( max((bool)((int32_t)(func_uint16_t_uint16_t_3( /* func call */ uint16_tVar_34 ))), (bool)((((uint16_t)( *uint8_tPointer_16)) - ((int16_t)((((int8_t)int8_tVar_30)  <<  4 )))))) ) ) { 
for (auto &VECTORuint16_tRefIterator_46: uint16_tVector_35) {
uint8_tArrayFieldVar_0[abs( max((int16_t)(((((int16_tVar_41)  <<  3 ))  <<  7 )), (int16_t)(((int16_t)int16_tVector_31.capacity())))  ) % 545] +=  max((uint8_t)((( *uint8_tPointer_16) + (uint8_tArrayVar_38[ ( *uint8_tPointer_16) % lengthArray(uint8_tArrayVar_38)]))), (uint8_t)((uint8_t) *uint8_tPointer_16)) ; 
  uint16_tVar_34 &= (((((uint16_tVector_35.empty() ? uint16_tVar_34 : uint16_tVector_35[((uint16_t)VECTORuint16_tRefIterator_46) % uint16_tVector_35.size()] )) + (((uint16_tVar_34) + (uint16_tVar_34))))) - (((uint16_t)uint16_tuint16_tMap_19.size()))); 
   int32_t int32_tIndArraySafeVar_47 = 23; 
do { 
 switch (int64_tArrayVar_27[ int32_tIndArraySafeVar_47 + 6]) {
               default : {
if ((int32_t)(this->uint8_tArrayFieldVar_0[ int32_tIndArraySafeVar_47])) {

if ( (int8_t)( max((bool)((int16_t)(boolSet_21.empty())), (bool)((int16_t)(((uint64_t)(uint8_tArrayVar_33[ int32_tIndArraySafeVar_47 + 5])) ? (((uint32_t)(27393)) ? (int16_tVar_26) : (int16_tVar_26)) : ((int16_t)int16_tVar_26)))) ) ) { 
int64_tVar_20 -= ((false) + (int64_tVar_20)); 
  for (auto &ARRAY_VARint32_tRefIterator_48: int32_tArrayVar_22) {
uint64_tVar_29 +=  min((uint64_t)( min((uint64_t)(((uint64_tVar_24) & (uint64_tVar_29))), (uint64_t)(((uint64_tVar_29) * (uint64_tVar_24)))) ), (uint64_t)((((false) + (false))) ? (uint64_tVar_29) : (uint64_tVar_24))) ; 
  int16_tVar_41 = ((--int16_tVar_26) + ((int16_t)int16_tVar_41)); 
  if ((int64_t)(boolArrayVar_32[ int32_tIndArraySafeVar_47])) {


continue;
 } 
  uint64_tVar_29 *= (( *uint64_tPointer_44)  <<  12 ); 
  int16_tVar_41 /= ((((int16_tVar_26) - (int16_tVar_26)))  <=  (int16_tArrayVar_23[ int32_tIndArraySafeVar_47])); 
  int8_tVar_30 -= int8_tVar_30; 
  int8_tVar_30 += (int8_t)int8_tVar_36; 
  uint16_tVar_34 +=  min((uint16_t)((uint16_tVector_35.empty() ? ((int16_t)(true)) ? (uint16_tVar_34) : (uint16_tVar_34) : uint16_tVector_35.at((uint16_tVar_34) % uint16_tVector_35.size()))), (uint16_t)(uint16_tVar_34)) ; 
  int8_tVar_43 -= ((int8_tVar_30)  <<  2 ); 
  int16_tVar_26 += int16_tVar_26; 
  ARRAY_VARint32_tRefIterator_48 = (int32_t)(int32_tVector_17.empty()); 
  int16_tVar_26 |=  min((int16_t)( max((int16_t)( max((int16_t)(int16_tVar_41), (int16_t)(int16_tVar_41)) ), (int16_t)(int16_tArrayVar_23[ int32_tIndArraySafeVar_47])) ), (int16_t)(int16_tVar_41)) ; 
  
} 
  
 } else { 
int16_tVar_41 ^= int16_tVar_26; 
  if ( true ) { 

 } else { 

 } 
  
 } 
  
break;
 } 
       break; 
}
 }
  

int32_tIndArraySafeVar_47++; 
}  while ( int32_tIndArraySafeVar_47 <= 282 ); 
  
} 
  
 } else { 

 } 
  

 } 
  return (uint8_t)(0 + 
 0   + 
checksum_uint8_t(int8_tVar_30 + int8_tVar_36 + int8_tVar_43)  + 
 0   + 
checksum_uint8_t(int16_tVar_26 + int16_tVar_41)  + 
(uint16_tVar_34)  + 
 0   + 
 0   + 
checksum_uint8_t(int64_tVar_20)  + 
(uint64_tVar_24 + uint64_tVar_29)  + 
  0) ; 

 } 



 bool func_bool_bool_49( bool boolVar_50) { 
// function body 
map <uint8_t, uint64_t> uint8_tuint64_tMap_51;
fillMap(uint8_tuint64_tMap_51, random() % 1000);
map <uint16_t, int16_t> uint16_tint16_tMap_52;
fillMap(uint16_tint16_tMap_52, random() % 1000);
int32_t int32_tVar_53 = -14824; 



 switch (int32_tVar_53) {
               default : {
if ( (boolVar_50) ) { 
for ( int64_t int64_tIndArraySafeVar_54 = 485; 
int64_tIndArraySafeVar_54 >= 1; int64_tIndArraySafeVar_54--) { 
if ( (int8_t)(((((-10) - (((int64_t)(106)) ? ((int8_t)-8) : (0)))) + ( max((int8_t)(-12), (int8_t)(((0)  <<  2 ))) ))) ) { 
if ( (((int16_t)(((8) + (-10)))) - ((int32_t)(func_uint16_t_uint16_t_3( /* func call */ 6344 )))) ) { 
 int16_t int16_tIndArraySafeVar_55 = 189; 
do { 
int32_tVar_53 +=  min((int32_t)(int32_tVar_53), (int32_t)(int32_tVar_53)) ; 
   uint32_t uint32_tIndArraySafeVar_56 = 219; 
 while ( uint32_tIndArraySafeVar_56 > 8 ){ 
uint32_tIndArraySafeVar_56 = uint32_tIndArraySafeVar_56 - 13; 
uint16_tint16_tMap_52.emplace(((((((((uint16_t)894) & (2116)))  ==  (((1653) + (5090))))) + ((uint16_t)227))), ((int16_t)(boolVar_50))); 
  boolVar_50 -= (uint64_t)(1030); 
  int32_tVar_53 -= int32_tVar_53; 
   int64_t int64_tIndArraySafeVar_57 = 354; 
do { 
uint8_tuint64_tMap_51.emplace((boolVar_50), (4614783)); 
  uint8_tuint64_tMap_51.insert({((uint8_t)( min((bool)((uint8_t)(((int8_t)(boolVar_50)) ? ((uint8_t)(boolVar_50)) : ((-83 > 199)))), (bool)((int16_t)(((269) - (275))))) )), ((uint64_t)((((int16_t)(boolVar_50)) * ((int64_t)(((-46085) * ( max((int64_t)(23720), (int64_t)(-3147)) )))))))}); 
  boolVar_50 *= (uint64_t)(3376); 
  if ( (int8_t)(((((uint8_t)(boolVar_50)) ? (((-3) - (-2))) : (((-10) + (3)))) - (9))) ) { 

 } else { 

 } 
  boolVar_50 += (((((int64_t)(((int32_tVar_53) / (int32_tVar_53)))) ? (((uint64_t)(113)) ? (5569770) : (4619632)) : (boolVar_50))) + ((int8_t)((((int8_t)(-6))  !=  ((((uint64_t)(boolVar_50))  <<  0 )))))); 
  uint8_tuint64_tMap_51.insert({(((uint8_t)uint8_tuint64_tMap_51.max_size())), (((((((5442711) - (4619539)))  >  (4612202))) + (((4613388) + (5306175)))))}); 
  boolVar_50 += (uint8_t)(uint8_tuint64_tMap_51.empty()); 
  boolVar_50 -= boolVar_50; 
  boolVar_50 += (((4615986) ^ ((uint64_t)(((120) - (((120) & (122))))))) > 5341427); 
   int64_t int64_tIndArraySafeVar_58 = 111; 
 while ( int64_tIndArraySafeVar_58 >= 6 ){ 
int64_tIndArraySafeVar_58 = int64_tIndArraySafeVar_58 - 15; 
uint8_tuint64_tMap_51.emplace(( min((uint8_t)(122), (uint8_t)(107)) ), (((4614923) + ( min((uint64_t)(871413), (uint64_t)(((4614873)  >>  33 ))) )))); 
  boolVar_50 -= (uint8_t)(((((uint8_t)uint8_tuint64_tMap_51.count(( min((uint8_t)((uint8_t)109), (uint8_t)(110)) )))) * ( max((uint8_t)(113), (uint8_t)(((uint8_t)uint8_tuint64_tMap_51.size()))) ))); 
  

 } 
  

int64_tIndArraySafeVar_57--; 
}  while ( int64_tIndArraySafeVar_57 > 18 ); 
  for (auto &MAPuint16_tRefIterator_59: uint16_tint16_tMap_52) {

} 
  

 } 
  

int16_tIndArraySafeVar_55 = int16_tIndArraySafeVar_55 - 19; 
}  while ( int16_tIndArraySafeVar_55 > 16 ); 
  
 } 
  
 } else { 

 } 
  

 } 
  
 } 
       break; 
}
 }
  return (bool)(0 + 
(boolVar_50)  + 
 0   + 
 0   + 
 0   + 
 0   + 
(int32_tVar_53)  + 
 0   + 
 0   + 
 0   + 
  0) ; 

 } 



 bool pointer_func_bool_bool_60( bool *boolPointer_61) { 
// function body 
map <uint32_t, int32_t> uint32_tint32_tMap_62;
fillMap(uint32_tint32_tMap_62, random() % 1000);
int32_t int32_tVar_63 = -7926; 
int64_t int64_tVar_64 = 35; 
vector <uint64_t> uint64_tVector_65;
fillVector(uint64_tVector_65, random() % 1000);
int32_t *int32_tPointer_66 = &int32_tVar_63; 
int8_t int8_tArrayVar_67[1000];
fillArray(int8_tArrayVar_67);
uint8_t uint8_tArrayVar_68[1000];
fillArray(uint8_tArrayVar_68);
uint32_t uint32_tVar_69 = 21730; 
int8_t int8_tVar_70 = -12; 
bool boolVar_71 = false; 
uint16_t uint16_tArrayVar_72[1000];
fillArray(uint16_tArrayVar_72);
int8_t int8_tVar_73 = -10; 

int32_t *int32_tPointer_74 = &int32_tVar_63; 


 int8_t int8_tIndVar_75 = 7; 
do { 
int8_tVar_70 -= int8_tVar_73; 
  if ( (uint64_t)(4617880) ) { 
uint32_tint32_tMap_62.insert({( max((uint32_t)(uint32_tVar_69), (uint32_t)( max((uint32_t)(21867), (uint32_t)(boolVar_71)) )) ), (boolVar_71)}); 
   int32_t int32_tIndArraySafeVar_76 = 349; 
do { 
 uint32_t uint32_tIndArraySafeVar_77 = 18; 
do { 
int64_tVar_64 -= int64_tVar_64; 
  

uint32_tIndArraySafeVar_77++; 
}  while ( uint32_tIndArraySafeVar_77 < 373 ); 
  if ((((uint16_t)(this->uint16_tArrayFieldVar_2[ int32_tIndArraySafeVar_76])) ? ((int16_t)217) : (-219))) {

this->uint16_tArrayFieldVar_2[ int32_tIndArraySafeVar_76] += (uint16_t)( *boolPointer_61); 
  int64_tVar_64 ^= int64_tVar_64; 
  if ( (int64_t)( min((uint16_t)(this->uint16_tArrayFieldVar_2[ int32_tIndArraySafeVar_76 + 7]), (uint16_t)(3194)) ) ) { 
 switch (int8_tVar_70) {
               default : {
boolVar_71 -= (((uint64_t)uint64_tVector_65.size())); 
       break; 
}
 }
  for (const auto &VECTORuint64_tConstRefIterator_78: uint64_tVector_65) {
if ((uint16_t)((((int16_t)(-202)) + ((int16_t)( min((bool)( *boolPointer_61), (bool)( *boolPointer_61)) ))))) {

for (auto &ARRAY_VARint8_tRefIterator_79: int8_tArrayVar_67) {
int8_tVar_73 += ((int8_tArrayVar_67[ int32_tIndArraySafeVar_76 + 5]) * (int8_tVar_73)); 
  ARRAY_VARint8_tRefIterator_79 = (int8_t)(abs(((int8_tVar_70)  >>  4 ))); 
  uint32_tVar_69 += (this -> uint32_tFieldVar_1); 
  int8_tVar_70 -= ((((-12)  !=  (int8_tVar_70))) + (int8_tArrayVar_67[ int32_tIndArraySafeVar_76])); 
  int8_tVar_70 /= ((int8_tVar_70) | (((int8_tVar_73) - ( *boolPointer_61)))); 
  boolVar_71 |= (uint16_t)(((uint8_tArrayVar_68[ int32_tIndArraySafeVar_76]) * ( max((uint8_t)(((118) - ((uint8_t)105))), (uint8_t)(this->uint8_tArrayFieldVar_0[ int32_tIndArraySafeVar_76 + 7])) ))); 
  int8_tVar_70 /= (((( min((int8_t)(int8_tVar_73), (int8_t)(int8_tVar_70)) ) | (((int8_tVar_70) - ((int8_t)int8_tVar_73))))) ^ (int8_tArrayVar_67[ int32_tIndArraySafeVar_76 + 4])); 
  uint32_tVar_69 &= ((((uint32_t)uint32_tint32_tMap_62.count((uint32_tVar_69)))) + (uint32_tVar_69)); 
  uint16_tArrayFieldVar_2[(((uint32_t)uint32_tint32_tMap_62.max_size()) ) % 726] &= ((6365)  <<  3 ); 
  
} 
  
break;
 } 
  
} 
  
 } 
  
continue;
 } 
  

int32_tIndArraySafeVar_76 = int32_tIndArraySafeVar_76 - 13; 
}  while ( int32_tIndArraySafeVar_76 >= 13 ); 
  
 } else { 

 } 
  

--int8_tIndVar_75; 
}  while ( int8_tIndVar_75 >= -14 ); 
  return (bool)(0 + 
(boolVar_71)  + 
(int8_tVar_70 + int8_tVar_73)  + 
 0   + 
 0   + 
 0   + 
(int32_tVar_63)  + 
(uint32_tVar_69)  + 
(int64_tVar_64)  + 
 0   + 
  0) ; 

 } 



 int16_t pointer_func_int16_t_int16_t_80( int16_t *int16_tPointer_81) { 
// function body 
uint32_t uint32_tVar_82 = 21920; 
vector <int32_t> int32_tVector_83;
fillVector(int32_tVector_83, random() % 1000);
set <uint8_t> uint8_tSet_84;
fillSet(uint8_tSet_84, random() % 1000);
map <uint32_t, int16_t> uint32_tint16_tMap_85;
fillMap(uint32_tint16_tMap_85, random() % 1000);
uint32_t *uint32_tPointer_86 = &uint32_tVar_82; 
map <int32_t, int16_t> int32_tint16_tMap_87;
fillMap(int32_tint16_tMap_87, random() % 1000);
map <int32_t, int64_t> int32_tint64_tMap_88;
fillMap(int32_tint64_tMap_88, random() % 1000);
bool boolVar_89 = true; 
bool boolVar_90 = true; 
set <int8_t> int8_tSet_91;
fillSet(int8_tSet_91, random() % 1000);
int64_t int64_tVar_92 = 9425; 
int32_t int32_tVar_93 = 1339; 
int64_t int64_tArrayVar_94[1000];
fillArray(int64_tArrayVar_94);
bool *boolPointer_95 = &boolVar_89; 
int32_t int32_tVar_96 = -15634; 
int64_t *int64_tPointer_97 = &int64_tVar_92; 
uint32_t *uint32_tPointer_98 = &uint32_tVar_82; 
vector <int32_t> int32_tVector_99;
fillVector(int32_tVector_99, random() % 1000);
vector <uint32_t> uint32_tVector_100;
fillVector(uint32_tVector_100, random() % 1000);
int64_t int64_tVar_101 = 45809; 
vector <int16_t> int16_tVector_102;
fillVector(int16_tVector_102, random() % 1000);
map <int32_t, uint16_t> int32_tuint16_tMap_103;
fillMap(int32_tuint16_tMap_103, random() % 1000);
uint8_t uint8_tArrayVar_104[1000];
fillArray(uint8_tArrayVar_104);
uint64_t uint64_tVar_105 = 4621749; 
bool boolVar_106 = false; 
int64_t int64_tVar_107 = 16748; 
uint32_t *uint32_tPointer_108 = &uint32_tVar_82; 
uint32_t uint32_tVar_109 = 21942; 

int32_t *int32_tPointer_110 = &int32_tVar_96; 


 uint64_t uint64_tIndVar_111 = 123; 
do { 
for ( int64_t int64_tIndArraySafeVar_112 = 403; 
int64_tIndArraySafeVar_112 >= 1; int64_tIndArraySafeVar_112--) { 
if ((int16_t)(((int8_t)int8_tSet_91.count(( min((int8_t)(((-8) / ((int8_t)-11))), (int8_t)(11)) ))))) {

if ( (((2830)  <<  2 )) ) { 
boolVar_106 &= (((uint8_t)(boolVar_90)) - ((uint16_t)(((((136) - (110))) - (((uint8_t)uint8_tSet_84.size())))))); 
  if ((((uint64_t)((((int32_t)(((4884) - (1485)))) - ((uint32_t)(121))))) - ((int32_t)(((((int32_t)int32_tuint16_tMap_103.max_size())) - (int32_tVector_99.empty())))))) {

 uint64_t uint64_tIndArraySafeVar_113 = 273; 
 while ( uint64_tIndArraySafeVar_113 >= 15 ){ 
uint64_tIndArraySafeVar_113 = uint64_tIndArraySafeVar_113 - 19; 
 int16_t int16_tIndArraySafeVar_114 = 4; 
 while ( int16_tIndArraySafeVar_114 < 161 ){ 
int16_tIndArraySafeVar_114++; 
int32_tVector_99.swap(int32_tVector_99); 
  if ( max((bool)((int32_t)(((int8_t)int8_tSet_91.max_size()))), (bool)((int32_t)(boolVar_106))) ) {

int32_tVector_83.swap(int32_tVector_99); 
  
break;
 } 
  uint32_tPointer_98 = &(this -> uint32_tFieldVar_1); 
  uint32_tPointer_98 = &(this -> uint32_tFieldVar_1); 
  if (!uint32_tVector_100.empty()) { 
sort(uint32_tVector_100.begin(), uint32_tVector_100.end());}
  uint32_tPointer_86 = &uint32_tVar_109; 
  uint32_tVector_100.push_back((uint32_tVector_100.empty() ? (((uint32_tVector_100.empty() ? uint32_tVar_82 : uint32_tVector_100.at(((this -> uint32_tFieldVar_1)) % uint32_tVector_100.size())))  >>  30 ) : uint32_tVector_100[( max((uint32_t)((uint32_tVector_100.empty() ? uint32_tVar_82 : uint32_tVector_100[((uint32_t)(this -> uint32_tFieldVar_1)) % uint32_tVector_100.size()] )), (uint32_t)((uint32_tVector_100.empty() ? uint32_tVar_82 : uint32_tVector_100.at(( *uint32_tPointer_108) % uint32_tVector_100.size())))) ) % uint32_tVector_100.size()] )); 
  if ((int64_t)((((int8_t)(((2) * ((int8_t)9)))) + ((int16_t)(((2)  <<  2 )))))) {

int32_tVector_99.clear(); 
  if ( (uint16_t)((uint16_t)3155) ) { 
int32_tVar_96 = (int32_tVector_83.empty() ? (int32_tVector_83.empty() ? (int32_tVector_99.empty() ? int32_tVar_93 : int32_tVector_99.at(((int32_t)int32_tVar_96) % int32_tVector_99.size())) : int32_tVector_99.at(( min((int32_t)( *int32_tPointer_110), (int32_t)(int32_tVar_96)) ) % int32_tVector_99.size())) : int32_tVector_99.at(((((int32_tVector_99.empty() ? int32_tVar_93 : int32_tVector_99.at((int32_tVar_96) % int32_tVector_99.size()))) * (int32_tVar_93))) % int32_tVector_99.size())); 
  boolVar_90 -= (uint64_t)(((3305) + ( min((uint16_t)(73), (uint16_t)(3284)) ))); 
  boolVar_89 *= (uint16_t)(3072); 
  int16_tVector_102.push_back((int16_tVector_102.empty() ?  *int16_tPointer_81 : int16_tVector_102.at(((int16_tVector_102.empty() ? (((int16_t) *int16_tPointer_81) - ( *int16_tPointer_81)) : int16_tVector_102.at((((307)  <<  14 )) % int16_tVector_102.size()))) % int16_tVector_102.size()))); 
  int32_tVector_99 = int32_tVector_99; 
  uint32_tVector_100.resize( random() % 1000, (uint32_tVar_109)); 
  
 } else { 

 } 
  
break;
 } 
  

 } 
  

 } 
  
continue;
 } 
  
 } else { 

 } 
  
break;
 } 
  

 } 
  

++uint64_tIndVar_111; 
}  while ( uint64_tIndVar_111 < 110 ); 
  return (int16_t)(0 + 
(boolVar_89 + boolVar_90 + boolVar_106)  + 
 0   + 
 0   + 
 0   + 
 0   + 
(int32_tVar_93 + int32_tVar_96)  + 
checksum_int16_t(uint32_tVar_82 + uint32_tVar_109)  + 
(int64_tVar_92 + int64_tVar_101 + int64_tVar_107)  + 
checksum_int16_t(uint64_tVar_105)  + 
  0) ; 

 } 



 uint64_t pointer_func_uint64_t_uint64_t_115( uint64_t *uint64_tPointer_116) { 
// function body 
int16_t int16_tArrayVar_117[1000];
fillArray(int16_tArrayVar_117);
vector <bool> boolVector_118;
fillVector(boolVector_118, random() % 1000);
set <uint16_t> uint16_tSet_119;
fillSet(uint16_tSet_119, random() % 1000);
uint32_t uint32_tVar_120 = 21876; 
int64_t int64_tArrayVar_121[1000];
fillArray(int64_tArrayVar_121);
int64_t int64_tVar_122 = -41530; 
uint32_t uint32_tArrayVar_123[1000];
fillArray(uint32_tArrayVar_123);
vector <uint8_t> uint8_tVector_124;
fillVector(uint8_tVector_124, random() % 1000);
int8_t int8_tArrayVar_125[1000];
fillArray(int8_tArrayVar_125);
vector <uint32_t> uint32_tVector_126;
fillVector(uint32_tVector_126, random() % 1000);
vector <int8_t> int8_tVector_127;
fillVector(int8_tVector_127, random() % 1000);
vector <int8_t> int8_tVector_128;
fillVector(int8_tVector_128, random() % 1000);
set <uint8_t> uint8_tSet_129;
fillSet(uint8_tSet_129, random() % 1000);
map <uint32_t, int64_t> uint32_tint64_tMap_130;
fillMap(uint32_tint64_tMap_130, random() % 1000);
int8_t int8_tVar_131 = -98; 
set <int32_t> int32_tSet_132;
fillSet(int32_tSet_132, random() % 1000);
int64_t int64_tArrayVar_133[1000];
fillArray(int64_tArrayVar_133);
map <bool, int16_t> boolint16_tMap_134;
fillMap(boolint16_tMap_134, random() % 1000);
int64_t int64_tArrayVar_135[1000];
fillArray(int64_tArrayVar_135);
uint16_t uint16_tVar_136 = 2195; 
vector <bool> boolVector_137;
fillVector(boolVector_137, random() % 1000);
int32_t int32_tArrayVar_138[1000];
fillArray(int32_tArrayVar_138);
bool boolArrayVar_139[1000];
fillArray(boolArrayVar_139);
int16_t int16_tVar_140 = -198; 
int32_t int32_tVar_141 = 17179; 



if ( func_bool_bool_49( /* func call */ (uint16_t)(func_uint16_t_uint16_t_3( /* func call */ func_uint16_t_uint16_t_3( /* func call */ uint16_tVar_136 ) )) ) ) { 
if ( (uint32_t)(func_uint16_t_uint16_t_3( /* func call */ func_uint16_t_uint16_t_3( /* func call */ ((uint16_t)uint16_tSet_119.count(((uint16_t)(uint16_tVar_136)))) ) )) ) { 
 uint16_t uint16_tIndArraySafeVar_142 = 98; 
 while ( uint16_tIndArraySafeVar_142 > 19 ){ 
uint16_tIndArraySafeVar_142--; 
 int16_t int16_tIndArraySafeVar_143 = 9; 
 while ( int16_tIndArraySafeVar_143 <= 173 ){ 
int16_tIndArraySafeVar_143 = int16_tIndArraySafeVar_143 + 12; 
 switch (int8_tArrayVar_125[ uint16_tIndArraySafeVar_142 + 4]) {
               default : {
int64_tVar_122 = int64_tArrayVar_135[ int16_tIndArraySafeVar_143]; 
       break; 
}
 }
  boolint16_tMap_134.emplace(((uint16_tVar_136++)), (154)); 
  boolVector_118 = boolVector_137; 
  if ((int64_t)(int32_tArrayVar_138[ int16_tIndArraySafeVar_143 + 2])) {


continue;
 } 
   switch (((int32_tVar_141) + (int32_tVar_141))) {
               default : {
for ( uint16_t uint16_tIndVar_144 = 236; 
uint16_tIndVar_144 >= 121; uint16_tIndVar_144--) { 
int8_tVar_131 += int8_tArrayVar_125[ int16_tIndArraySafeVar_143]; 
   int64_t int64_tIndVar_145 = -578; 
 while ( int64_tIndVar_145 < 224 ){ 
++int64_tIndVar_145; 
 uint32_t uint32_tIndArraySafeVar_146 = 8; 
 while ( uint32_tIndArraySafeVar_146 <= 398 ){ 
uint32_tIndArraySafeVar_146++; 
if ((int16_t)(boolArrayVar_139[ int16_tIndArraySafeVar_143 + 1])) {

if ((bool)( max((uint16_t)(980), (uint16_t)(false)) )) {

this->uint8_tArrayFieldVar_0[ int16_tIndArraySafeVar_143] -= ((uint8_tSet_129.empty()) - ((uint8_tVector_124.empty() ? (true) ? (107) : (115) : uint8_tVector_124[((uint8_tVector_124.empty() ? 112 : uint8_tVector_124[((uint8_t)121) % uint8_tVector_124.size()] )) % uint8_tVector_124.size()] ))); 
  memcpy(int64_tArrayVar_133, int64_tArrayVar_135, lengthArray(int64_tArrayVar_135));
  memcpy(int64_tArrayVar_135, int64_tArrayVar_135, lengthArray(int64_tArrayVar_135));
  boolVector_118.swap(boolVector_137); 
  
break;
 } 
  int32_tVar_141 |= (( max((int32_t)(int32_tArrayVar_138[ int16_tIndArraySafeVar_143 + 4]), (int32_t)(((int32_tVar_141)  >>  7 ))) )  >=  (int32_tVar_141)); 
  boolVector_118.push_back((uint32_t)(((uint16_tVar_136) - (uint16_tVar_136)))); 
  memcpy(int64_tArrayVar_121, int64_tArrayVar_133, lengthArray(int64_tArrayVar_133));
  if ( (112) ) { 
uint32_tVar_120 -= ((uint32_t)uint32_tint64_tMap_130.count((uint32_tArrayVar_123[ uint32_tIndArraySafeVar_146 + 3]))); 
  
 } else { 

 } 
  
break;
 } 
  

 } 
  

 } 
  

 } 
       break; 
}
 }
  

 } 
  

 } 
  
 } else { 

 } 
  
 } else { 

 } 
  return (uint64_t)(0 + 
 0   + 
checksum_uint64_t(int8_tVar_131)  + 
 0   + 
checksum_uint64_t(int16_tVar_140)  + 
checksum_uint64_t(uint16_tVar_136)  + 
checksum_uint64_t(int32_tVar_141)  + 
checksum_uint64_t(uint32_tVar_120)  + 
checksum_uint64_t(int64_tVar_122)  + 
 0   + 
  0) ; 

 } 



 int8_t func_int8_t_int8_t_147( int8_t int8_tVar_148) { 
// function body 
uint32_t uint32_tVar_149 = 21689; 
map <uint16_t, uint64_t> uint16_tuint64_tMap_150;
fillMap(uint16_tuint64_tMap_150, random() % 1000);
uint16_t uint16_tVar_151 = 174; 
uint32_t uint32_tVar_152 = 21797; 
bool boolVar_153 = false; 
bool boolVar_154 = true; 



if ( (uint32_t)((uint16_t)uint16_tVar_151) ) { 
if ( (int16_t)(func_bool_bool_49( /* func call */ func_bool_bool_49( /* func call */ (int16_t)( min((int16_t)(-144), (int16_t)(-274)) ) ) )) ) { 
 switch (int8_tVar_148) {
               default : {
for ( int64_t int64_tIndVar_155 = 223; 
int64_tIndVar_155 > -579; --int64_tIndVar_155) { 


 } 
       break; 
}
 }
  for (auto &MAPuint16_tRefIterator_156: uint16_tuint64_tMap_150) {
if ( (boolVar_153 <  min((int32_t)(-20543), (int32_t)(((uint32_t)(uint32_tVar_152)) ? (((-4048) * (-13982))) : (4969))) ) ) { 
int8_tVar_148 &= ((((int8_tVar_148) / (int8_tVar_148)))  !=  (int8_tVar_148)); 
  (this -> uint32_tFieldVar_1) /= uint32_tVar_149; 
  if ( (uint64_t)(uint32_tVar_152) ) { 
int8_tVar_148 -= ((((10239)) ? (int8_tVar_148) : ((boolVar_153) ? (int8_tVar_148) : ((int8_t)int8_tVar_148))) * (10)); 
   int64_t int64_tIndVar_157 = -577; 
 while ( int64_tIndVar_157 < 401 ){ 
int64_tIndVar_157++; 
 uint64_t uint64_tIndArraySafeVar_158 = 285; 
 while ( uint64_tIndArraySafeVar_158 >= 15 ){ 
uint64_tIndArraySafeVar_158 = uint64_tIndArraySafeVar_158 - 16; 
 int8_t int8_tIndVar_159 = -14; 
do { 
int8_tVar_148 = -40; 
  uint16_tArrayFieldVar_2[(((((102) + (boolVar_154))) + (((197) | ( min((uint8_t)((uint8_t)120), (uint8_t)(107)) )))) ) % 711] += ((((((uint16_tVar_151) + ((uint16_t)(MAPuint16_tRefIterator_156.first))))  <<  8 ))  ==  ((boolVar_154) ? (uint16_tVar_151) : ( min((uint16_t)(uint16_tVar_151), (uint16_t)(uint16_tVar_151)) ))); 
  boolVar_153 -= (((uint64_t)(uint16_tVar_151))  ==  ((uint16_t)( min((bool)((uint64_t)( min((uint8_t)((uint8_t)109), (uint8_t)(113)) )), (bool)((int32_t)((((uint16_t)((uint16_t)6362))  <<  0 )))) ))); 
  uint32_tVar_149 *= uint32_tVar_152; 
  if ((uint8_t)(boolVar_153)) {

int8_tVar_148 -= int8_tVar_148; 
  
continue;
 } 
  int8_tVar_148 = boolVar_153; 
  if (((uint64_t)4621768)) {

uint16_tVar_151 -=  min((uint16_t)((uint16_t)uint16_tVar_151), (uint16_t)((uint16_t)uint16_tVar_151)) ; 
  uint32_tVar_152 -= 21694; 
  for ( int32_t int32_tIndVar_160 = -578; 
int32_tIndVar_160 <= 69; ++int32_tIndVar_160) { 


 } 
  uint32_tVar_152 -= (this -> uint32_tFieldVar_1); 
  
continue;
 } 
  

++int8_tIndVar_159; 
}  while ( int8_tIndVar_159 < -1 ); 
  

 } 
  

 } 
  
 } else { 

 } 
  
 } else { 

 } 
  
} 
  
 } else { 

 } 
  
 } else { 

 } 
  return (int8_t)(0 + 
(boolVar_153 + boolVar_154)  + 
(int8_tVar_148)  + 
 0   + 
 0   + 
checksum_int8_t(uint16_tVar_151)  + 
 0   + 
(uint32_tVar_149 + uint32_tVar_152)  + 
 0   + 
 0   + 
  0) ; 

 } 



 uint16_t func_uint16_t_uint16_t_161( uint16_t uint16_tVar_162) { 
// function body 
map <int64_t, uint16_t> int64_tuint16_tMap_163;
fillMap(int64_tuint16_tMap_163, random() % 1000);
uint8_t uint8_tVar_164 = 105; 



return (uint16_t)(0 + 
 0   + 
 0   + 
checksum_uint16_t(uint8_tVar_164)  + 
 0   + 
(uint16_tVar_162)  + 
 0   + 
 0   + 
 0   + 
 0   + 
  0) ; 

 } 

string run() { 
int64_t int64_tVar_165 = -17841; 
uint16_t uint16_tVar_166 = 4448; 
int16_t int16_tVar_167 = -211; 
vector <uint8_t> uint8_tVector_168;
fillVector(uint8_tVector_168, random() % 1000);
set <uint64_t> uint64_tSet_169;
fillSet(uint64_tSet_169, random() % 1000);
int32_t int32_tVar_170 = 207; 
uint32_t uint32_tArrayVar_171[1000];
fillArray(uint32_tArrayVar_171);
bool boolVar_172 = false; 
uint8_t uint8_tVar_173 = 105; 

uint16_t *uint16_tPointer_174 = &uint16_tVar_166; 


if ( func_bool_bool_49( /* func call */ func_bool_bool_49( /* func call */ (uint8_t)(((uint8_tVar_173)  <=  (uint8_tVar_173))) ) ) ) { 
if ( (((21576) - (uint32_tArrayVar_171[ (21719) % lengthArray(uint32_tArrayVar_171)])) != ((21688) / ( max((uint32_t)(((21532) - ((uint32_t)21921))), (uint32_t)(((21819) - (21639)))) ))) ) { 
if ( (int8_t)(func_int8_t_int8_t_147( /* func call */ func_int8_t_int8_t_147( /* func call */ func_int8_t_int8_t_147( /* func call */ -2 ) ) )) ) { 
for (auto &ARRAY_VARuint32_tRefIterator_175: uint32_tArrayVar_171) {
uint8_tVar_173 |= uint8_tVar_173; 
   int16_t int16_tIndArraySafeVar_176 = 175; 
 while ( int16_tIndArraySafeVar_176 >= 6 ){ 
int16_tIndArraySafeVar_176--; 
uint16_tVar_166 *= boolVar_172; 
   int64_t int64_tIndVar_177 = 383; 
do { 
 uint64_t uint64_tIndArraySafeVar_178 = 2; 
 while ( uint64_tIndArraySafeVar_178 < 577 ){ 
uint64_tIndArraySafeVar_178++; 
for ( int32_t int32_tIndVar_179 = -577; 
int32_tIndVar_179 < 130; int32_tIndVar_179++) { 
if ( (uint32_t)((uint8_tVector_168.empty() ? uint8_tVar_173 : uint8_tVector_168[((uint8_tVector_168.empty() ?  min((uint8_t)(uint8_tVar_173), (uint8_t)((uint8_t)uint8_tVar_173))  : uint8_tVector_168[((uint8_tVector_168.empty() ? (uint8_t)100 : uint8_tVector_168.at(((uint8_t)111) % uint8_tVector_168.size()))) % uint8_tVector_168.size()] )) % uint8_tVector_168.size()] )) ) { 
int16_tVar_167 += boolVar_172; 
  boolVar_172 -= (int64_t)(uint8_tVar_173); 
  if ( (((((-6) * (((-10)  >>  0 )))) - (11))) ) { 
boolVar_172 |= ((( min((uint16_t)( min((uint16_t)(uint16_tVar_166), (uint16_t)((uint16_t)uint16_tVar_166)) ), (uint16_t)(((uint16_tVar_166) ^ (uint16_tVar_166)))) ) * (((uint16_tVar_166)  >>  8 ))) ==  *uint16_tPointer_174); 
  int64_tVar_165 *= (((int64_t)int64_tVar_165) * (int64_tVar_165)); 
  int32_tVar_170 = (((int32_t)int32_tVar_170)  >>  6 ); 
  int16_tVar_167 = int16_tVar_167; 
  uint8_tVar_173 -= boolVar_172; 
  int64_tVar_165 *= ((((int64_tVar_165)  <  (int64_tVar_165))) * (int64_tVar_165)); 
  uint8_tVar_173 = ((((int64_t)(boolVar_172)) ? ((uint8_tVector_168.empty() ? 115 : uint8_tVector_168[(uint8_tVar_173) % uint8_tVector_168.size()] )) : ((uint8_tVector_168.empty() ? uint8_tVar_173 : uint8_tVector_168[(uint8_tVar_173) % uint8_tVector_168.size()] ))) * ((uint8_tVector_168.empty() ? uint8_tVar_173 : uint8_tVector_168.at((((uint8_tVar_173) + (uint8_tVar_173))) % uint8_tVector_168.size())))); 
  
 } else { 
uint16_tVar_166 -= ((uint16_tVar_166) / ( max((uint16_t)( *uint16_tPointer_174), (uint16_t)(uint16_tVar_166)) )); 
  
 } 
  boolVar_172 += (((boolVar_172)  >>  2 )); 
  
 } else { 
int64_tVar_165 = ((((29731)  >>  57 )) % ( max((int64_t)(int64_tVar_165), (int64_t)((int64_t)int64_tVar_165)) )); 
  uint16_tVar_166 -=  *uint16_tPointer_174; 
  
 } 
  

 } 
  

 } 
  

int64_tIndVar_177--; 
}  while ( int64_tIndVar_177 >= -579 ); 
  

 } 
  
} 
  
 } else { 

 } 
  
 } else { 

 } 
  
 } 
  string result = "";
    return result;
}
};

int main(int32_t argc, char* argv[]) { 
    Test test;
    cout << test.run();
return 0;
}