
/*
CF3

Copyright (c) 2015 ishiura-lab.

Released under the MIT license.  
https://github.com/ishiura-compiler/CF3/MIT-LICENSE.md
*/

#include<stdio.h>
#include<stdint.h>
#include<stdlib.h>
#include"test1.h"

int32_t t0 = 197;
int32_t x14 = INT32_MAX;
volatile uint64_t t1 = 222274872158LLU;
int64_t t2 = -62502152959908079LL;
static int32_t x29 = -1;
static volatile uint64_t t4 = UINT64_MAX;
uint64_t x43 = 141255498259LLU;
volatile int32_t x44 = -1;
uint64_t x46 = 8LLU;
static uint32_t x52 = UINT32_MAX;
int64_t x68 = -1LL;
volatile int64_t t10 = -62LL;
volatile uint32_t t12 = 54U;
static int64_t x85 = -209213LL;
int64_t x94 = INT64_MIN;
int16_t x95 = INT16_MIN;
int32_t x96 = INT32_MIN;
static volatile int64_t x101 = 4139058979316131597LL;
int32_t x109 = -4879296;
int8_t x124 = -1;
volatile int64_t t20 = 20LL;
int8_t x136 = INT8_MIN;
int32_t x140 = INT32_MAX;
int64_t x146 = INT64_MIN;
static volatile uint64_t x147 = 3074391186607694164LLU;
int64_t x163 = -1LL;
static volatile int32_t x164 = INT32_MIN;
volatile uint16_t x192 = 2U;
int8_t x200 = INT8_MAX;
volatile uint64_t t31 = 70LLU;
uint64_t t34 = 256493LLU;
static uint64_t x216 = 1LLU;
uint64_t t35 = 10200689072LLU;
uint32_t x218 = UINT32_MAX;
volatile uint32_t t36 = 977946248U;
static int64_t x229 = -1LL;
int8_t x232 = INT8_MAX;
volatile uint32_t t39 = 387836U;
static uint32_t t42 = 30584U;
uint32_t t44 = 431311U;
static int32_t t46 = -12;
int8_t x282 = 0;
int16_t x287 = 496;
static uint32_t t49 = 1U;
volatile int32_t t50 = -55432;
uint16_t x297 = UINT16_MAX;
uint32_t x301 = UINT32_MAX;
volatile uint32_t t52 = 361878U;
static uint32_t x314 = UINT32_MAX;
uint64_t x317 = UINT64_MAX;
int8_t x333 = INT8_MIN;
int8_t x337 = INT8_MAX;
int32_t x353 = INT32_MIN;
uint32_t x359 = 6585U;
static int16_t x361 = -1;
int8_t x372 = INT8_MIN;
uint8_t x373 = 4U;
int32_t x381 = INT32_MIN;
int32_t x383 = INT32_MIN;
uint64_t x408 = UINT64_MAX;
uint32_t x418 = UINT32_MAX;
static int8_t x419 = INT8_MIN;
volatile uint32_t t78 = 6620U;
volatile int64_t x441 = -1LL;
uint32_t x447 = 562U;
uint16_t x448 = UINT16_MAX;
uint32_t t82 = 587U;
volatile uint8_t x477 = 1U;
uint8_t x488 = 99U;
int16_t x501 = -1;
uint8_t x502 = 0U;
uint8_t x503 = UINT8_MAX;
volatile int8_t x509 = 1;
static uint8_t x510 = UINT8_MAX;
int32_t x513 = INT32_MIN;
volatile uint64_t t91 = 4LLU;
uint32_t x520 = UINT32_MAX;
int32_t x529 = INT32_MIN;
uint32_t x540 = UINT32_MAX;
uint32_t x555 = 3531776U;
uint16_t x568 = 20386U;
uint16_t x570 = 49U;
int16_t x576 = INT16_MAX;
int16_t x591 = -1;
uint16_t x592 = 47U;
int64_t x605 = -1LL;
volatile int64_t x613 = -1LL;
int8_t x622 = INT8_MIN;
int64_t t112 = 52255447LL;
int64_t t114 = -1LL;
static int32_t x657 = 15580;
volatile int8_t x660 = -1;
volatile uint64_t t116 = 100139959410379LLU;
int64_t x674 = -3949643123125016LL;
static int16_t x676 = -115;
uint32_t x679 = 74204375U;
int8_t x688 = INT8_MAX;
uint16_t x691 = UINT16_MAX;
volatile uint64_t x692 = 691356745590985LLU;
volatile int16_t x693 = 0;
int8_t x698 = INT8_MIN;
volatile uint64_t t123 = 416753770464324LLU;
uint8_t x702 = 0U;
volatile int64_t x707 = -1LL;
uint64_t t125 = 370699792LLU;
uint32_t x714 = 26U;
uint16_t x719 = 0U;
int8_t x721 = INT8_MIN;
uint8_t x723 = UINT8_MAX;
static volatile int16_t x728 = 1;
volatile uint8_t x729 = 3U;
int32_t t131 = -1;
static int64_t x744 = -1LL;
static int8_t x747 = INT8_MIN;
static int32_t t134 = 5;
static int32_t x750 = -1;
static uint32_t x751 = 431342U;
uint64_t t135 = 12080472200LLU;
static volatile int32_t x763 = -1;
uint16_t x767 = 4880U;
int8_t x773 = INT8_MAX;
static volatile uint16_t x776 = UINT16_MAX;
int8_t x783 = INT8_MAX;
static uint32_t x787 = 26U;
volatile uint16_t x796 = 29U;
uint32_t x800 = 362U;
int64_t t143 = 1LL;
uint64_t x802 = 57633771025288LLU;
volatile int16_t x804 = 1256;
uint16_t x806 = UINT16_MAX;
int32_t x823 = 3747;
int32_t x830 = INT32_MIN;
int16_t x835 = -1;
int16_t x843 = -1;
volatile int8_t x847 = INT8_MAX;
volatile int8_t x848 = INT8_MAX;
static volatile int32_t t152 = -128283;
int8_t x853 = INT8_MIN;
int32_t x854 = -25;
int8_t x855 = -1;
uint64_t t154 = 33LLU;
volatile uint64_t t155 = 3206387835828LLU;
uint16_t x880 = 1U;
volatile uint64_t t156 = 1293LLU;
volatile uint8_t x881 = 0U;
uint16_t x891 = UINT16_MAX;
int64_t x896 = 2142539115341835823LL;
uint16_t x899 = UINT16_MAX;
int64_t t164 = 1785585630LL;
int8_t x928 = INT8_MAX;
static volatile int32_t x934 = INT32_MIN;
uint8_t x937 = 43U;
uint64_t x938 = UINT64_MAX;
static volatile uint64_t t167 = 1LLU;
int8_t x959 = INT8_MIN;
int32_t x972 = -1;
volatile uint16_t x973 = 468U;
int16_t x974 = -1;
int32_t x993 = 2836445;
uint8_t x1001 = 6U;
int8_t x1013 = INT8_MIN;
static int8_t x1014 = INT8_MAX;
static int16_t x1027 = INT16_MAX;
int32_t x1050 = INT32_MIN;
int64_t x1051 = -1LL;
int16_t x1061 = 2047;
int64_t t191 = 180249LL;
uint32_t x1067 = 3879381U;
int64_t x1069 = -1LL;
int32_t x1079 = INT32_MAX;
uint8_t x1080 = 33U;
int8_t x1081 = 1;
uint8_t x1083 = UINT8_MAX;
int16_t x1085 = -1;
int8_t x1099 = INT8_MAX;


void f0(void) {
    	static int8_t x5 = -5;
	uint8_t x6 = UINT8_MAX;
	static uint8_t x7 = 50U;
	int8_t x8 = INT8_MIN;

    t0 = (x5*((x6^x7)+x8));

    if (t0 != -385) { NG(); } else { ; }
	
}

void f1(void) {
    	uint32_t x13 = 52U;
	int16_t x15 = INT16_MIN;
	static uint64_t x16 = UINT64_MAX;

    t1 = (x13*((x14^x15)+x16));

    if (t1 != 18446743962042105752LLU) { NG(); } else { ; }
	
}

void f2(void) {
    	uint8_t x21 = 115U;
	volatile int8_t x22 = INT8_MIN;
	int16_t x23 = INT16_MIN;
	int64_t x24 = 504217693LL;

    t2 = (x21*((x22^x23)+x24));

    if (t2 != 57988788295LL) { NG(); } else { ; }
	
}

void f3(void) {
    	int16_t x25 = INT16_MIN;
	uint8_t x26 = 8U;
	int64_t x27 = 1968619LL;
	uint64_t x28 = 2428148252373091LLU;
	uint64_t t3 = 1483386915LLU;

    t3 = (x25*((x26^x27)+x28));

    if (t3 != 12668158370278866944LLU) { NG(); } else { ; }
	
}

void f4(void) {
    	int8_t x30 = -3;
	volatile uint64_t x31 = UINT64_MAX;
	int16_t x32 = -1;

    t4 = (x29*((x30^x31)+x32));

    if (t4 != UINT64_MAX) { NG(); } else { ; }
	
}

void f5(void) {
    	uint32_t x33 = 25029U;
	uint16_t x34 = UINT16_MAX;
	static int32_t x35 = 2538;
	int8_t x36 = -5;
	volatile uint32_t t5 = 18585U;

    t5 = (x33*((x34^x35)+x36));

    if (t5 != 1576626768U) { NG(); } else { ; }
	
}

void f6(void) {
    	static int64_t x41 = INT64_MIN;
	int8_t x42 = INT8_MIN;
	static uint64_t t6 = 780194440557056LLU;

    t6 = (x41*((x42^x43)+x44));

    if (t6 != 0LLU) { NG(); } else { ; }
	
}

