Compiler Explorer

Source code

#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, true, false, false, false, false, false, false, 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(3, 1, -4, -9, 5, -5, 4, 1, -1, 1)
#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(103, 107, 103, 183, 103, 123, 100, 106, 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(308, 277, -215, -244, -53, -1499, -154, 278, 322, -555)
#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(55, 1587, 4140, 3290, 128, 673, 715, 4245, 1841, 4198)
#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(-6546, -16584, 3681, -2845, -15422, 5649, -5002, 17606, 1762, 19295)
#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(21835, 21735, 21638, 21910, 21574, 21635, 21759, 21715, 21720, 21881)
#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(37496, -26039, -38695, -669, 2472, -3988820, 24772, 31665, 9046, 17080)
#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(4615173, 4615065, 4620352, 4622921, 3160926, 4621029, 4613364, 4617943, 4615517, 4618014)
#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;
}

public:
int32_t int32_tArrayFieldVar_0[1000] = {INITS1000_int32_t};
int64_t int64_tFieldVar_1 = -3537970; 
uint8_t uint8_tArrayFieldVar_2[1000] = {INITS1000_uint8_t};

int8_t func_int8_t_int8_t_3( int8_t int8_tVar_4) { 
// function body 
vector <int16_t> int16_tVector_5;
fillVector(int16_tVector_5, random() % 1000);
int64_t int64_tVar_6 = 42716; 
int64_t *int64_tPointer_7 = &int64_tVar_6; 
set <int8_t> int8_tSet_8;
fillSet(int8_tSet_8, random() % 1000);
set <uint16_t> uint16_tSet_9;
fillSet(uint16_tSet_9, random() % 1000);
int8_t int8_tVar_10 = -88; 
map <int64_t, bool> int64_tboolMap_11;
fillMap(int64_tboolMap_11, random() % 1000);
int32_t int32_tArrayVar_12[1000];
fillArray(int32_tArrayVar_12);
bool boolVar_13 = true; 
int8_t int8_tArrayVar_14[1000];
fillArray(int8_tArrayVar_14);
int64_t *int64_tPointer_15 = &int64_tVar_6; 
uint16_t uint16_tArrayVar_16[1000];
fillArray(uint16_tArrayVar_16);
map <uint64_t, uint16_t> uint64_tuint16_tMap_17;
fillMap(uint64_tuint16_tMap_17, random() % 1000);
uint32_t uint32_tVar_18 = 21498;

int64_t *int64_tPointer_19 = &int64_tVar_6;

switch ((( *int64_tPointer_7) - ((((((int64_t) *int64_tPointer_15) + ( *int64_tPointer_7))) + ((( *int64_tPointer_19) + ((this -> int64_tFieldVar_1)))))))) {
               default : {
 int64_t int64_tIndArraySafeVar_20 = 5; 
do { 
if ( ( max((uint32_t)(((uint32_tVar_18) + ((boolVar_13) ? (uint32_tVar_18) : ((uint32_t)uint32_tVar_18)))), (uint32_t)((( min((uint32_t)(uint32_tVar_18), (uint32_t)(uint32_tVar_18)) ) - ((((uint32_t)uint32_tVar_18)  >>  15 ))))) ) ) { 
if ( (int8_t)(int8_tVar_10) ) { 
 int16_t int16_tIndArraySafeVar_21 = 0; 
 while ( int16_tIndArraySafeVar_21 < 163 ){ 
int16_tIndArraySafeVar_21++; 
if ( (this->int32_tArrayFieldVar_0[ int64_tIndArraySafeVar_20 + 7]) ) { 
int64_tPointer_15 = &int64_tVar_6; 
  if ( (uint8_t)(115) ) { 
int64_tPointer_15 = &int64_tVar_6; 
  int64_tPointer_7 = &int64_tVar_6; 
  int16_tVector_5.push_back(((int16_t)int16_tVector_5.capacity())); 
  int8_tVar_10 *= int8_tArrayVar_14[ int16_tIndArraySafeVar_21]; 
  for ( uint16_t uint16_tIndArraySafeVar_22 = 239; 
uint16_tIndArraySafeVar_22 >= 17; uint16_tIndArraySafeVar_22--) { 
int64_tPointer_19 = &int64_tVar_6; 
  boolVar_13 *= boolVar_13; 
  *int64_tPointer_19 = (int64_t)(((int64_tVar_6) & ( *int64_tPointer_7))); 
  for ( int16_t int16_tIndArraySafeVar_23 = 118; 
int16_tIndArraySafeVar_23 > 9; --int16_tIndArraySafeVar_23) { 
uint16_tSet_9.insert( max((uint16_t)(uint16_tArrayVar_16[ int64_tIndArraySafeVar_20 + 2]), (uint16_t)( max((uint16_t)(uint16_tArrayVar_16[ uint16_tIndArraySafeVar_22]), (uint16_t)(5188)) )) ); 
  uint32_tVar_18 -=  min((uint32_t)(uint32_tVar_18), (uint32_t)(uint32_tVar_18)) ; 
  int8_tSet_8.insert(int8_tArrayVar_14[ int16_tIndArraySafeVar_21]); 
  if (int16_tVector_5.size() > 0)
    int16_tVector_5.pop_back(); 
  if (!int16_tVector_5.empty()) { 
sort(int16_tVector_5.begin(), int16_tVector_5.end());}
  uint16_tSet_9.emplace(uint16_tArrayVar_16[ int64_tIndArraySafeVar_20]);

} 
  int64_tPointer_19 = &(this -> int64_tFieldVar_1);

} 
  
 } 
  
 } else { 
if ( (uint32_t)( min((bool)((int64_t)(int8_tArrayVar_14[ int16_tIndArraySafeVar_21 + 5])), (bool)( min((bool)((uint16_t)(((4207)  >>  1 ))), (bool)(boolVar_13)) )) ) ) {

} else {

} 
  
 }

} 
  
 } else {

} 
  
 }

int64_tIndArraySafeVar_20 = int64_tIndArraySafeVar_20 + 17; 
}  while ( int64_tIndArraySafeVar_20 < 111 ); 
       break; 
}
 }
   return ((int8_t)int8_tSet_8.size());

}