void f7(void) {
    	static volatile uint64_t x45 = UINT64_MAX;
	int16_t x47 = INT16_MIN;
	static int32_t x48 = INT32_MAX;
	volatile uint64_t t7 = 11031807942090650LLU;

    t7 = (x45*((x46^x47)+x48));

    if (t7 != 18446744071562100729LLU) { NG(); } else { ; }
	
}

void f8(void) {
    	volatile int32_t x49 = INT32_MAX;
	int8_t x50 = -1;
	uint16_t x51 = UINT16_MAX;
	uint32_t t8 = 859U;

    t8 = (x49*((x50^x51)+x52));

    if (t8 != 2147549185U) { NG(); } else { ; }
	
}

void f9(void) {
    	int8_t x53 = 57;
	int64_t x54 = 0LL;
	static uint8_t x55 = 2U;
	int16_t x56 = 216;
	static volatile int64_t t9 = -232LL;

    t9 = (x53*((x54^x55)+x56));

    if (t9 != 12426LL) { NG(); } else { ; }
	
}

void f10(void) {
    	volatile int16_t x65 = INT16_MAX;
	int8_t x66 = INT8_MAX;
	int8_t x67 = INT8_MIN;

    t10 = (x65*((x66^x67)+x68));

    if (t10 != -65534LL) { NG(); } else { ; }
	
}

void f11(void) {
    	volatile int64_t x73 = -1LL;
	static int8_t x74 = 56;
	int32_t x75 = INT32_MIN;
	static int16_t x76 = 10;
	static int64_t t11 = 467331LL;

    t11 = (x73*((x74^x75)+x76));

    if (t11 != 2147483582LL) { NG(); } else { ; }
	
}

void f12(void) {
    	int32_t x77 = 1;
	volatile int32_t x78 = -3640;
	static volatile uint32_t x79 = 1U;
	int16_t x80 = -8813;

    t12 = (x77*((x78^x79)+x80));

    if (t12 != 4294954844U) { NG(); } else { ; }
	
}

void f13(void) {
    	uint64_t x86 = UINT64_MAX;
	int32_t x87 = -1;
	static int32_t x88 = -1;
	static uint64_t t13 = 994950260075461LLU;

    t13 = (x85*((x86^x87)+x88));

    if (t13 != 209213LLU) { NG(); } else { ; }
	
}

void f14(void) {
    	int8_t x93 = -1;
	static volatile int64_t t14 = -49962409534LL;

    t14 = (x93*((x94^x95)+x96));

    if (t14 != -9223372034707259392LL) { NG(); } else { ; }
	
}

void f15(void) {
    	volatile int32_t x102 = INT32_MIN;
	int64_t x103 = INT64_MIN;
	uint64_t x104 = UINT64_MAX;
	static uint64_t t15 = 3507LLU;

    t15 = (x101*((x102^x103)+x104));

    if (t15 != 2543241052517079283LLU) { NG(); } else { ; }
	
}

void f16(void) {
    	int8_t x105 = -1;
	volatile uint16_t x106 = 125U;
	int8_t x107 = INT8_MIN;
	uint32_t x108 = 37783U;
	volatile uint32_t t16 = 16U;

    t16 = (x105*((x106^x107)+x108));

    if (t16 != 4294929516U) { NG(); } else { ; }
	
}

void f17(void) {
    	int64_t x110 = INT64_MIN;
	volatile uint64_t x111 = 3806629013667LLU;
	static volatile int64_t x112 = INT64_MIN;
	static uint64_t t17 = 448584228879LLU;

    t17 = (x109*((x110^x111)+x112));

    if (t17 != 18319818427549764800LLU) { NG(); } else { ; }
	
}

void f18(void) {
    	volatile int32_t x117 = -1;
	volatile int32_t x118 = -173;
	int16_t x119 = INT16_MIN;
	volatile uint16_t x120 = UINT16_MAX;
	int32_t t18 = 61467;

    t18 = (x117*((x118^x119)+x120));

    if (t18 != -98130) { NG(); } else { ; }
	
}

void f19(void) {
    	volatile uint8_t x121 = UINT8_MAX;
	static uint16_t x122 = UINT16_MAX;
	int32_t x123 = 73;
	int32_t t19 = 8764;

    t19 = (x121*((x122^x123)+x124));

    if (t19 != 16692555) { NG(); } else { ; }
	
}

void f20(void) {
    	uint8_t x125 = 3U;
	int64_t x126 = -1LL;
	static int16_t x127 = INT16_MIN;
	uint8_t x128 = UINT8_MAX;

    t20 = (x125*((x126^x127)+x128));

    if (t20 != 99066LL) { NG(); } else { ; }
	
}

void f21(void) {
    	volatile int64_t x133 = -96249534493119LL;
	volatile int8_t x134 = INT8_MAX;
	int64_t x135 = 66LL;
	volatile int64_t t21 = -62607LL;

    t21 = (x133*((x134^x135)+x136));

    if (t21 != 6448718811038973LL) { NG(); } else { ; }
	
}

void f22(void) {
    	uint8_t x137 = 1U;
	static volatile int16_t x138 = 1;
	uint64_t x139 = UINT64_MAX;
	static volatile uint64_t t22 = 12LLU;

    t22 = (x137*((x138^x139)+x140));

    if (t22 != 2147483645LLU) { NG(); } else { ; }
	
}

void f23(void) {
    	static int8_t x141 = -1;
	int8_t x142 = INT8_MIN;
	int64_t x143 = -6288828561677LL;
	volatile int64_t x144 = -14895LL;
	static int64_t t23 = -14829LL;

    t23 = (x141*((x142^x143)+x144));

    if (t23 != -6288828546884LL) { NG(); } else { ; }
	
}

void f24(void) {
    	static int8_t x145 = 1;
	int64_t x148 = INT64_MAX;
	volatile uint64_t t24 = 6408807152944LLU;

    t24 = (x145*((x146^x147)+x148));

    if (t24 != 3074391186607694163LLU) { NG(); } else { ; }
	
}

void f25(void) {
    	int8_t x149 = -1;
	volatile int64_t x150 = INT64_MIN;
	volatile int64_t x151 = INT64_MIN;
	uint32_t x152 = UINT32_MAX;
	volatile int64_t t25 = -298LL;

    t25 = (x149*((x150^x151)+x152));

    if (t25 != -4294967295LL) { NG(); } else { ; }
	
}

void f26(void) {
    	uint16_t x157 = 1U;
	static int16_t x158 = INT16_MIN;
	uint8_t x159 = UINT8_MAX;
	int8_t x160 = INT8_MAX;
	volatile int32_t t26 = 188898884;

    t26 = (x157*((x158^x159)+x160));

    if (t26 != -32386) { NG(); } else { ; }
	
}

void f27(void) {
    	uint16_t x161 = 1135U;
	int64_t x162 = -1LL;
	volatile int64_t t27 = 152283085257802741LL;

    t27 = (x161*((x162^x163)+x164));

    if (t27 != -2437393940480LL) { NG(); } else { ; }
	
}

void f28(void) {
    	static uint64_t x181 = UINT64_MAX;
	int32_t x182 = INT32_MIN;
	static int16_t x183 = -14;
	int16_t x184 = -1;
	volatile uint64_t t28 = 5LLU;

    t28 = (x181*((x182^x183)+x184));

    if (t28 != 18446744071562067983LLU) { NG(); } else { ; }
	
}

void f29(void) {
    	static int32_t x189 = INT32_MAX;
	static uint8_t x190 = 27U;
	static uint32_t x191 = 45133U;
	uint32_t t29 = 88983U;

    t29 = (x189*((x190^x191)+x192));

    if (t29 != 4294922152U) { NG(); } else { ; }
	
}

void f30(void) {
    	static int32_t x193 = -102500;
	uint8_t x194 = UINT8_MAX;
	int16_t x195 = 0;
	uint64_t x196 = 4649013LLU;
	uint64_t t30 = 2084520LLU;

    t30 = (x193*((x194^x195)+x196));

    if (t30 != 18446743597159581616LLU) { NG(); } else { ; }
	
}

void f31(void) {
    	int16_t x197 = 10852;
	int16_t x198 = -1;
	uint64_t x199 = 1134038146LLU;

    t31 = (x197*((x198^x199)+x200));

    if (t31 != 18446731767128958576LLU) { NG(); } else { ; }
	
}

void f32(void) {
    	int8_t x201 = 4;
	volatile uint64_t x202 = UINT64_MAX;
	static uint8_t x203 = 45U;
	volatile uint16_t x204 = UINT16_MAX;
	static volatile uint64_t t32 = 270LLU;

    t32 = (x201*((x202^x203)+x204));

    if (t32 != 261956LLU) { NG(); } else { ; }
	
}

void f33(void) {
    	uint64_t x205 = 11201312LLU;
	int16_t x206 = INT16_MIN;
	int16_t x207 = INT16_MIN;
	static int16_t x208 = 11;
	uint64_t t33 = 26352247579LLU;

    t33 = (x205*((x206^x207)+x208));

    if (t33 != 123214432LLU) { NG(); } else { ; }
	
}

void f34(void) {
    	int32_t x209 = INT32_MIN;
	int32_t x210 = INT32_MIN;
	int64_t x211 = INT64_MAX;
	uint64_t x212 = 1700388718657041949LLU;

    t34 = (x209*((x210^x211)+x212));

    if (t34 != 15433489516706398208LLU) { NG(); } else { ; }
	
}

void f35(void) {
    	int8_t x213 = INT8_MIN;
	volatile int64_t x214 = -56094LL;
	int32_t x215 = INT32_MIN;

    t35 = (x213*((x214^x215)+x216));

    if (t35 != 18446743798838824576LLU) { NG(); } else { ; }
	
}

void f36(void) {
    	int16_t x217 = -1;
	int8_t x219 = INT8_MIN;
	uint32_t x220 = 89172687U;

    t36 = (x217*((x218^x219)+x220));

    if (t36 != 4205794482U) { NG(); } else { ; }
	
}

void f37(void) {
    	int8_t x221 = -1;
	int32_t x222 = INT32_MIN;
	int32_t x223 = INT32_MAX;
	uint32_t x224 = 0U;
	volatile uint32_t t37 = 17U;

    t37 = (x221*((x222^x223)+x224));

    if (t37 != 1U) { NG(); } else { ; }
	
}

void f38(void) {
    	int16_t x230 = INT16_MIN;
	static int8_t x231 = INT8_MIN;
	volatile int64_t t38 = 1025410LL;

    t38 = (x229*((x230^x231)+x232));

    if (t38 != -32767LL) { NG(); } else { ; }
	
}

void f39(void) {
    	volatile uint32_t x233 = 4U;
	uint8_t x234 = 13U;
	int8_t x235 = 14;
	static uint32_t x236 = 7456U;

    t39 = (x233*((x234^x235)+x236));

    if (t39 != 29836U) { NG(); } else { ; }
	
}

void f40(void) {
    	uint64_t x237 = UINT64_MAX;
	int16_t x238 = -1;
	uint16_t x239 = UINT16_MAX;
	static int8_t x240 = INT8_MAX;
	static volatile uint64_t t40 = 4735953394662139332LLU;

    t40 = (x237*((x238^x239)+x240));

    if (t40 != 65409LLU) { NG(); } else { ; }
	
}

void f41(void) {
    	int8_t x241 = INT8_MIN;
	volatile int32_t x242 = -1;
	static uint16_t x243 = 287U;
	static uint8_t x244 = 1U;
	int32_t t41 = -14;

    t41 = (x241*((x242^x243)+x244));

    if (t41 != 36736) { NG(); } else { ; }
	
}

void f42(void) {
    	uint32_t x253 = 140U;
	static uint16_t x254 = 60U;
	static int32_t x255 = -1;
	int16_t x256 = 152;

    t42 = (x253*((x254^x255)+x256));

    if (t42 != 12740U) { NG(); } else { ; }
	
}

void f43(void) {
    	uint8_t x257 = UINT8_MAX;
	int32_t x258 = INT32_MIN;
	int64_t x259 = 547714408517470LL;
	uint32_t x260 = 111U;
	int64_t t43 = 3809796835408105LL;

    t43 = (x257*((x258^x259)+x260));

    if (t43 != -139667287475110605LL) { NG(); } else { ; }
	
}

void f44(void) {
    	uint32_t x261 = UINT32_MAX;
	static int32_t x262 = INT32_MIN;
	volatile uint8_t x263 = 2U;
	volatile uint8_t x264 = UINT8_MAX;

    t44 = (x261*((x262^x263)+x264));

    if (t44 != 2147483391U) { NG(); } else { ; }
	
}

void f45(void) {
    	volatile int32_t x265 = 5425;
	uint64_t x266 = 519775326883168LLU;
	volatile int8_t x267 = INT8_MIN;
	uint64_t x268 = UINT64_MAX;
	uint64_t t45 = 11615LLU;

    t45 = (x265*((x266^x267)+x268));

    if (t45 != 15626962925368706991LLU) { NG(); } else { ; }
	
}

void f46(void) {
    	uint16_t x277 = 17U;
	int8_t x278 = 0;
	static uint16_t x279 = 712U;
	uint16_t x280 = UINT16_MAX;

    t46 = (x277*((x278^x279)+x280));

    if (t46 != 1126199) { NG(); } else { ; }
	
}

void f47(void) {
    	volatile int64_t x281 = 5287452873242786LL;
	volatile uint64_t x283 = 113186953669314LLU;
	volatile int8_t x284 = -24;
	uint64_t t47 = 134866142814LLU;

    t47 = (x281*((x282^x283)+x284));

    if (t47 != 2582957846864211860LLU) { NG(); } else { ; }
	
}

void f48(void) {
    	volatile uint32_t x285 = 12035470U;
	uint16_t x286 = 49U;
	static int64_t x288 = -814816195LL;
	volatile int64_t t48 = 99100048759219629LL;

    t48 = (x285*((x286^x287)+x288));

    if (t48 != -9806690466510620LL) { NG(); } else { ; }
	
}

void f49(void) {
    	uint16_t x289 = 484U;
	static int8_t x290 = INT8_MIN;
	int32_t x291 = INT32_MIN;
	uint32_t x292 = UINT32_MAX;

    t49 = (x289*((x290^x291)+x292));

    if (t49 != 4294904860U) { NG(); } else { ; }
	
}

void f50(void) {
    	volatile uint16_t x293 = 211U;
	uint8_t x294 = 39U;
	static uint8_t x295 = 31U;
	int8_t x296 = INT8_MAX;

    t50 = (x293*((x294^x295)+x296));

    if (t50 != 38613) { NG(); } else { ; }
	
}

void f51(void) {
    	uint8_t x298 = UINT8_MAX;
	int8_t x299 = INT8_MIN;
	volatile int8_t x300 = 1;
	volatile int32_t t51 = 6020344;

    t51 = (x297*((x298^x299)+x300));

    if (t51 != -8388480) { NG(); } else { ; }
	
}

void f52(void) {
    	int32_t x302 = -22;
	static int8_t x303 = 54;
	static int8_t x304 = -3;

    t52 = (x301*((x302^x303)+x304));

    if (t52 != 39U) { NG(); } else { ; }
	
}

void f53(void) {
    	uint32_t x305 = 2028208836U;
	volatile int16_t x306 = 166;
	static int8_t x307 = -1;
	volatile int32_t x308 = -1;
	volatile uint32_t t53 = 17U;

    t53 = (x305*((x306^x307)+x308));

    if (t53 != 2858299232U) { NG(); } else { ; }
	
}

void f54(void) {
    	int8_t x309 = -10;
	int16_t x310 = -29;
	static int32_t x311 = -1;
	static uint16_t x312 = 6U;
	static volatile int32_t t54 = -19138;

    t54 = (x309*((x310^x311)+x312));

    if (t54 != -340) { NG(); } else { ; }
	
}

void f55(void) {
    	volatile int16_t x313 = INT16_MIN;
	volatile int16_t x315 = 8231;
	int16_t x316 = 7458;
	uint32_t t55 = 20011891U;

    t55 = (x313*((x314^x315)+x316));

    if (t55 != 25362432U) { NG(); } else { ; }
	
}

void f56(void) {
    	int64_t x318 = INT64_MIN;
	volatile uint16_t x319 = 47U;
	int16_t x320 = 1;
	static volatile uint64_t t56 = 1680181941109542373LLU;

    t56 = (x317*((x318^x319)+x320));

    if (t56 != 9223372036854775760LLU) { NG(); } else { ; }
	
}

void f57(void) {
    	uint64_t x321 = UINT64_MAX;
	uint64_t x322 = 24LLU;
	int8_t x323 = INT8_MIN;
	volatile int64_t x324 = INT64_MIN;
	static volatile uint64_t t57 = 297351018755LLU;

    t57 = (x321*((x322^x323)+x324));

    if (t57 != 9223372036854775912LLU) { NG(); } else { ; }
	
}

void f58(void) {
    	int8_t x325 = INT8_MIN;
	volatile int64_t x326 = -1LL;
	volatile int8_t x327 = INT8_MAX;
	int8_t x328 = -1;
	volatile int64_t t58 = -1516204LL;

    t58 = (x325*((x326^x327)+x328));

    if (t58 != 16512LL) { NG(); } else { ; }
	
}

void f59(void) {
    	static int16_t x329 = 0;
	static uint16_t x330 = UINT16_MAX;
	uint64_t x331 = 1721615011704LLU;
	int8_t x332 = 0;
	uint64_t t59 = 3394263003LLU;

    t59 = (x329*((x330^x331)+x332));

    if (t59 != 0LLU) { NG(); } else { ; }
	
}

void f60(void) {
    	int32_t x334 = -56;
	uint32_t x335 = 1397501U;
	volatile int32_t x336 = 11547;
	uint32_t t60 = 428789554U;

    t60 = (x333*((x334^x335)+x336));

    if (t60 != 177395712U) { NG(); } else { ; }
	
}

void f61(void) {
    	int32_t x338 = -1;
	int16_t x339 = -1;
	static int32_t x340 = -1;
	int32_t t61 = 1485;

    t61 = (x337*((x338^x339)+x340));

    if (t61 != -127) { NG(); } else { ; }
	
}

void f62(void) {
    	volatile int32_t x341 = -2;
	int32_t x342 = -4;
	uint64_t x343 = 849008LLU;
	int64_t x344 = INT64_MIN;
	static volatile uint64_t t62 = 3913175407718138LLU;

    t62 = (x341*((x342^x343)+x344));

    if (t62 != 1698024LLU) { NG(); } else { ; }
	
}

void f63(void) {
    	volatile uint8_t x345 = 1U;
	volatile int16_t x346 = INT16_MIN;
	int8_t x347 = INT8_MIN;
	volatile uint16_t x348 = 709U;
	volatile int32_t t63 = 22347141;

    t63 = (x345*((x346^x347)+x348));

    if (t63 != 33349) { NG(); } else { ; }
	
}