uint64_t func_uint64_t_uint64_t_24( uint64_t uint64_tVar_25) { 
// function body 
vector <int8_t> int8_tVector_26;
fillVector(int8_tVector_26, random() % 1000);
vector <int8_t> int8_tVector_27;
fillVector(int8_tVector_27, random() % 1000);
uint8_t uint8_tVar_28 = 104; 
uint16_t uint16_tVar_29 = 4380; 
int64_t int64_tArrayVar_30[1000];
fillArray(int64_tArrayVar_30);
vector <uint64_t> uint64_tVector_31;
fillVector(uint64_tVector_31, random() % 1000);
uint16_t uint16_tVar_32 = 3280; 
uint16_t *uint16_tPointer_33 = &uint16_tVar_32; 
vector <int64_t> int64_tVector_34;
fillVector(int64_tVector_34, random() % 1000);
set <uint16_t> uint16_tSet_35;
fillSet(uint16_tSet_35, random() % 1000);
int16_t int16_tVar_36 = -34; 
map <bool, uint64_t> booluint64_tMap_37;
fillMap(booluint64_tMap_37, random() % 1000);
bool boolVar_38 = true; 
uint8_t uint8_tVar_39 = 110; 
vector <uint64_t> uint64_tVector_40;
fillVector(uint64_tVector_40, random() % 1000);
int32_t int32_tVar_41 = -8528; 
uint64_t uint64_tArrayVar_42[1000];
fillArray(uint64_tArrayVar_42);
int16_t int16_tArrayVar_43[1000];
fillArray(int16_tArrayVar_43);
int8_t int8_tArrayVar_44[1000];
fillArray(int8_tArrayVar_44);
int16_t int16_tVar_45 = 90; 
int16_t *int16_tPointer_46 = &int16_tVar_45; 
int64_t int64_tVar_47 = 22145;

uint8_t *uint8_tPointer_48 = &uint8_tVar_28;

uint64_tVector_40.emplace_back((uint64_tVector_31  !=  uint64_tVector_40)); 
   switch (abs(abs( *int16_tPointer_46))) {
               default : {
for (auto &SETuint16_tRefIterator_49: uint16_tSet_35) {
 int8_t int8_tIndVar_50 = 3; 
do { 
if ((uint16_t)(((uint8_tVar_28) | (uint8_tVar_39)))) {

if ((int16_t)(boolVar_38)) {

uint64_tVar_25 += ((int32_t)((((uint8_t)(uint8_tVar_28)) - ((uint64_t)((((int8_t)(boolVar_38)) & ((uint64_t)((uint8_t)uint8_tVar_28)))))))) ? ( max((uint64_t)( min((uint64_t)(uint64_tVar_25), (uint64_t)(uint64_tVar_25)) ), (uint64_t)(((uint16_t)(true)) ? (uint64_tVar_25) : (uint64_tVar_25))) ) : (uint64_tVar_25); 
  uint8_tVar_39 *= uint8_tVar_28; 
  int16_tVar_36 = (((((int16_t)int16_tVar_45) + ( max((int16_t)( *int16_tPointer_46), (int16_t)(int16_tVar_36)) )))  >>  9 ); 
  if ( (((int32_t)( max((uint8_t)(uint8_tVar_28), (uint8_t)(uint8_tVar_28)) )) - ((uint8_t)(boolVar_38))) ) { 
for ( uint8_t uint8_tIndArraySafeVar_51 = 7; 
uint8_tIndArraySafeVar_51 >= 4; uint8_tIndArraySafeVar_51--) { 
for ( int8_t int8_tIndArraySafeVar_52 = 2; 
int8_tIndArraySafeVar_52 <= 13; ++int8_tIndArraySafeVar_52) { 
if ( (uint16_t)((((int32_t)(uint8_tVar_28)) - ( min((bool)((int16_t)((int16_t)int16_tVar_36)), (bool)((int32_t)(((uint16_t)uint16_tSet_35.max_size())))) ))) ) { 
 uint8_t uint8_tIndVar_53 = 16; 
 while ( uint8_tIndVar_53 < 2 ){ 
uint8_tIndVar_53 = uint8_tIndVar_53 + 1; 
boolVar_38 += (uint64_t)(((int64_t)((((int8_t)(boolVar_38))  <  ((uint8_t)(boolVar_38))))) ? ((uint32_t)( *uint8_tPointer_48)) : (boolVar_38));

} 
  uint8_tVar_39 += (((( *uint8_tPointer_48)  <<  6 ))  ==  (((boolVar_38) - ( *uint8_tPointer_48)))); 
  uint64_tVar_25 -= uint64_tVar_25; 
  uint16_tVar_32 *= ((((uint16_t)uint16_tSet_35.count(((uint16_t)uint16_tVar_32))))  <  (uint16_tVar_29)); 
  int16_tVar_36 &= int16_tArrayVar_43[ int8_tIndArraySafeVar_52 + 7]; 
  *int16_tPointer_46 = (int16_t)(int16_tArrayVar_43[ ( min((int16_t)((( *int16_tPointer_46) + ( *int16_tPointer_46))), (int16_t)( *int16_tPointer_46)) ) % lengthArray(int16_tArrayVar_43)]); 
  
 } else { 
uint8_tVar_39 = uint8_tVar_39; 
  uint8_tVar_39 *=  *uint8_tPointer_48; 
  uint64_tVar_25 *= (uint64_t)uint64_tVar_25; 
  
 }

}

} 
  
 } else { 
uint8_tVar_39 -=  *uint8_tPointer_48; 
  
 } 
  uint8_tVar_39 /= (uint8_t)uint8_tVar_39; 
  
continue;
 } 
  
break;
 }

int8_tIndVar_50 = int8_tIndVar_50 - 1; 
}  while ( int8_tIndVar_50 > -14 ); 
  
} 
       break; 
}
 }
   return (( max((uint64_t)((((uint64_t)uint64_tVar_25) - (uint64_tVar_25))), (uint64_t)(uint64_tVar_25)) ) + (uint64_tArrayVar_42[ (((uint64_tVar_25) - (uint64_tVar_25))) % lengthArray(uint64_tArrayVar_42)]));

}

uint8_t pointer_func_uint8_t_uint8_t_54( uint8_t *uint8_tPointer_55) { 
// function body 
int16_t int16_tVar_56 = -117; 
map <uint16_t, int64_t> uint16_tint64_tMap_57;
fillMap(uint16_tint64_tMap_57, random() % 1000);
uint32_t uint32_tVar_58 = 21877;

switch (((int16_tVar_56) - (((int16_tVar_56)  <<  2 )))) {
               default : {
for (auto &MAPuint16_tRefIterator_59: uint16_tint64_tMap_57) {
if ((int16_t)( *uint8_tPointer_55)) {

int32_t int32_tIndVar_60 = 249; 
 while ( int32_tIndVar_60 > -577 ){ 
--int32_tIndVar_60; 
if ( ((false) + ((int64_t)(((((2567) - (4949))) | (4756))))) ) { 
int16_tVar_56 -= int16_tVar_56; 
   switch ( min((int16_t)(int16_tVar_56), (int16_t)(int16_tVar_56)) ) {
               default : {
for (auto &MAPuint16_tRefIterator_61: uint16_tint64_tMap_57) {
uint32_tVar_58 -= uint32_tVar_58; 
   switch (int16_tVar_56) {
               default : {
 int16_t int16_tIndArraySafeVar_62 = 1; 
 while ( int16_tIndArraySafeVar_62 < 213 ){ 
int16_tIndArraySafeVar_62++; 
*uint8_tPointer_55 = (uint8_t)((( *uint8_tPointer_55)  <<  4 )); 
   uint8_t uint8_tIndVar_63 = 16; 
do { 
uint32_tVar_58 -= ((uint32_tVar_58)  ==  ((false) ? (uint32_tVar_58) : (((uint32_tVar_58) + (uint32_tVar_58))))); 
  uint32_tVar_58 -= ((uint32_tVar_58)  >>  27 ); 
  int16_tVar_56 += int16_tVar_56; 
  int16_tVar_56 -= (int16_t)int16_tVar_56; 
  int16_tVar_56 *=  max((int16_t)(((((int8_t)((bool)true)) ? (int16_tVar_56) : ((int16_t)int16_tVar_56)) - (int16_tVar_56))), (int16_t)(int16_tVar_56)) ; 
  int16_tVar_56 /= 84;

uint8_tIndVar_63 = uint8_tIndVar_63 + 4; 
}  while ( uint8_tIndVar_63 < 0 ); 
  int16_tVar_56 &= ((((int16_tVar_56)  <<  12 )) - (((((290) & (int16_tVar_56)))  ==  (204)))); 
  uint32_tVar_58 *= (( max((uint32_t)(uint32_tVar_58), (uint32_t)(uint32_tVar_58)) ) - ((( max((uint32_t)(21719), (uint32_t)((uint32_t)uint32_tVar_58)) ) + ((uint32_t)uint32_tVar_58))));

} 
       break; 
}
 }
  uint32_tVar_58 |= uint32_tVar_58; 
  uint32_tVar_58 += uint32_tVar_58; 
  if ((((4614313) / (false)))) {

continue;
 } 
  
} 
       break; 
}
 }
  uint32_tVar_58 +=  max((uint32_t)( min((uint32_t)(uint32_tVar_58), (uint32_t)((uint32_t)uint32_tVar_58)) ), (uint32_t)(21736)) ; 
  
 } else {

}

} 
  
continue;
 } 
  
} 
       break; 
}
 }
   return (uint8_t) *uint8_tPointer_55;

}

int32_t pointer_func_int32_t_int32_t_64( int32_t *int32_tPointer_65) { 
// function body 
vector <uint64_t> uint64_tVector_66;
fillVector(uint64_tVector_66, random() % 1000);
uint32_t uint32_tArrayVar_67[1000];
fillArray(uint32_tArrayVar_67);
vector <bool> boolVector_68;
fillVector(boolVector_68, random() % 1000);
vector <int64_t> int64_tVector_69;
fillVector(int64_tVector_69, random() % 1000);
int16_t int16_tArrayVar_70[1000];
fillArray(int16_tArrayVar_70);
uint16_t uint16_tArrayVar_71[1000];
fillArray(uint16_tArrayVar_71);
map <int32_t, bool> int32_tboolMap_72;
fillMap(int32_tboolMap_72, random() % 1000);
uint8_t uint8_tVar_73 = 115; 
map <bool, uint64_t> booluint64_tMap_74;
fillMap(booluint64_tMap_74, random() % 1000);
int64_t int64_tVar_75 = -29675; 
uint8_t *uint8_tPointer_76 = &uint8_tVar_73; 
uint8_t uint8_tVar_77 = 118; 
vector <uint32_t> uint32_tVector_78;
fillVector(uint32_tVector_78, random() % 1000);
uint8_t uint8_tVar_79 = 25; 
vector <int8_t> int8_tVector_80;
fillVector(int8_tVector_80, random() % 1000);
uint16_t uint16_tVar_81 = 6223; 
int64_t int64_tVar_82 = 25511; 
int16_t int16_tVar_83 = -39; 
map <int32_t, uint8_t> int32_tuint8_tMap_84;
fillMap(int32_tuint8_tMap_84, random() % 1000);
int8_t int8_tVar_85 = 4;

uint8_t *uint8_tPointer_86 = &uint8_tVar_77;

switch (((int64_t)int64_tVector_69.max_size())) {
               default : {
for (auto &VECTORuint32_tRefIterator_87: uint32_tVector_78) {
 uint32_t uint32_tIndVar_88 = 131; 
do { 
uint8_tVar_73 -=  *uint8_tPointer_86; 
  if ((int32_t)(((int64_t)(((uint8_tVar_73)  >>  3 ))) ? ((( *int32_tPointer_65) + ((int32_t) *int32_tPointer_65))) : ( *int32_tPointer_65))) {

int8_tVar_85 += int8_tVar_85; 
  if ( ((( max((uint32_t)(21907), (uint32_t)(((21620)  <<  5 ))) ))  >>  0 ) ) { 
if (((uint16_t)(uint16_tArrayVar_71[ (uint16_tVar_81) % lengthArray(uint16_tArrayVar_71)])) ? ((uint32_t)(false)) : ((((((int8_t)((int8_t)int8_tVar_85)) ? ((int64_t)int64_tVar_82) : ((int64_t)(this -> int64_tFieldVar_1))) - ((int64_t)int64_tVar_82))))) {

int64_t int64_tIndArraySafeVar_89 = 465; 
 while ( int64_tIndArraySafeVar_89 >= 21 ){ 
int64_tIndArraySafeVar_89--; 
int64_tVar_82 |= (int64_tVector_69.empty() ? abs((int64_t)int64_tVar_82) : int64_tVector_69.at((((abs((int64_t)int64_tVar_75)) + ((((this -> int64_tFieldVar_1)) * ((int64_t)(this -> int64_tFieldVar_1)))))) % int64_tVector_69.size())); 
  *uint8_tPointer_86 = (uint8_t)((((((uint8_t)((boolVector_68.empty() ? (uint8_t)(true) : boolVector_68.at(((int8_tVar_85)) % boolVector_68.size()))))  <<  7 )) + ( min((uint8_t)((uint8_t)uint8_tVar_79), (uint8_t)(((uint8_tVar_79) + ( *uint8_tPointer_86)))) ))); 
   switch (++int16_tVar_83) {
               default : {
uint16_tVar_81 += (((uint16_t)(uint16_tArrayVar_71[ int64_tIndArraySafeVar_89])) - ( max((uint16_t)(uint16_tArrayVar_71[ int64_tIndArraySafeVar_89]), (uint16_t)(uint16_tArrayVar_71[ int64_tIndArraySafeVar_89])) )); 
       break; 
}
 }

} 
  uint8_tVar_79 *= ((uint8_tVar_77) & ((( min((uint8_t)((uint8_t)(false)), (uint8_t)( *uint8_tPointer_76)) )  ==  (uint8_tVar_77)))); 
  for (auto &VECTORuint32_tRefIterator_90: uint32_tVector_78) {

} 
   uint64_t uint64_tIndVar_91 = 478; 
 while ( uint64_tIndVar_91 > 123 ){ 
uint64_tIndVar_91--; 
for (auto &ARRAY_VARint16_tRefIterator_92: int16_tArrayVar_70) {
if ( (int64_t)(((int64_t)(((++int64_tVar_75) + ((int64_t)(abs((int16_t)((int16_t)ARRAY_VARint16_tRefIterator_92))))))) ? ((this -> int64_tFieldVar_1)) : (int64_tVar_82)) ) { 
uint16_tVar_81 = true; 
  int16_tVar_83 += ((((int16_tVar_83) & (false))) * (((((int16_tVar_83) ^ ((int16_t)ARRAY_VARint16_tRefIterator_92))) - (((int16_tVar_83) + ((int16_t)ARRAY_VARint16_tRefIterator_92)))))); 
  ARRAY_VARint16_tRefIterator_92 = (int16_t)(true); 
  int64_tVar_82 /= int64_tVar_75; 
  int64_tVar_75 = ((int64_t)int64_tVector_69.capacity()); 
  uint8_tVar_79 += uint8_tVar_73; 
  (this -> int64_tFieldVar_1) -= int64_tVar_82; 
  
 } else {

} 
  
}

} 
  
break;
 } 
  
 } else {

} 
  
break;
 }

uint32_tIndVar_88 = uint32_tIndVar_88 - 18; 
}  while ( uint32_tIndVar_88 > 123 ); 
  
} 
       break; 
}
 }
   return  *int32_tPointer_65;

}