void f64(void) {
    	int16_t x349 = INT16_MAX;
	static volatile int16_t x350 = 1;
	static uint16_t x351 = 1U;
	volatile int8_t x352 = INT8_MIN;
	int32_t t64 = 54;

    t64 = (x349*((x350^x351)+x352));

    if (t64 != -4194176) { NG(); } else { ; }
	
}

void f65(void) {
    	uint64_t x354 = UINT64_MAX;
	int8_t x355 = INT8_MAX;
	uint64_t x356 = 4251181606298056LLU;
	volatile uint64_t t65 = 1857387787LLU;

    t65 = (x353*((x354^x355)+x356));

    if (t65 != 5998107904027131904LLU) { NG(); } else { ; }
	
}

void f66(void) {
    	volatile int32_t x357 = INT32_MAX;
	int16_t x358 = INT16_MIN;
	int16_t x360 = -2437;
	volatile uint32_t t66 = 3118U;

    t66 = (x357*((x358^x359)+x360));

    if (t66 != 28620U) { NG(); } else { ; }
	
}

void f67(void) {
    	uint64_t x362 = 2029192996LLU;
	volatile int64_t x363 = 11011517516353LL;
	uint32_t x364 = 591U;
	uint64_t t67 = 44902793134LLU;

    t67 = (x361*((x362^x363)+x364));

    if (t67 != 18446733062866464844LLU) { NG(); } else { ; }
	
}

void f68(void) {
    	uint32_t x365 = 988U;
	int32_t x366 = INT32_MAX;
	static uint32_t x367 = 411U;
	int32_t x368 = -1;
	uint32_t t68 = 2995610U;

    t68 = (x365*((x366^x367)+x368));

    if (t68 != 4294559252U) { NG(); } else { ; }
	
}

void f69(void) {
    	static volatile int16_t x369 = INT16_MAX;
	uint64_t x370 = 2694644837216LLU;
	uint16_t x371 = 3U;
	uint64_t t69 = 100058665838564286LLU;

    t69 = (x369*((x370^x371)+x372));

    if (t69 != 88295427376960797LLU) { NG(); } else { ; }
	
}

void f70(void) {
    	uint8_t x374 = 1U;
	volatile int16_t x375 = INT16_MAX;
	int64_t x376 = 35356639LL;
	volatile int64_t t70 = 2420LL;

    t70 = (x373*((x374^x375)+x376));

    if (t70 != 141557620LL) { NG(); } else { ; }
	
}

void f71(void) {
    	volatile int16_t x382 = INT16_MIN;
	volatile uint32_t x384 = UINT32_MAX;
	volatile uint32_t t71 = 476633U;

    t71 = (x381*((x382^x383)+x384));

    if (t71 != 2147483648U) { NG(); } else { ; }
	
}

void f72(void) {
    	static volatile int8_t x385 = 0;
	uint16_t x386 = UINT16_MAX;
	int16_t x387 = INT16_MIN;
	volatile uint64_t x388 = 18168LLU;
	static uint64_t t72 = 2904883337019LLU;

    t72 = (x385*((x386^x387)+x388));

    if (t72 != 0LLU) { NG(); } else { ; }
	
}

void f73(void) {
    	int64_t x401 = -1LL;
	static uint16_t x402 = 2U;
	volatile int64_t x403 = INT64_MIN;
	uint16_t x404 = 5U;
	int64_t t73 = -20505338305LL;

    t73 = (x401*((x402^x403)+x404));

    if (t73 != 9223372036854775801LL) { NG(); } else { ; }
	
}

void f74(void) {
    	volatile int16_t x405 = -3;
	static int16_t x406 = INT16_MAX;
	uint32_t x407 = 93681U;
	volatile uint64_t t74 = 3LLU;

    t74 = (x405*((x406^x407)+x408));

    if (t74 != 18446744073709341145LLU) { NG(); } else { ; }
	
}

void f75(void) {
    	uint8_t x413 = 0U;
	uint8_t x414 = 89U;
	volatile int32_t x415 = INT32_MIN;
	int64_t x416 = -2433971142LL;
	int64_t t75 = 34014072309885954LL;

    t75 = (x413*((x414^x415)+x416));

    if (t75 != 0LL) { NG(); } else { ; }
	
}

void f76(void) {
    	static volatile uint64_t x417 = UINT64_MAX;
	volatile int32_t x420 = 2564;
	uint64_t t76 = 15178802146LLU;

    t76 = (x417*((x418^x419)+x420));

    if (t76 != 18446744073709548925LLU) { NG(); } else { ; }
	
}

void f77(void) {
    	static uint32_t x421 = 2356U;
	int32_t x422 = INT32_MIN;
	volatile int8_t x423 = INT8_MAX;
	volatile int16_t x424 = 8584;
	uint32_t t77 = 68U;

    t77 = (x421*((x422^x423)+x424));

    if (t77 != 20523116U) { NG(); } else { ; }
	
}

void f78(void) {
    	int8_t x425 = INT8_MIN;
	uint8_t x426 = 11U;
	volatile int8_t x427 = INT8_MIN;
	static uint32_t x428 = UINT32_MAX;

    t78 = (x425*((x426^x427)+x428));

    if (t78 != 15104U) { NG(); } else { ; }
	
}

void f79(void) {
    	static int8_t x429 = 10;
	volatile uint64_t x430 = 65392563LLU;
	int8_t x431 = INT8_MIN;
	uint8_t x432 = UINT8_MAX;
	uint64_t t79 = 652200LLU;

    t79 = (x429*((x430^x431)+x432));

    if (t79 != 18446744073055628276LLU) { NG(); } else { ; }
	
}

void f80(void) {
    	static uint64_t x442 = UINT64_MAX;
	uint64_t x443 = 1809LLU;
	static int32_t x444 = INT32_MIN;
	volatile uint64_t t80 = 602394LLU;

    t80 = (x441*((x442^x443)+x444));

    if (t80 != 2147485458LLU) { NG(); } else { ; }
	
}

void f81(void) {
    	uint32_t x445 = UINT32_MAX;
	uint32_t x446 = UINT32_MAX;
	volatile uint32_t t81 = 9U;

    t81 = (x445*((x446^x447)+x448));

    if (t81 != 4294902324U) { NG(); } else { ; }
	
}

void f82(void) {
    	uint16_t x449 = UINT16_MAX;
	static volatile int32_t x450 = INT32_MAX;
	uint32_t x451 = 1711U;
	int8_t x452 = -51;

    t82 = (x449*((x450^x451)+x452));

    if (t82 != 2031945443U) { NG(); } else { ; }
	
}

void f83(void) {
    	int16_t x465 = 106;
	int32_t x466 = INT32_MIN;
	int8_t x467 = INT8_MIN;
	int64_t x468 = -1LL;
	int64_t t83 = 1359049172048064LL;

    t83 = (x465*((x466^x467)+x468));

    if (t83 != 227633253014LL) { NG(); } else { ; }
	
}

void f84(void) {
    	volatile int8_t x469 = -1;
	uint32_t x470 = 1077U;
	uint16_t x471 = UINT16_MAX;
	int8_t x472 = INT8_MIN;
	uint32_t t84 = 4379310U;

    t84 = (x469*((x470^x471)+x472));

    if (t84 != 4294902966U) { NG(); } else { ; }
	
}

void f85(void) {
    	int32_t x478 = INT32_MIN;
	static int16_t x479 = INT16_MIN;
	static volatile int32_t x480 = 191;
	int32_t t85 = 16615966;

    t85 = (x477*((x478^x479)+x480));

    if (t85 != 2147451071) { NG(); } else { ; }
	
}

void f86(void) {
    	int16_t x485 = -1;
	int32_t x486 = -748549;
	volatile int64_t x487 = -1LL;
	volatile int64_t t86 = 6578067LL;

    t86 = (x485*((x486^x487)+x488));

    if (t86 != -748647LL) { NG(); } else { ; }
	
}

void f87(void) {
    	volatile uint16_t x493 = 8U;
	static uint16_t x494 = UINT16_MAX;
	uint64_t x495 = 461LLU;
	int16_t x496 = 14;
	volatile uint64_t t87 = 75529676083130151LLU;

    t87 = (x493*((x494^x495)+x496));

    if (t87 != 520704LLU) { NG(); } else { ; }
	
}

void f88(void) {
    	volatile uint8_t x497 = UINT8_MAX;
	static int32_t x498 = INT32_MIN;
	uint64_t x499 = 472204LLU;
	static int64_t x500 = INT64_MAX;
	uint64_t t88 = 1619842243LLU;

    t88 = (x497*((x498^x499)+x500));

    if (t88 != 9223371489366857333LLU) { NG(); } else { ; }
	
}

void f89(void) {
    	int64_t x504 = INT64_MIN;
	static volatile int64_t t89 = 78274LL;

    t89 = (x501*((x502^x503)+x504));

    if (t89 != 9223372036854775553LL) { NG(); } else { ; }
	
}

void f90(void) {
    	volatile int32_t x511 = INT32_MIN;
	int8_t x512 = INT8_MIN;
	volatile int32_t t90 = -5931;

    t90 = (x509*((x510^x511)+x512));

    if (t90 != -2147483521) { NG(); } else { ; }
	
}

void f91(void) {
    	static int16_t x514 = INT16_MIN;
	int64_t x515 = -1LL;
	static volatile uint64_t x516 = 188051348LLU;

    t91 = (x513*((x514^x515)+x516));

    if (t91 != 18042836512298500096LLU) { NG(); } else { ; }
	
}