int8_t func_int8_t_int8_t_93( int8_t int8_tVar_94) { 
// function body 
set <int64_t> int64_tSet_95;
fillSet(int64_tSet_95, random() % 1000);
int16_t int16_tVar_96 = -240; 
int32_t int32_tVar_97 = 16056; 
int64_t int64_tArrayVar_98[1000];
fillArray(int64_tArrayVar_98);
map <int64_t, int32_t> int64_tint32_tMap_99;
fillMap(int64_tint32_tMap_99, random() % 1000);
vector <uint8_t> uint8_tVector_100;
fillVector(uint8_tVector_100, random() % 1000);
uint8_t uint8_tArrayVar_101[1000];
fillArray(uint8_tArrayVar_101);
map <int16_t, int16_t> int16_tint16_tMap_102;
fillMap(int16_tint16_tMap_102, random() % 1000);
int16_t int16_tVar_103 = 85;

uint16_t uint16_tIndVar_104 = 123; 
 while ( uint16_tIndVar_104 < 27 ){ 
uint16_tIndVar_104 = uint16_tIndVar_104 + 11; 
for ( int16_t int16_tIndArraySafeVar_105 = 247; 
int16_tIndArraySafeVar_105 >= 0; --int16_tIndArraySafeVar_105) { 
if ((uint16_t)(2412)) {

if (!uint8_tVector_100.empty()) { 
sort(uint8_tVector_100.begin(), uint8_tVector_100.end());}
  if ((int32_t)( min((int8_t)(int8_tVar_94), (int8_t)(--int8_tVar_94)) )) {

if ( (int16_t)((((uint16_t)(((303) + ((uint16_t)65))))  >>  0 )) ) {

} else { 
int16_tint16_tMap_102.emplace((int16_tVar_96), (((int8_t)(int8_tVar_94)) ? (abs(int16_tVar_103)) : (((int16_tVar_103) | (int16_tVar_103))))); 
  if ( (uint16_t)((((uint8_t)(this->uint8_tArrayFieldVar_2[ int16_tIndArraySafeVar_105 + 5])) + ((uint16_t)( max((uint16_t)((uint16_t)(3410)), (uint16_t)(3230)) )))) ) { 
int16_tVar_103 = ((((((int16_tVar_96)  <  ((int16_t)130))) ^ ((int16_t)int16_tVar_103))) + (true)); 
   int8_t int8_tIndVar_106 = -14; 
do { 
int8_tVar_94 += ((int8_tVar_94) + ( min((int8_t)(int8_tVar_94), (int8_t)(int8_tVar_94)) )); 
  if ((int32_t)(((7518)) ? (int8_tVar_94) : ( min((int8_t)(int8_tVar_94), (int8_t)(int8_tVar_94)) ))) {

continue;
 } 
   int16_t int16_tIndVar_107 = -278; 
do { 
int8_tVar_94 += ((int8_tVar_94) - ((int8_t)int8_tVar_94)); 
  int64_tint32_tMap_99.insert({(int64_tArrayVar_98[ int16_tIndArraySafeVar_105 + 7]), (int32_tVar_97)}); 
  if ((uint64_t)(true)) {

break;
 }

int16_tIndVar_107 = int16_tIndVar_107 + 18; 
}  while ( int16_tIndVar_107 < 73 ); 
  int16_tVar_96 -= int16_tVar_103; 
  if (!uint8_tVector_100.empty()) { 
sort(uint8_tVector_100.begin(), uint8_tVector_100.end());}
  int64_tSet_95.insert(true); 
  if (!uint8_tVector_100.empty()) { 
sort(uint8_tVector_100.begin(), uint8_tVector_100.end());}
  uint8_tVector_100.push_back(124); 
  int8_tVar_94 -=  min((int8_t)(int8_tVar_94), (int8_t)(((((int8_tVar_94) * ((int8_t)int8_tVar_94))) - (int8_tVar_94)))) ; 
  if ((uint16_t)((((int32_t)(2285)) + ((int32_t)(((int16_tVar_103)  <<  4 )))))) {

int8_tVar_94 *= ((((int8_tVar_94) + (((int8_tVar_94) + ((int8_t)int8_tVar_94))))) + (int8_tVar_94)); 
  int64_tint32_tMap_99.insert({(40108), (((int32_tVar_97)  <  ((((((int32_t)int32_tVar_97) + (int32_tVar_97))) - (int32_tVar_97)))))}); 
  
continue;
 }

int8_tIndVar_106++; 
}  while ( int8_tIndVar_106 <= 4 ); 
  
 } else {

} 
  
 } 
  
continue;
 } 
  
break;
 }

}

} 
   return func_int8_t_int8_t_3( /* func call */ func_int8_t_int8_t_3( /* func call */ func_int8_t_int8_t_3( /* func call */ int8_tVar_94 ) ) );

}