void f92(void) {
    	int8_t x517 = INT8_MIN;
	volatile int32_t x518 = -1;
	int8_t x519 = INT8_MIN;
	static volatile uint32_t t92 = 30517952U;

    t92 = (x517*((x518^x519)+x520));

    if (t92 != 4294951168U) { NG(); } else { ; }
	
}

void f93(void) {
    	volatile int16_t x525 = -8008;
	static uint32_t x526 = UINT32_MAX;
	static int16_t x527 = INT16_MIN;
	volatile uint8_t x528 = 1U;
	static uint32_t t93 = 76864U;

    t93 = (x525*((x526^x527)+x528));

    if (t93 != 4032561152U) { NG(); } else { ; }
	
}

void f94(void) {
    	int64_t x530 = 533LL;
	volatile int64_t x531 = 43LL;
	volatile uint32_t x532 = 94347U;
	static int64_t t94 = -282280614442LL;

    t94 = (x529*((x530^x531)+x532));

    if (t94 != -203841295351808LL) { NG(); } else { ; }
	
}

void f95(void) {
    	static int8_t x533 = 54;
	int16_t x534 = -1;
	static int32_t x535 = -26;
	int8_t x536 = INT8_MIN;
	volatile int32_t t95 = -46657024;

    t95 = (x533*((x534^x535)+x536));

    if (t95 != -5562) { NG(); } else { ; }
	
}

void f96(void) {
    	int8_t x537 = INT8_MIN;
	volatile uint8_t x538 = 0U;
	uint8_t x539 = UINT8_MAX;
	uint32_t t96 = 6U;

    t96 = (x537*((x538^x539)+x540));

    if (t96 != 4294934784U) { NG(); } else { ; }
	
}

void f97(void) {
    	uint8_t x541 = UINT8_MAX;
	int8_t x542 = -1;
	int64_t x543 = -49302LL;
	int8_t x544 = -30;
	int64_t t97 = -3219LL;

    t97 = (x541*((x542^x543)+x544));

    if (t97 != 12564105LL) { NG(); } else { ; }
	
}

void f98(void) {
    	int64_t x553 = 28935376399LL;
	uint16_t x554 = 6U;
	int16_t x556 = INT16_MAX;
	int64_t t98 = 16424804806959132LL;

    t98 = (x553*((x554^x555)+x556));

    if (t98 != 103141567007679051LL) { NG(); } else { ; }
	
}

void f99(void) {
    	uint64_t x557 = 194LLU;
	int32_t x558 = INT32_MIN;
	int64_t x559 = 0LL;
	uint32_t x560 = UINT32_MAX;
	uint64_t t99 = 1158LLU;

    t99 = (x557*((x558^x559)+x560));

    if (t99 != 416611827518LLU) { NG(); } else { ; }
	
}

void f100(void) {
    	volatile int8_t x561 = -1;
	int32_t x562 = INT32_MIN;
	int32_t x563 = -1;
	static int16_t x564 = INT16_MIN;
	int32_t t100 = 337422996;

    t100 = (x561*((x562^x563)+x564));

    if (t100 != -2147450879) { NG(); } else { ; }
	
}

void f101(void) {
    	int16_t x565 = -1;
	int8_t x566 = INT8_MIN;
	uint8_t x567 = 2U;
	int32_t t101 = 465203;

    t101 = (x565*((x566^x567)+x568));

    if (t101 != -20260) { NG(); } else { ; }
	
}

void f102(void) {
    	int8_t x569 = 62;
	uint8_t x571 = UINT8_MAX;
	uint8_t x572 = 23U;
	static volatile int32_t t102 = -1;

    t102 = (x569*((x570^x571)+x572));

    if (t102 != 14198) { NG(); } else { ; }
	
}

void f103(void) {
    	int16_t x573 = 14;
	int8_t x574 = 17;
	int8_t x575 = 1;
	int32_t t103 = 5059086;

    t103 = (x573*((x574^x575)+x576));

    if (t103 != 458962) { NG(); } else { ; }
	
}

void f104(void) {
    	int8_t x581 = INT8_MIN;
	uint32_t x582 = 14409621U;
	int32_t x583 = -1;
	int32_t x584 = -1;
	volatile uint32_t t104 = 2004U;

    t104 = (x581*((x582^x583)+x584));

    if (t104 != 1844431744U) { NG(); } else { ; }
	
}

void f105(void) {
    	int16_t x589 = INT16_MAX;
	static volatile uint8_t x590 = 127U;
	int32_t t105 = 17315;

    t105 = (x589*((x590^x591)+x592));

    if (t105 != -2654127) { NG(); } else { ; }
	
}

void f106(void) {
    	uint16_t x593 = 6517U;
	uint64_t x594 = 1930455171LLU;
	volatile uint32_t x595 = 1467649353U;
	int16_t x596 = INT16_MIN;
	static uint64_t t106 = 70578971230LLU;

    t106 = (x593*((x594^x595)+x596));

    if (t106 != 3981578420050LLU) { NG(); } else { ; }
	
}

void f107(void) {
    	uint64_t x597 = 6LLU;
	int16_t x598 = INT16_MAX;
	int64_t x599 = 4400435530434366521LL;
	int16_t x600 = INT16_MIN;
	volatile uint64_t t107 = 64543597045487LLU;

    t107 = (x597*((x598^x599)+x600));

    if (t107 != 7955869108896413348LLU) { NG(); } else { ; }
	
}

void f108(void) {
    	int32_t x606 = INT32_MIN;
	int32_t x607 = INT32_MIN;
	static volatile uint16_t x608 = UINT16_MAX;
	int64_t t108 = 63855256LL;

    t108 = (x605*((x606^x607)+x608));

    if (t108 != -65535LL) { NG(); } else { ; }
	
}

void f109(void) {
    	static uint64_t x614 = 4024LLU;
	static int64_t x615 = INT64_MIN;
	int16_t x616 = INT16_MAX;
	static volatile uint64_t t109 = 8445793662092LLU;

    t109 = (x613*((x614^x615)+x616));

    if (t109 != 9223372036854739017LLU) { NG(); } else { ; }
	
}

void f110(void) {
    	int32_t x621 = -326825;
	uint8_t x623 = 0U;
	int8_t x624 = INT8_MAX;
	static int32_t t110 = -6834680;

    t110 = (x621*((x622^x623)+x624));

    if (t110 != 326825) { NG(); } else { ; }
	
}

void f111(void) {
    	static int32_t x625 = 704;
	uint32_t x626 = 0U;
	int16_t x627 = -1;
	int8_t x628 = -1;
	uint32_t t111 = 218U;

    t111 = (x625*((x626^x627)+x628));

    if (t111 != 4294965888U) { NG(); } else { ; }
	
}

void f112(void) {
    	static uint8_t x629 = 5U;
	uint8_t x630 = UINT8_MAX;
	static volatile int64_t x631 = -541535395118330LL;
	int8_t x632 = INT8_MIN;

    t112 = (x629*((x630^x631)+x632));

    if (t112 != -2707676975591075LL) { NG(); } else { ; }
	
}

void f113(void) {
    	uint16_t x641 = 76U;
	volatile uint32_t x642 = UINT32_MAX;
	int8_t x643 = -1;
	int8_t x644 = INT8_MIN;
	volatile uint32_t t113 = 1776655286U;

    t113 = (x641*((x642^x643)+x644));

    if (t113 != 4294957568U) { NG(); } else { ; }
	
}

void f114(void) {
    	static int8_t x653 = -1;
	int64_t x654 = -2327LL;
	int64_t x655 = -65401078382LL;
	static int32_t x656 = -1;

    t114 = (x653*((x654^x655)+x656));

    if (t114 != -65401080698LL) { NG(); } else { ; }
	
}

void f115(void) {
    	volatile int16_t x658 = 338;
	int32_t x659 = -63;
	volatile int32_t t115 = -648911;

    t115 = (x657*((x658^x659)+x660));

    if (t115 != -5702280) { NG(); } else { ; }
	
}

void f116(void) {
    	uint64_t x665 = UINT64_MAX;
	int8_t x666 = INT8_MIN;
	volatile int32_t x667 = INT32_MIN;
	uint64_t x668 = 1012628LLU;

    t116 = (x665*((x666^x667)+x668));

    if (t116 != 18446744071561055468LLU) { NG(); } else { ; }
	
}

void f117(void) {
    	static uint8_t x673 = 6U;
	int8_t x675 = -63;
	volatile int64_t t117 = 1799440384166LL;

    t117 = (x673*((x674^x675)+x676));

    if (t117 != 23697858738749508LL) { NG(); } else { ; }
	
}

void f118(void) {
    	volatile uint32_t x677 = 80275579U;
	uint32_t x678 = UINT32_MAX;
	volatile int8_t x680 = -1;
	uint32_t t118 = 976U;

    t118 = (x677*((x678^x679)+x680));

    if (t118 != 2483962813U) { NG(); } else { ; }
	
}

void f119(void) {
    	int8_t x681 = INT8_MIN;
	static uint32_t x682 = 4090U;
	volatile int32_t x683 = -1035;
	uint8_t x684 = 1U;
	static uint32_t t119 = 130268036U;

    t119 = (x681*((x682^x683)+x684));

    if (t119 != 391168U) { NG(); } else { ; }
	
}

void f120(void) {
    	int16_t x685 = 1;
	int32_t x686 = -1;
	int16_t x687 = INT16_MAX;
	static int32_t t120 = 31;

    t120 = (x685*((x686^x687)+x688));

    if (t120 != -32641) { NG(); } else { ; }
	
}

void f121(void) {
    	static int8_t x689 = 1;
	int64_t x690 = 1001161146713LL;
	uint64_t t121 = 711LLU;

    t121 = (x689*((x690^x691)+x692));

    if (t121 != 692357906704239LLU) { NG(); } else { ; }
	
}

void f122(void) {
    	int32_t x694 = 3537;
	uint32_t x695 = UINT32_MAX;
	static volatile uint16_t x696 = 1U;
	volatile uint32_t t122 = 15U;

    t122 = (x693*((x694^x695)+x696));

    if (t122 != 0U) { NG(); } else { ; }
	
}

void f123(void) {
    	int16_t x697 = -12479;
	uint64_t x699 = 6LLU;
	uint16_t x700 = 11U;

    t123 = (x697*((x698^x699)+x700));

    if (t123 != 1385169LLU) { NG(); } else { ; }
	
}

void f124(void) {
    	uint32_t x701 = UINT32_MAX;
	uint64_t x703 = 2443167275LLU;
	volatile int32_t x704 = 212;
	volatile uint64_t t124 = 9857262293991712LLU;

    t124 = (x701*((x702^x703)+x704));

    if (t124 != 10493324452872337665LLU) { NG(); } else { ; }
	
}

void f125(void) {
    	static uint64_t x705 = 2LLU;
	int16_t x706 = -36;
	uint16_t x708 = 2542U;

    t125 = (x705*((x706^x707)+x708));

    if (t125 != 5154LLU) { NG(); } else { ; }
	
}

void f126(void) {
    	int32_t x709 = INT32_MIN;
	int64_t x710 = 33274027LL;
	static volatile uint32_t x711 = UINT32_MAX;
	uint64_t x712 = UINT64_MAX;
	static uint64_t t126 = 3886LLU;

    t126 = (x709*((x710^x711)+x712));

    if (t126 != 9294827470035353600LLU) { NG(); } else { ; }
	
}

void f127(void) {
    	volatile int8_t x713 = INT8_MIN;
	static int64_t x715 = -267355950907331LL;
	volatile uint8_t x716 = 23U;
	int64_t t127 = 1701866041228LL;

    t127 = (x713*((x714^x715)+x716));

    if (t127 != 34221561716138240LL) { NG(); } else { ; }
	
}

void f128(void) {
    	int8_t x717 = INT8_MIN;
	uint64_t x718 = 18LLU;
	volatile int8_t x720 = INT8_MAX;
	volatile uint64_t t128 = 344914798989992233LLU;

    t128 = (x717*((x718^x719)+x720));

    if (t128 != 18446744073709533056LLU) { NG(); } else { ; }
	
}

void f129(void) {
    	int16_t x722 = INT16_MIN;
	int16_t x724 = INT16_MAX;
	volatile int32_t t129 = 29124186;

    t129 = (x721*((x722^x723)+x724));

    if (t129 != -32512) { NG(); } else { ; }
	
}

void f130(void) {
    	int64_t x725 = INT64_MAX;
	volatile uint16_t x726 = UINT16_MAX;
	uint64_t x727 = UINT64_MAX;
	volatile uint64_t t130 = 262810522654901LLU;

    t130 = (x725*((x726^x727)+x728));

    if (t130 != 9223372036854841343LLU) { NG(); } else { ; }
	
}

void f131(void) {
    	static int8_t x730 = 15;
	int16_t x731 = INT16_MIN;
	int16_t x732 = INT16_MIN;

    t131 = (x729*((x730^x731)+x732));

    if (t131 != -196563) { NG(); } else { ; }
	
}

void f132(void) {
    	uint64_t x737 = 158286847471023LLU;
	uint32_t x738 = 2U;
	int64_t x739 = INT64_MIN;
	uint64_t x740 = UINT64_MAX;
	volatile uint64_t t132 = 64LLU;

    t132 = (x737*((x738^x739)+x740));

    if (t132 != 9223530323702246831LLU) { NG(); } else { ; }
	
}

void f133(void) {
    	int64_t x741 = INT64_MIN;
	uint64_t x742 = 132851718LLU;
	int32_t x743 = INT32_MIN;
	volatile uint64_t t133 = 566149LLU;

    t133 = (x741*((x742^x743)+x744));

    if (t133 != 9223372036854775808LLU) { NG(); } else { ; }
	
}

void f134(void) {
    	int32_t x745 = -1;
	int16_t x746 = -4;
	int8_t x748 = -1;

    t134 = (x745*((x746^x747)+x748));

    if (t134 != -123) { NG(); } else { ; }
	
}

void f135(void) {
    	volatile int64_t x749 = INT64_MIN;
	uint64_t x752 = 2LLU;

    t135 = (x749*((x750^x751)+x752));

    if (t135 != 9223372036854775808LLU) { NG(); } else { ; }
	
}

void f136(void) {
    	uint64_t x761 = 122507473462364226LLU;
	uint64_t x762 = 30058624409000LLU;
	static int8_t x764 = 2;
	uint64_t t136 = 6LLU;

    t136 = (x761*((x762^x763)+x764));

    if (t136 != 2366653455077384946LLU) { NG(); } else { ; }
	
}

void f137(void) {
    	volatile int32_t x765 = INT32_MIN;
	volatile uint64_t x766 = 1836316946LLU;
	static volatile int32_t x768 = INT32_MAX;
	volatile uint64_t t137 = 5588579548LLU;

    t137 = (x765*((x766^x767)+x768));

    if (t137 != 9891605724046295040LLU) { NG(); } else { ; }
	
}

void f138(void) {
    	uint16_t x774 = 10U;
	volatile int16_t x775 = -617;
	volatile int32_t t138 = -101;

    t138 = (x773*((x774^x775)+x776));

    if (t138 != 8245348) { NG(); } else { ; }
	
}

void f139(void) {
    	volatile uint16_t x781 = 255U;
	static volatile int32_t x782 = 358;
	int16_t x784 = -13;
	volatile int32_t t139 = 194429988;

    t139 = (x781*((x782^x783)+x784));

    if (t139 != 68340) { NG(); } else { ; }
	
}

void f140(void) {
    	int16_t x785 = INT16_MAX;
	volatile int64_t x786 = -3LL;
	uint16_t x788 = 220U;
	int64_t t140 = 760424197664676LL;

    t140 = (x785*((x786^x787)+x788));

    if (t140 != 6389565LL) { NG(); } else { ; }
	
}

void f141(void) {
    	volatile uint32_t x789 = UINT32_MAX;
	uint64_t x790 = 946690924LLU;
	volatile int16_t x791 = 53;
	int32_t x792 = INT32_MIN;
	volatile uint64_t t141 = 236834175081470LLU;

    t141 = (x789*((x790^x791)+x792));

    if (t141 != 13289378514451211431LLU) { NG(); } else { ; }
	
}

void f142(void) {
    	uint32_t x793 = 5U;
	uint32_t x794 = 2U;
	uint32_t x795 = 407723140U;
	volatile uint32_t t142 = 79171294U;

    t142 = (x793*((x794^x795)+x796));

    if (t142 != 2038615855U) { NG(); } else { ; }
	
}

void f143(void) {
    	volatile int8_t x797 = -1;
	volatile int64_t x798 = INT64_MAX;
	int64_t x799 = INT64_MIN;

    t143 = (x797*((x798^x799)+x800));

    if (t143 != -361LL) { NG(); } else { ; }
	
}

void f144(void) {
    	static int16_t x801 = INT16_MIN;
	static uint16_t x803 = 12464U;
	volatile uint64_t t144 = 16656758501167661LLU;

    t144 = (x801*((x802^x803)+x804));

    if (t144 != 16558200665117032448LLU) { NG(); } else { ; }
	
}

void f145(void) {
    	int32_t x805 = -50656;
	uint16_t x807 = UINT16_MAX;
	uint64_t x808 = 259206LLU;
	volatile uint64_t t145 = 2834986756LLU;

    t145 = (x805*((x806^x807)+x808));

    if (t145 != 18446744060579212480LLU) { NG(); } else { ; }
	
}

void f146(void) {
    	static uint64_t x809 = 11836033864249LLU;
	volatile int64_t x810 = -1LL;
	int8_t x811 = INT8_MIN;
	int8_t x812 = -1;
	volatile uint64_t t146 = 84144911LLU;

    t146 = (x809*((x810^x811)+x812));

    if (t146 != 1491340266895374LLU) { NG(); } else { ; }
	
}

void f147(void) {
    	uint16_t x817 = 4U;
	int32_t x818 = -1;
	uint8_t x819 = 1U;
	uint32_t x820 = UINT32_MAX;
	uint32_t t147 = 5121969U;

    t147 = (x817*((x818^x819)+x820));

    if (t147 != 4294967284U) { NG(); } else { ; }
	
}

void f148(void) {
    	int16_t x821 = 2;
	int64_t x822 = -337LL;
	int8_t x824 = 2;
	static int64_t t148 = 96240366026207LL;

    t148 = (x821*((x822^x823)+x824));

    if (t148 != -8164LL) { NG(); } else { ; }
	
}

void f149(void) {
    	volatile int64_t x829 = 155LL;
	int16_t x831 = -1;
	int64_t x832 = 3673LL;
	int64_t t149 = 47866367772335LL;

    t149 = (x829*((x830^x831)+x832));

    if (t149 != 332860534600LL) { NG(); } else { ; }
	
}

void f150(void) {
    	int32_t x833 = 3;
	uint64_t x834 = 18LLU;
	uint32_t x836 = UINT32_MAX;
	static volatile uint64_t t150 = 5907LLU;

    t150 = (x833*((x834^x835)+x836));

    if (t150 != 12884901828LLU) { NG(); } else { ; }
	
}