uint64_t pointer_func_uint64_t_uint64_t_108( uint64_t *uint64_tPointer_109) { 
// function body 
vector <uint64_t> uint64_tVector_110;
fillVector(uint64_tVector_110, random() % 1000);
uint16_t uint16_tVar_111 = 5198; 
bool boolArrayVar_112[1000];
fillArray(boolArrayVar_112);
vector <int16_t> int16_tVector_113;
fillVector(int16_tVector_113, random() % 1000);
int64_t int64_tVar_114 = -3049; 
int32_t int32_tArrayVar_115[1000];
fillArray(int32_tArrayVar_115);
vector <int8_t> int8_tVector_116;
fillVector(int8_tVector_116, random() % 1000);
uint64_t uint64_tArrayVar_117[1000];
fillArray(uint64_tArrayVar_117);
int32_t int32_tVar_118 = -5049; 
vector <bool> boolVector_119;
fillVector(boolVector_119, random() % 1000);
int8_t int8_tVar_120 = -7; 
int32_t int32_tVar_121 = -13242; 
uint8_t uint8_tVar_122 = 108;

for ( uint64_t uint64_tIndArraySafeVar_123 = 189; 
uint64_tIndArraySafeVar_123 > 20; --uint64_tIndArraySafeVar_123) { 
 switch (this->int32_tArrayFieldVar_0[ uint64_tIndArraySafeVar_123 + 2]) {
               default : {
if ( (uint16_t)((((int16_t)((int16_tVector_113.empty() ? (int16_tVector_113.empty() ? 242 : int16_tVector_113.back()) : int16_tVector_113.at(((int16_tVector_113.empty() ? -148 : int16_tVector_113.at((-224) % int16_tVector_113.size()))) % int16_tVector_113.size())))) + ((int16_t)(boolArrayVar_112[ uint64_tIndArraySafeVar_123 + 4])))) ) { 
boolVector_119.push_back(boolArrayVar_112[ uint64_tIndArraySafeVar_123]); 
  if ( (uint64_t)((((int16_t)(func_int8_t_int8_t_3( /* func call */ int8_tVar_120 )))  >>  0 )) ) { 
if ( ((int16_tVector_113.empty() ? -117 : int16_tVector_113[(((-77) - ((int16_tVector_113.empty() ? -243 : int16_tVector_113[((int16_t)96) % int16_tVector_113.size()] )))) % int16_tVector_113.size()] ) > (int16_tVector_113.empty() ? (((int16_tVector_113.empty() ? 81 : int16_tVector_113[(-255) % int16_tVector_113.size()] ))  ==  ((int16_tVector_113.empty() ? 257 : int16_tVector_113[((int16_t)159) % int16_tVector_113.size()] ))) : int16_tVector_113.at(((int16_t)279) % int16_tVector_113.size()))) ) { 
int16_tVector_113.resize( random() % 1000, ((((int16_tVector_113.empty() ? ((172) - ((int16_t)94)) : int16_tVector_113.at(((((int16_t)-190) + (-47))) % int16_tVector_113.size()))) / (21)))); 
  for ( int16_t int16_tIndVar_124 = -278; 
int16_tIndVar_124 < 95; ++int16_tIndVar_124) { 
int8_tVar_120 -= abs((((int8_tVector_116.empty() ? int8_tVar_120 : int8_tVector_116.at((int8_tVar_120) % int8_tVector_116.size())))  <<  7 )); 
  for (auto &VECTORint8_tRefIterator_125: int8_tVector_116) {
int64_tVar_114 -=  min((int64_t)(int64_tVar_114), (int64_t)((int64_t)(uint8_tVar_122))) ; 
  if ( (uint64_t)(21891) ) { 
int64_tVar_114 %= int64_tVar_114; 
  int32_tVar_121 -= ((((this->int32_tArrayFieldVar_0[ uint64_tIndArraySafeVar_123])  >>  5 ))  ==  (int32_tVar_118)); 
  uint8_tVar_122 = ((uint8_tVar_122) * (((uint8_tVar_122) + (uint8_tVar_122)))); 
  int32_tVar_121 %= ((int32_tVar_121)  <<  5 ); 
  VECTORint8_tRefIterator_125 = (int8_t)((int8_tVector_116.empty() ? int8_tVar_120 : int8_tVector_116.back())); 
  int32_tVar_118 = int32_tVar_121; 
  uint8_tVar_122 /= ((uint8_tVar_122) + ((uint8_t)(uint8_tVar_122))); 
   int16_t int16_tIndVar_126 = -278; 
 while ( int16_tIndVar_126 <= 185 ){ 
++int16_tIndVar_126; 
uint16_tVar_111 += uint16_tVar_111; 
  int8_tVar_120 -=  min((int8_t)(int8_tVar_120), (int8_t)( min((int8_t)(((int8_tVar_120) * (int8_tVar_120))), (int8_t)(-21)) )) ; 
  uint16_tVar_111 += uint16_tVar_111; 
  int32_tVar_118 -= this->int32_tArrayFieldVar_0[ uint64_tIndArraySafeVar_123]; 
  (this -> int64_tFieldVar_1) += ((uint64_t)((((uint64_t)(uint8_tVar_122)) + ((int32_t)(uint16_tVar_111))))) ? (((((int64_tVar_114)  <=  (int64_tVar_114))) * (((int64_tVar_114)  <<  3 )))) : (int64_tVar_114);

} 
  
 } 
  
}

} 
  
 } 
  
 } else {

} 
  
 } else {

} 
       break; 
}
 }

} 
   return func_uint64_t_uint64_t_24( /* func call */ func_uint64_t_uint64_t_24( /* func call */ func_uint64_t_uint64_t_24( /* func call */  *uint64_tPointer_109 ) ) );

}

uint16_t pointer_func_uint16_t_uint16_t_127( uint16_t *uint16_tPointer_128) { 
// function body 
vector <uint64_t> uint64_tVector_129;
fillVector(uint64_tVector_129, random() % 1000);
int8_t int8_tVar_130 = 5; 
vector <int16_t> int16_tVector_131;
fillVector(int16_tVector_131, random() % 1000);
map <int8_t, uint16_t> int8_tuint16_tMap_132;
fillMap(int8_tuint16_tMap_132, random() % 1000);
uint32_t uint32_tVar_133 = 21914; 
int8_t int8_tVar_134 = -3; 
uint64_t uint64_tVar_135 = 4613716; 
vector <int16_t> int16_tVector_136;
fillVector(int16_tVector_136, random() % 1000);
vector <uint32_t> uint32_tVector_137;
fillVector(uint32_tVector_137, random() % 1000);
uint64_t uint64_tVar_138 = 4613276; 
map <int16_t, uint64_t> int16_tuint64_tMap_139;
fillMap(int16_tuint64_tMap_139, random() % 1000);
int16_t int16_tVar_140 = 97; 
set <int16_t> int16_tSet_141;
fillSet(int16_tSet_141, random() % 1000);
int32_t int32_tVar_142 = -15732; 
int32_t int32_tVar_143 = 7511; 
int8_t int8_tArrayVar_144[1000];
fillArray(int8_tArrayVar_144);
uint16_t uint16_tVar_145 = 3761; 
int16_t int16_tVar_146 = -289; 
vector <int64_t> int64_tVector_147;
fillVector(int64_tVector_147, random() % 1000);
int32_t *int32_tPointer_148 = &int32_tVar_142; 
set <int32_t> int32_tSet_149;
fillSet(int32_tSet_149, random() % 1000);
uint32_t uint32_tVar_150 = 21524; 
vector <int16_t> int16_tVector_151;
fillVector(int16_tVector_151, random() % 1000);
vector <uint32_t> uint32_tVector_152;
fillVector(uint32_tVector_152, random() % 1000);
uint16_t uint16_tArrayVar_153[1000];
fillArray(uint16_tArrayVar_153);
uint8_t uint8_tVar_154 = 118; 
map <int8_t, uint32_t> int8_tuint32_tMap_155;
fillMap(int8_tuint32_tMap_155, random() % 1000);
map <int32_t, uint64_t> int32_tuint64_tMap_156;
fillMap(int32_tuint64_tMap_156, random() % 1000);
vector <int32_t> int32_tVector_157;
fillVector(int32_tVector_157, random() % 1000);
int16_t *int16_tPointer_158 = &int16_tVar_146; 
int64_t int64_tVar_159 = 4304; 
uint32_t uint32_tArrayVar_160[1000];
fillArray(uint32_tArrayVar_160);
int16_t int16_tVar_161 = -170; 
vector <uint16_t> uint16_tVector_162;
fillVector(uint16_tVector_162, random() % 1000);
map <int8_t, uint16_t> int8_tuint16_tMap_163;
fillMap(int8_tuint16_tMap_163, random() % 1000);
int16_t int16_tVar_164 = -260; 
int32_t int32_tArrayVar_165[1000];
fillArray(int32_tArrayVar_165);
int16_t int16_tVar_166 = -123;

uint64_t *uint64_tPointer_167 = &uint64_tVar_135;

int64_t int64_tIndVar_168 = 44; 
 while ( int64_tIndVar_168 >= -579 ){ 
int64_tIndVar_168 = int64_tIndVar_168 - 10; 
 int16_t int16_tIndVar_169 = 25; 
 while ( int16_tIndVar_169 >= -277 ){ 
int16_tIndVar_169 = int16_tIndVar_169 - 10; 
if ( true ) { 
if ( ((uint32_tVector_152  >  uint32_tVector_152)) ) { 
if ((int64_t)(((((((int8_tVar_130) - (int8_tVar_134)))  ==  (int8_tArrayVar_144[ (int8_tVar_134) % lengthArray(int8_tArrayVar_144)]))) + (int8_tArrayVar_144[ (int8_tVar_134) % lengthArray(int8_tArrayVar_144)])))) {

int32_t int32_tIndArraySafeVar_170 = 228; 
 while ( int32_tIndArraySafeVar_170 > 19 ){ 
int32_tIndArraySafeVar_170 = int32_tIndArraySafeVar_170 - 12;

} 
  uint32_tVector_152.swap(uint32_tVector_137); 
  if (!uint32_tVector_137.empty()) { 
sort(uint32_tVector_137.begin(), uint32_tVector_137.end());}
  if ( false ) { 
int16_tVar_164 |= ((((int16_tVar_166)  <  (((int16_t)int16_tSet_141.count(((int16_t)int16_tVar_140))))))  !=  ((( max((int16_t)(int16_tVar_166), (int16_t)(int16_tVar_166)) )  <<  12 ))); 
  if ( (uint32_t)((((((uint8_t)( max((uint8_t)(uint8_tVar_154), (uint8_t)(uint8_tVar_154)) )) + (uint8_tVar_154)))  >>  5 )) ) { 
int16_tuint64_tMap_139.clear(); 
   uint32_t uint32_tIndVar_171 = 123; 
 while ( uint32_tIndVar_171 <= 233 ){ 
uint32_tIndVar_171++; 
uint64_tPointer_167 = &uint64_tVar_135; 
  int64_tVar_159 -= (((((((this -> int64_tFieldVar_1))  >>  49 ))  <<  27 )) + ((((((int64_t)(this -> int64_tFieldVar_1))  >  ((this -> int64_tFieldVar_1)))) + ((((int64_t)(this -> int64_tFieldVar_1))  ==  ((int64_t)int64_tVar_159)))))); 
  int32_tVar_142 += (int32_tVector_157.empty() ? int32_tVar_143 : int32_tVector_157[(true) % int32_tVector_157.size()] ); 
  int8_tuint32_tMap_155.insert({(int8_tVar_130), (((int32_t)(abs(true))) ? (uint32_tVar_133) : ( min((uint32_t)(uint32_tVar_150), (uint32_t)(uint32_tVar_133--)) ))});

} 
  *uint64_tPointer_167 = (uint64_t)(((uint64_t)uint64_tVector_129.size())); 
  int16_tVar_161 %= ((int16_t)int16_tSet_141.count(((((int16_tVector_136.empty() ? int16_tVar_161 : int16_tVector_136.at((int16_tVar_140) % int16_tVector_136.size()))) + (int16_tVar_161))))); 
  int8_tuint16_tMap_163.insert({(((int8_tuint16_tMap_132.empty()) - (int8_tVar_130))), ((( *uint16_tPointer_128) + (uint16_tArrayVar_153[ (((uint16_tVar_145)  <<  1 )) % lengthArray(uint16_tArrayVar_153)])))}); 
  int16_tPointer_158 = &int16_tVar_164; 
  int16_tVector_151.emplace_back(((((uint16_t)(((uint16_tVar_145) - (uint16_tVar_145)))) ? ((((int16_t)(uint8_tVar_154)) - ( *int16_tPointer_158))) : (((uint16_t)(uint16_tVar_145)) ? (int16_tVar_146) : (int16_tVar_166))) - (--int16_tVar_166))); 
  int16_tVector_131.assign(random() % 1000, (abs((((int16_tVector_151.empty() ? int16_tVar_164 : int16_tVector_151.at(((int16_t)int16_tVar_166) % int16_tVector_151.size()))) + (int16_tVar_164))))); 
  int16_tVar_140 /= ((int16_t)int16_tSet_141.count((int16_tVar_146))); 
  
 } 
  int8_tuint16_tMap_163 = int8_tuint16_tMap_132; 
  
 } 
  
continue;
 } 
  
 } else {

} 
  
 } else {

}

} 
   return (uint16_t)(uint8_tVar_154--);

}

int32_t func_int32_t_int32_t_172( int32_t int32_tVar_173) { 
// function body 
map <uint8_t, uint16_t> uint8_tuint16_tMap_174;
fillMap(uint8_tuint16_tMap_174, random() % 1000);
uint64_t uint64_tVar_175 = 4618522; 
uint8_t uint8_tVar_176 = 123; 
uint32_t uint32_tVar_177 = 21765; 
vector <uint32_t> uint32_tVector_178;
fillVector(uint32_tVector_178, random() % 1000);
uint8_t uint8_tArrayVar_179[1000];
fillArray(uint8_tArrayVar_179);
uint16_t uint16_tArrayVar_180[1000];
fillArray(uint16_tArrayVar_180);
uint32_t uint32_tArrayVar_181[1000];
fillArray(uint32_tArrayVar_181);
uint8_t uint8_tVar_182 = 114; 
map <int32_t, int64_t> int32_tint64_tMap_183;
fillMap(int32_tint64_tMap_183, random() % 1000);
int16_t int16_tArrayVar_184[1000];
fillArray(int16_tArrayVar_184);
int32_t *int32_tPointer_185 = &int32_tVar_173; 
int32_t int32_tVar_186 = 16464; 
uint32_t *uint32_tPointer_187 = &uint32_tVar_177; 
uint8_t uint8_tVar_188 = 118; 
uint8_t uint8_tVar_189 = 121; 
vector <uint16_t> uint16_tVector_190;
fillVector(uint16_tVector_190, random() % 1000);
vector <bool> boolVector_191;
fillVector(boolVector_191, random() % 1000);
map <int64_t, bool> int64_tboolMap_192;
fillMap(int64_tboolMap_192, random() % 1000);
uint8_t uint8_tVar_193 = 116;

uint8_t *uint8_tPointer_194 = &uint8_tVar_188;

for ( int16_t int16_tIndArraySafeVar_195 = 5; 
int16_tIndArraySafeVar_195 < 60; int16_tIndArraySafeVar_195++) { 
if ( (int32_t)(func_int8_t_int8_t_93( /* func call */ 2 )) ) { 
if ((uint16_t)(uint16_tVector_190.empty())) {

uint32_tVector_178.resize( random() % 1000, (uint32_tArrayVar_181[ int16_tIndArraySafeVar_195 + 1])); 
  boolVector_191.resize( random() % 1000, ((int32_t)(-3134))); 
   switch (-9960) {
               default : {
 uint16_t uint16_tIndVar_196 = 29; 
do {

uint16_tIndVar_196 = uint16_tIndVar_196 - 10; 
}  while ( uint16_tIndVar_196 >= 121 ); 
       break; 
}
 }
  if ((uint64_t)(((uint16_tArrayVar_180[ int16_tIndArraySafeVar_195])  !=  (304)))) {

uint32_tVector_178.emplace_back(--uint32_tVar_177); 
  if (!uint16_tVector_190.empty()) { 
sort(uint16_tVector_190.begin(), uint16_tVector_190.end());}
  for ( int64_t int64_tIndVar_197 = -579; 
int64_tIndVar_197 <= 269; ++int64_tIndVar_197) { 
 switch (int32_tVar_173) {
               default : {
uint8_tVar_189 += uint8_tVar_176; 
       break; 
}
 }
  int32_tPointer_185 = &int32_tVar_173; 
   int64_t int64_tIndVar_198 = -577; 
 while ( int64_tIndVar_198 <= 270 ){ 
++int64_tIndVar_198; 
uint16_tVector_190.emplace_back(uint16_tArrayVar_180[ int16_tIndArraySafeVar_195]); 
  for ( uint32_t uint32_tIndVar_199 = 457; 
uint32_tIndVar_199 >= 123; --uint32_tIndVar_199) {

} 
  for ( int16_t int16_tIndVar_200 = -278; 
int16_tIndVar_200 < 73; int16_tIndVar_200++) { 
uint32_tVector_178.resize( random() % 1000, (((uint32_t)uint32_tVector_178.size()))); 
  uint32_tVar_177 +=  *uint32_tPointer_187;

} 
  uint8_tPointer_194 = &uint8_tVar_182; 
  uint8_tVar_176 += uint8_tArrayVar_179[ int16_tIndArraySafeVar_195]; 
  if (uint16_tVector_190.size() > 0)
    uint16_tVector_190.pop_back(); 
  uint8_tVar_193 += ((uint8_t)uint8_tuint16_tMap_174.max_size()); 
  int32_tint64_tMap_183.emplace((int32_tVar_173--), (30577));

}

} 
  
break;
 } 
  
continue;
 } 
  
 } else {

}

} 
   return int32_tVar_173;

}

string run() { 
int16_t int16_tArrayVar_201[1000];
fillArray(int16_tArrayVar_201);
map <uint32_t, int64_t> uint32_tint64_tMap_202;
fillMap(uint32_tint64_tMap_202, random() % 1000);
int64_t int64_tVar_203 = 37129; 
map <int32_t, int16_t> int32_tint16_tMap_204;
fillMap(int32_tint16_tMap_204, random() % 1000);
int64_t *int64_tPointer_205 = &int64_tVar_203; 
vector <uint16_t> uint16_tVector_206;
fillVector(uint16_tVector_206, random() % 1000);
set <int8_t> int8_tSet_207;
fillSet(int8_tSet_207, random() % 1000);
map <int32_t, uint8_t> int32_tuint8_tMap_208;
fillMap(int32_tuint8_tMap_208, random() % 1000);
uint16_t uint16_tVar_209 = 6229; 
set <int16_t> int16_tSet_210;
fillSet(int16_tSet_210, random() % 1000);
int8_t int8_tArrayVar_211[1000];
fillArray(int8_tArrayVar_211);
uint32_t uint32_tVar_212 = 21477; 
int64_t *int64_tPointer_213 = &int64_tVar_203; 
uint16_t uint16_tVar_214 = 4943; 
int64_t int64_tVar_215 = -4002; 
uint16_t uint16_tVar_216 = 1201; 
bool boolVar_217 = true; 
int16_t int16_tVar_218 = 223; 
uint8_t uint8_tArrayVar_219[1000];
fillArray(uint8_tArrayVar_219);
uint32_t uint32_tVar_220 = 21909; 
uint32_t *uint32_tPointer_221 = &uint32_tVar_212; 
uint64_t uint64_tVar_222 = 4617253; 
map <int32_t, uint8_t> int32_tuint8_tMap_223;
fillMap(int32_tuint8_tMap_223, random() % 1000);
vector <int8_t> int8_tVector_224;
fillVector(int8_tVector_224, random() % 1000);
set <uint8_t> uint8_tSet_225;
fillSet(uint8_tSet_225, random() % 1000);
uint16_t uint16_tVar_226 = 4051; 
uint16_t uint16_tVar_227 = 5577; 
uint8_t uint8_tVar_228 = 106; 
uint64_t uint64_tVar_229 = 4618282; 
uint8_t uint8_tVar_230 = 113; 
uint8_t uint8_tVar_231 = 122; 
map <uint8_t, uint64_t> uint8_tuint64_tMap_232;
fillMap(uint8_tuint64_tMap_232, random() % 1000);
int64_t int64_tArrayVar_233[1000];
fillArray(int64_tArrayVar_233);
int8_t int8_tVar_234 = -5; 
uint64_t uint64_tVar_235 = 4619914; 
map <int16_t, int16_t> int16_tint16_tMap_236;
fillMap(int16_tint16_tMap_236, random() % 1000);
map <int16_t, uint8_t> int16_tuint8_tMap_237;
fillMap(int16_tuint8_tMap_237, random() % 1000);
vector <int64_t> int64_tVector_238;
fillVector(int64_tVector_238, random() % 1000);
int64_t int64_tVar_239 = 6960; 
uint8_t uint8_tVar_240 = 101;

if ( (uint32_t)(boolVar_217) ) { 
if ( (int16_t)(func_int8_t_int8_t_93( /* func call */ func_int8_t_int8_t_3( /* func call */ func_int8_t_int8_t_3( /* func call */ int8_tVar_234 ) ) )) ) { 
 uint64_t uint64_tIndVar_241 = 122; 
do { 
if ( boolVar_217 ) { 
if ( boolVar_217 ) { 
for (auto &ARRAY_VARint8_tRefIterator_242: int8_tArrayVar_211) {
 int32_t int32_tIndArraySafeVar_243 = 16; 
 while ( int32_tIndArraySafeVar_243 <= 140 ){ 
int32_tIndArraySafeVar_243 = int32_tIndArraySafeVar_243 + 19; 
for ( uint64_t uint64_tIndArraySafeVar_244 = 8; 
uint64_tIndArraySafeVar_244 <= 470; uint64_tIndArraySafeVar_244++) { 
if ((int16_t)((((int32_t)(((((6880) * (16458))) + ((int32_t)4791))))  >>  0 ))) {

uint8_tVar_230 = this->uint8_tArrayFieldVar_2[ int32_tIndArraySafeVar_243 + 4]; 
  int64_tVar_239 -= int64_tArrayVar_233[ uint64_tIndArraySafeVar_244]; 
  uint16_tVar_209 -= uint16_tVar_214; 
  uint16_tVar_227 = (uint16_tVector_206.empty() ? (uint16_t)uint16_tVar_214 : uint16_tVector_206.at((((uint16_tVar_214) / (uint16_tVar_209))) % uint16_tVector_206.size())); 
  
break;
 } 
  if ( (int8_t)((((int64_t)(this->uint8_tArrayFieldVar_2[ int32_tIndArraySafeVar_243 + 7])) - ((int64_t)(((int64_t)int64_tVector_238.size()))))) ) { 
 uint64_t uint64_tIndVar_245 = 123; 
 while ( uint64_tIndVar_245 < 526 ){ 
++uint64_tIndVar_245;

} 
  uint8_tVar_231 ^= ((((uint8_tVar_240)  >>  7 )) * (this->uint8_tArrayFieldVar_2[ int32_tIndArraySafeVar_243])); 
  int64_tVar_215 = int64_tArrayVar_233[ int32_tIndArraySafeVar_243]; 
  uint32_tVar_220 = --uint32_tVar_212; 
   int16_t int16_tIndVar_246 = 125; 
 while ( int16_tIndVar_246 > -278 ){ 
int16_tIndVar_246--; 
uint16_tVar_227 -= uint16_tVar_227; 
  uint8_tVar_230 *=  max((uint8_t)(((uint8_t)uint8_tuint64_tMap_232.max_size())), (uint8_t)(uint8_tArrayVar_219[ int32_tIndArraySafeVar_243 + 2])) ; 
  ARRAY_VARint8_tRefIterator_242 = (int8_t)((int8_t)(int8_tArrayVar_211[ uint64_tIndArraySafeVar_244])); 
  int64_tVar_203 |=  min((int64_t)(int64_tVar_215), (int64_t)(int64_tArrayVar_233[ int32_tIndArraySafeVar_243])) ;

} 
  
 } else {

} 
  uint16_tVar_214 -= (uint16_t)uint16_tVar_216;

} 
   uint8_t uint8_tIndVar_247 = -2; 
 while ( uint8_tIndVar_247 >= 16 ){ 
uint8_tIndVar_247 = uint8_tIndVar_247 - 4;

}

} 
  
} 
  
 } else {

} 
  
 } else {

}

uint64_tIndVar_241++; 
}  while ( uint64_tIndVar_241 <= 461 ); 
  
 } else {

} 
  
 } else {

} 
  string result = "";
result += "int8_tVector_224 " + to_string(print(int8_tVector_224)); 
result += "int64_tArrayVar_233 " + to_string(print(int64_tArrayVar_233)); 
result += "uint64_tVar_222,uint64_tVar_229,uint64_tVar_235 " + to_string(uint64_tVar_222) + to_string(uint64_tVar_229) + to_string(uint64_tVar_235); 
result += "int64_tPointer_205,int64_tPointer_213 " + to_string(*int64_tPointer_205) + to_string(*int64_tPointer_213); 
result += "int32_tint16_tMap_204 " + to_string(print(int32_tint16_tMap_204)); 
result += "int8_tSet_207 " + to_string(print(int8_tSet_207)); 
result += "uint8_tVar_228,uint8_tVar_230,uint8_tVar_231,uint8_tVar_240 " + to_string(uint8_tVar_228) + to_string(uint8_tVar_230) + to_string(uint8_tVar_231) + to_string(uint8_tVar_240); 
result += "uint16_tVar_209,uint16_tVar_214,uint16_tVar_216,uint16_tVar_226,uint16_tVar_227 " + to_string(uint16_tVar_209) + to_string(uint16_tVar_214) + to_string(uint16_tVar_216) + to_string(uint16_tVar_226) + to_string(uint16_tVar_227); 
result += "int64_tVar_203,int64_tVar_215,int64_tVar_239 " + to_string(int64_tVar_203) + to_string(int64_tVar_215) + to_string(int64_tVar_239); 
result += "int32_tuint8_tMap_208,int32_tuint8_tMap_223 " + to_string(print(int32_tuint8_tMap_208)) + to_string(print(int32_tuint8_tMap_223)); 
result += "int16_tuint8_tMap_237 " + to_string(print(int16_tuint8_tMap_237)); 
result += "int8_tVar_234 " + to_string(int8_tVar_234); 
result += "int16_tArrayVar_201 " + to_string(print(int16_tArrayVar_201)); 
result += "uint32_tVar_212,uint32_tVar_220 " + to_string(uint32_tVar_212) + to_string(uint32_tVar_220); 
result += "int8_tArrayVar_211 " + to_string(print(int8_tArrayVar_211)); 
result += "uint8_tSet_225 " + to_string(print(uint8_tSet_225)); 
result += "uint8_tuint64_tMap_232 " + to_string(print(uint8_tuint64_tMap_232)); 
result += "uint32_tPointer_221 " + to_string(*uint32_tPointer_221); 
result += "uint16_tVector_206 " + to_string(print(uint16_tVector_206)); 
result += "int16_tSet_210 " + to_string(print(int16_tSet_210)); 
result += "boolVar_217 " + to_string(boolVar_217); 
result += "int16_tVar_218 " + to_string(int16_tVar_218); 
result += "int64_tVector_238 " + to_string(print(int64_tVector_238)); 
result += "uint8_tArrayVar_219 " + to_string(print(uint8_tArrayVar_219)); 
result += "uint32_tint64_tMap_202 " + to_string(print(uint32_tint64_tMap_202)); 
result += "int16_tint16_tMap_236 " + to_string(print(int16_tint16_tMap_236)); 
    return result;
}
};

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