void f151(void) {
    	uint32_t x841 = UINT32_MAX;
	volatile uint32_t x842 = 28606U;
	static int8_t x844 = INT8_MIN;
	volatile uint32_t t151 = 109U;

    t151 = (x841*((x842^x843)+x844));

    if (t151 != 28735U) { NG(); } else { ; }
	
}

void f152(void) {
    	int8_t x845 = -1;
	int8_t x846 = INT8_MAX;

    t152 = (x845*((x846^x847)+x848));

    if (t152 != -127) { NG(); } else { ; }
	
}

void f153(void) {
    	uint32_t x856 = 118973637U;
	uint32_t t153 = 669U;

    t153 = (x853*((x854^x855)+x856));

    if (t153 != 1951240576U) { NG(); } else { ; }
	
}

void f154(void) {
    	static int64_t x857 = -4338LL;
	volatile uint64_t x858 = UINT64_MAX;
	uint32_t x859 = 450847231U;
	static uint32_t x860 = UINT32_MAX;

    t154 = (x857*((x858^x859)+x860));

    if (t154 != 18446727397916718322LLU) { NG(); } else { ; }
	
}

void f155(void) {
    	uint16_t x861 = 1362U;
	uint64_t x862 = 2010453485LLU;
	volatile uint32_t x863 = UINT32_MAX;
	int8_t x864 = -15;

    t155 = (x861*((x862^x863)+x864));

    if (t155 != 3111507788790LLU) { NG(); } else { ; }
	
}

void f156(void) {
    	static uint64_t x877 = UINT64_MAX;
	volatile uint16_t x878 = 15U;
	int16_t x879 = INT16_MIN;

    t156 = (x877*((x878^x879)+x880));

    if (t156 != 32752LLU) { NG(); } else { ; }
	
}

void f157(void) {
    	static int32_t x882 = INT32_MAX;
	int64_t x883 = -1LL;
	int8_t x884 = 15;
	volatile int64_t t157 = -322876894447LL;

    t157 = (x881*((x882^x883)+x884));

    if (t157 != 0LL) { NG(); } else { ; }
	
}

void f158(void) {
    	uint64_t x885 = 34394566709143LLU;
	int32_t x886 = INT32_MAX;
	int64_t x887 = INT64_MAX;
	int64_t x888 = 262823357LL;
	volatile uint64_t t158 = 518328654920699LLU;

    t158 = (x885*((x886^x887)+x888));

    if (t158 != 9007944179860413819LLU) { NG(); } else { ; }
	
}

void f159(void) {
    	uint64_t x889 = UINT64_MAX;
	int8_t x890 = INT8_MAX;
	int32_t x892 = INT32_MIN;
	volatile uint64_t t159 = 6751639894LLU;

    t159 = (x889*((x890^x891)+x892));

    if (t159 != 2147418240LLU) { NG(); } else { ; }
	
}

void f160(void) {
    	int16_t x893 = -1;
	volatile int8_t x894 = 9;
	int8_t x895 = INT8_MIN;
	int64_t t160 = 7264998291491LL;

    t160 = (x893*((x894^x895)+x896));

    if (t160 != -2142539115341835704LL) { NG(); } else { ; }
	
}

void f161(void) {
    	uint64_t x897 = UINT64_MAX;
	uint16_t x898 = UINT16_MAX;
	static int16_t x900 = -1;
	uint64_t t161 = 22943999798LLU;

    t161 = (x897*((x898^x899)+x900));

    if (t161 != 1LLU) { NG(); } else { ; }
	
}

void f162(void) {
    	int64_t x905 = -2340254LL;
	static volatile uint32_t x906 = 112U;
	uint16_t x907 = UINT16_MAX;
	int64_t x908 = -171LL;
	int64_t t162 = -22074LL;

    t162 = (x905*((x906^x907)+x908));

    if (t162 != -152706254008LL) { NG(); } else { ; }
	
}

void f163(void) {
    	volatile int32_t x917 = -1;
	int8_t x918 = INT8_MIN;
	int64_t x919 = INT64_MAX;
	volatile uint32_t x920 = 113U;
	volatile int64_t t163 = -25724867LL;

    t163 = (x917*((x918^x919)+x920));

    if (t163 != 9223372036854775568LL) { NG(); } else { ; }
	
}

void f164(void) {
    	static uint8_t x921 = UINT8_MAX;
	static int64_t x922 = -3346515LL;
	int64_t x923 = -1LL;
	static int16_t x924 = INT16_MIN;

    t164 = (x921*((x922^x923)+x924));

    if (t164 != 845005230LL) { NG(); } else { ; }
	
}

void f165(void) {
    	volatile int64_t x925 = -1560LL;
	uint32_t x926 = 11302U;
	uint16_t x927 = UINT16_MAX;
	volatile int64_t t165 = -26021614LL;

    t165 = (x925*((x926^x927)+x928));

    if (t165 != -84801600LL) { NG(); } else { ; }
	
}

void f166(void) {
    	static uint8_t x933 = 11U;
	int16_t x935 = INT16_MIN;
	int64_t x936 = 54128424450257LL;
	int64_t t166 = 1957413784226325975LL;

    t166 = (x933*((x934^x935)+x936));

    if (t166 != 595436290912507LL) { NG(); } else { ; }
	
}

void f167(void) {
    	static int16_t x939 = INT16_MIN;
	uint16_t x940 = UINT16_MAX;

    t167 = (x937*((x938^x939)+x940));

    if (t167 != 4226986LLU) { NG(); } else { ; }
	
}

void f168(void) {
    	int16_t x945 = INT16_MAX;
	uint32_t x946 = UINT32_MAX;
	static int16_t x947 = 0;
	uint16_t x948 = 86U;
	static volatile uint32_t t168 = 49U;

    t168 = (x945*((x946^x947)+x948));

    if (t168 != 2785195U) { NG(); } else { ; }
	
}

void f169(void) {
    	static uint64_t x949 = 23728274LLU;
	volatile int16_t x950 = -1;
	static uint8_t x951 = UINT8_MAX;
	uint32_t x952 = 238248507U;
	static uint64_t t169 = 18LLU;

    t169 = (x949*((x950^x951)+x952));

    if (t169 != 5653219779748774LLU) { NG(); } else { ; }
	
}

void f170(void) {
    	int32_t x957 = -57020660;
	int32_t x958 = INT32_MIN;
	uint32_t x960 = 869U;
	static volatile uint32_t t170 = 27016423U;

    t170 = (x957*((x958^x959)+x960));

    if (t170 != 697363900U) { NG(); } else { ; }
	
}

void f171(void) {
    	volatile int64_t x961 = -1LL;
	uint32_t x962 = 67139142U;
	int64_t x963 = -1LL;
	uint64_t x964 = 5LLU;
	volatile uint64_t t171 = 15195944979890LLU;

    t171 = (x961*((x962^x963)+x964));

    if (t171 != 67139138LLU) { NG(); } else { ; }
	
}

void f172(void) {
    	uint32_t x969 = UINT32_MAX;
	uint8_t x970 = 7U;
	static int32_t x971 = 261210;
	static volatile uint32_t t172 = 174508834U;

    t172 = (x969*((x970^x971)+x972));

    if (t172 != 4294706084U) { NG(); } else { ; }
	
}

void f173(void) {
    	int16_t x975 = INT16_MAX;
	int8_t x976 = INT8_MIN;
	volatile int32_t t173 = 1;

    t173 = (x973*((x974^x975)+x976));

    if (t173 != -15395328) { NG(); } else { ; }
	
}

void f174(void) {
    	int16_t x977 = 1227;
	volatile uint32_t x978 = 743U;
	int16_t x979 = 12;
	static uint8_t x980 = UINT8_MAX;
	uint32_t t174 = 545481U;

    t174 = (x977*((x978^x979)+x980));

    if (t174 != 1229454U) { NG(); } else { ; }
	
}

void f175(void) {
    	static int16_t x981 = -1;
	uint8_t x982 = 66U;
	static int32_t x983 = 446657;
	volatile int64_t x984 = -1LL;
	int64_t t175 = -9318397536354LL;

    t175 = (x981*((x982^x983)+x984));

    if (t175 != -446594LL) { NG(); } else { ; }
	
}

void f176(void) {
    	int64_t x985 = -5544LL;
	int8_t x986 = -7;
	int32_t x987 = 30210;
	volatile int16_t x988 = INT16_MIN;
	int64_t t176 = 3511471528960LL;

    t176 = (x985*((x986^x987)+x988));

    if (t176 != 349166664LL) { NG(); } else { ; }
	
}

void f177(void) {
    	uint16_t x989 = UINT16_MAX;
	uint32_t x990 = 330186U;
	static volatile int16_t x991 = INT16_MAX;
	uint16_t x992 = 1U;
	uint32_t t177 = 4143U;

    t177 = (x989*((x990^x991)+x992));

    if (t177 != 1982892490U) { NG(); } else { ; }
	
}

void f178(void) {
    	volatile uint64_t x994 = 972251539185134LLU;
	uint16_t x995 = 7U;
	int16_t x996 = -3831;
	volatile uint64_t t178 = 207607638131LLU;

    t178 = (x993*((x994^x995)+x996));

    if (t178 != 9173150070373614826LLU) { NG(); } else { ; }
	
}

void f179(void) {
    	static uint8_t x1002 = UINT8_MAX;
	int8_t x1003 = INT8_MIN;
	int8_t x1004 = -15;
	volatile int32_t t179 = 10;

    t179 = (x1001*((x1002^x1003)+x1004));

    if (t179 != -864) { NG(); } else { ; }
	
}

void f180(void) {
    	volatile int32_t x1005 = -13;
	static int16_t x1006 = 1;
	uint32_t x1007 = UINT32_MAX;
	uint32_t x1008 = 247U;
	uint32_t t180 = 2U;

    t180 = (x1005*((x1006^x1007)+x1008));

    if (t180 != 4294964111U) { NG(); } else { ; }
	
}

void f181(void) {
    	int16_t x1009 = -1;
	int8_t x1010 = 3;
	uint64_t x1011 = 201LLU;
	int32_t x1012 = INT32_MIN;
	volatile uint64_t t181 = 142832LLU;

    t181 = (x1009*((x1010^x1011)+x1012));

    if (t181 != 2147483446LLU) { NG(); } else { ; }
	
}

void f182(void) {
    	volatile uint16_t x1015 = 27U;
	int16_t x1016 = INT16_MIN;
	volatile int32_t t182 = -14888;

    t182 = (x1013*((x1014^x1015)+x1016));

    if (t182 != 4181504) { NG(); } else { ; }
	
}

void f183(void) {
    	volatile uint64_t x1021 = 130132034440LLU;
	uint32_t x1022 = UINT32_MAX;
	uint16_t x1023 = UINT16_MAX;
	static uint16_t x1024 = 1U;
	volatile uint64_t t183 = 20248471282LLU;

    t183 = (x1021*((x1022^x1023)+x1024));

    if (t183 != 5501981667582100360LLU) { NG(); } else { ; }
	
}

void f184(void) {
    	static int32_t x1025 = 607329;
	static int8_t x1026 = 11;
	volatile uint32_t x1028 = 1U;
	volatile uint32_t t184 = 129446436U;

    t184 = (x1025*((x1026^x1027)+x1028));

    if (t184 != 2714406869U) { NG(); } else { ; }
	
}

void f185(void) {
    	uint64_t x1029 = 42479959416LLU;
	int64_t x1030 = -2708326518232LL;
	int64_t x1031 = -1266156470LL;
	volatile int8_t x1032 = INT8_MAX;
	uint64_t t185 = 99970904875449LLU;

    t185 = (x1029*((x1030^x1031)+x1032));

    if (t185 != 13705115599939245688LLU) { NG(); } else { ; }
	
}

void f186(void) {
    	int16_t x1033 = -1;
	static int8_t x1034 = INT8_MAX;
	volatile uint64_t x1035 = 875355787553035373LLU;
	int16_t x1036 = INT16_MIN;
	uint64_t t186 = 479LLU;

    t186 = (x1033*((x1034^x1035)+x1036));

    if (t186 != 17571388286156549102LLU) { NG(); } else { ; }
	
}

void f187(void) {
    	static uint8_t x1037 = 4U;
	uint16_t x1038 = 302U;
	int32_t x1039 = 0;
	volatile int8_t x1040 = INT8_MIN;
	volatile int32_t t187 = -35517561;

    t187 = (x1037*((x1038^x1039)+x1040));

    if (t187 != 696) { NG(); } else { ; }
	
}

void f188(void) {
    	int16_t x1041 = 1;
	uint8_t x1042 = 1U;
	uint8_t x1043 = 127U;
	volatile int32_t x1044 = -1914;
	static volatile int32_t t188 = -2;

    t188 = (x1041*((x1042^x1043)+x1044));

    if (t188 != -1788) { NG(); } else { ; }
	
}

void f189(void) {
    	volatile int8_t x1049 = INT8_MAX;
	int16_t x1052 = -2675;
	int64_t t189 = -34430745479324LL;

    t189 = (x1049*((x1050^x1051)+x1052));

    if (t189 != 272730083444LL) { NG(); } else { ; }
	
}

void f190(void) {
    	int8_t x1057 = INT8_MAX;
	int8_t x1058 = INT8_MIN;
	uint16_t x1059 = 39U;
	uint32_t x1060 = 1639U;
	volatile uint32_t t190 = 21392U;

    t190 = (x1057*((x1058^x1059)+x1060));

    if (t190 != 196850U) { NG(); } else { ; }
	
}

void f191(void) {
    	volatile int32_t x1062 = INT32_MIN;
	int64_t x1063 = -22386LL;
	uint32_t x1064 = 158794721U;

    t191 = (x1061*((x1062^x1063)+x1064));

    if (t191 != 4720905997201LL) { NG(); } else { ; }
	
}

void f192(void) {
    	int16_t x1065 = -2156;
	uint8_t x1066 = 79U;
	int32_t x1068 = -1;
	static uint32_t t192 = 23U;

    t192 = (x1065*((x1066^x1067)+x1068));

    if (t192 != 226118516U) { NG(); } else { ; }
	
}

void f193(void) {
    	uint8_t x1070 = UINT8_MAX;
	int32_t x1071 = INT32_MAX;
	volatile uint8_t x1072 = 1U;
	int64_t t193 = 105458286901093732LL;

    t193 = (x1069*((x1070^x1071)+x1072));

    if (t193 != -2147483393LL) { NG(); } else { ; }
	
}

void f194(void) {
    	int8_t x1073 = 11;
	static volatile int8_t x1074 = INT8_MAX;
	int16_t x1075 = -1;
	volatile uint64_t x1076 = UINT64_MAX;
	static uint64_t t194 = 5049194571361700883LLU;

    t194 = (x1073*((x1074^x1075)+x1076));

    if (t194 != 18446744073709550197LLU) { NG(); } else { ; }
	
}

void f195(void) {
    	int8_t x1077 = 0;
	int32_t x1078 = -169677279;
	int32_t t195 = 460968;

    t195 = (x1077*((x1078^x1079)+x1080));

    if (t195 != 0) { NG(); } else { ; }
	
}

void f196(void) {
    	static uint64_t x1082 = 165516LLU;
	int8_t x1084 = INT8_MAX;
	uint64_t t196 = 723LLU;

    t196 = (x1081*((x1082^x1083)+x1084));

    if (t196 != 165618LLU) { NG(); } else { ; }
	
}

void f197(void) {
    	int8_t x1086 = INT8_MIN;
	int16_t x1087 = INT16_MIN;
	static int8_t x1088 = INT8_MIN;
	static volatile int32_t t197 = -219;

    t197 = (x1085*((x1086^x1087)+x1088));

    if (t197 != -32512) { NG(); } else { ; }
	
}

void f198(void) {
    	uint32_t x1093 = 1355360795U;
	int16_t x1094 = INT16_MIN;
	int32_t x1095 = INT32_MAX;
	volatile uint64_t x1096 = 18892586589289154LLU;
	static uint64_t t198 = 48786738569187114LLU;

    t198 = (x1093*((x1094^x1095)+x1096));

    if (t198 != 10778584997584608347LLU) { NG(); } else { ; }
	
}

void f199(void) {
    	static volatile uint64_t x1097 = UINT64_MAX;
	static int64_t x1098 = 12423523366525544LL;
	volatile int64_t x1100 = INT64_MIN;
	uint64_t t199 = 314928LLU;

    t199 = (x1097*((x1098^x1099)+x1100));

    if (t199 != 9210948513488250345LLU) { NG(); } else { ; }
	
}

int main(void) {
        f0();
    f1();
    f2();
    f3();
    f4();
    f5();
    f6();
    f7();
    f8();
    f9();
    f10();
    f11();
    f12();
    f13();
    f14();
    f15();
    f16();
    f17();
    f18();
    f19();
    f20();
    f21();
    f22();
    f23();
    f24();
    f25();
    f26();
    f27();
    f28();
    f29();
    f30();
    f31();
    f32();
    f33();
    f34();
    f35();
    f36();
    f37();
    f38();
    f39();
    f40();
    f41();
    f42();
    f43();
    f44();
    f45();
    f46();
    f47();
    f48();
    f49();
    f50();
    f51();
    f52();
    f53();
    f54();
    f55();
    f56();
    f57();
    f58();
    f59();
    f60();
    f61();
    f62();
    f63();
    f64();
    f65();
    f66();
    f67();
    f68();
    f69();
    f70();
    f71();
    f72();
    f73();
    f74();
    f75();
    f76();
    f77();
    f78();
    f79();
    f80();
    f81();
    f82();
    f83();
    f84();
    f85();
    f86();
    f87();
    f88();
    f89();
    f90();
    f91();
    f92();
    f93();
    f94();
    f95();
    f96();
    f97();
    f98();
    f99();
    f100();
    f101();
    f102();
    f103();
    f104();
    f105();
    f106();
    f107();
    f108();
    f109();
    f110();
    f111();
    f112();
    f113();
    f114();
    f115();
    f116();
    f117();
    f118();
    f119();
    f120();
    f121();
    f122();
    f123();
    f124();
    f125();
    f126();
    f127();
    f128();
    f129();
    f130();
    f131();
    f132();
    f133();
    f134();
    f135();
    f136();
    f137();
    f138();
    f139();
    f140();
    f141();
    f142();
    f143();
    f144();
    f145();
    f146();
    f147();
    f148();
    f149();
    f150();
    f151();
    f152();
    f153();
    f154();
    f155();
    f156();
    f157();
    f158();
    f159();
    f160();
    f161();
    f162();
    f163();
    f164();
    f165();
    f166();
    f167();
    f168();
    f169();
    f170();
    f171();
    f172();
    f173();
    f174();
    f175();
    f176();
    f177();
    f178();
    f179();
    f180();
    f181();
    f182();
    f183();
    f184();
    f185();
    f186();
    f187();
    f188();
    f189();
    f190();
    f191();
    f192();
    f193();
    f194();
    f195();
    f196();
    f197();
    f198();
    f199();


    return 0;
}

