
/*
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"

volatile uint64_t x25 = 11LLU;
int64_t x59 = INT64_MIN;
uint32_t x154 = UINT32_MAX;
static volatile int32_t x171 = INT32_MIN;
int16_t x172 = INT16_MIN;
static int32_t t7 = -2675473;
volatile uint64_t x182 = 889570660LLU;
int16_t x195 = INT16_MIN;
volatile int32_t t9 = 484;
uint64_t t10 = 7436694897864063964LLU;
volatile uint16_t x325 = 4U;
int64_t x358 = INT64_MIN;
int16_t x360 = -1;
int32_t x363 = INT32_MIN;
int32_t t14 = -818643;
uint8_t x433 = 16U;
int32_t t15 = -3723;
uint8_t x437 = UINT8_MAX;
int64_t x439 = -466230543930519LL;
volatile int32_t t16 = 3591030;
int32_t x477 = INT32_MIN;
uint8_t x487 = 0U;
int8_t x495 = 13;
volatile int32_t t22 = -24810;
int16_t x512 = INT16_MAX;
int32_t t24 = 5;
int32_t x520 = -1;
uint64_t x526 = 58873545590LLU;
uint8_t x564 = 17U;
static int64_t t31 = 5037506LL;
static int32_t x624 = INT32_MIN;
int16_t x643 = 17;
volatile int16_t x674 = INT16_MAX;
volatile int32_t t35 = -16207207;
int64_t x678 = -117438474348612LL;
volatile uint64_t x687 = UINT64_MAX;
int64_t x701 = 1378888729LL;
static uint16_t x767 = 15U;
static uint16_t x789 = UINT16_MAX;
int8_t x790 = -7;
static volatile int32_t t41 = 1115363;
static uint16_t x809 = UINT16_MAX;
int8_t x810 = INT8_MIN;
int8_t x817 = -1;
uint64_t t45 = 72594386545LLU;
int8_t x916 = -1;
int16_t x931 = 2;
uint32_t x974 = 1014193U;
static uint32_t t50 = 1592010039U;
static volatile int32_t x998 = INT32_MAX;
uint8_t x999 = 6U;
static uint8_t x1000 = 3U;
uint32_t x1008 = 1U;
volatile uint64_t t54 = 3871510640993659333LLU;
int8_t x1092 = -2;
uint16_t x1119 = 263U;
int64_t x1188 = -1LL;
volatile int64_t x1207 = INT64_MIN;
static int16_t x1346 = 94;
static volatile int32_t x1348 = 10455;
int8_t x1438 = -4;
volatile int8_t x1440 = INT8_MIN;
int32_t t68 = -46863602;
volatile uint64_t t71 = 628098171458LLU;
int16_t x1535 = INT16_MAX;
static int8_t x1536 = INT8_MAX;
uint8_t x1581 = UINT8_MAX;
int64_t x1583 = INT64_MAX;
int64_t x1590 = INT64_MAX;
int8_t x1595 = INT8_MAX;
uint64_t t77 = 20638155175LLU;
int32_t x1601 = -14;
int16_t x1613 = INT16_MAX;
uint32_t x1614 = 20053683U;
int16_t x1616 = -1;
volatile uint64_t x1622 = 514312623370623LLU;
volatile uint64_t t83 = 1546363LLU;
int8_t x1671 = -57;
volatile int32_t t85 = -33;
int32_t t87 = -96893;
int64_t x1725 = -1LL;
uint64_t x1726 = 3329534119493753990LLU;
int16_t x1734 = -1;
volatile int16_t x1744 = INT16_MAX;
int32_t x1753 = -1;
int16_t x1828 = INT16_MIN;
volatile uint64_t t97 = 32907267LLU;
volatile int64_t t98 = 0LL;
int64_t x1958 = -1LL;
static volatile int8_t x1961 = 25;
int32_t x1962 = 209109293;
volatile int8_t x1964 = -44;
static int32_t x2015 = INT32_MAX;
volatile int32_t x2040 = 2;
volatile int32_t t104 = -129622;
uint64_t x2099 = UINT64_MAX;
int8_t x2136 = INT8_MIN;
int8_t x2139 = 3;
int64_t t107 = 16990307565LL;
static int16_t x2177 = 19;
volatile int64_t x2178 = 2407312475LL;
uint16_t x2180 = UINT16_MAX;
volatile uint32_t x2181 = 2790062U;
uint32_t x2184 = 273U;
int32_t x2219 = 399834021;
int16_t x2220 = 2;
int32_t x2293 = INT32_MIN;
static volatile uint32_t x2296 = UINT32_MAX;
int8_t x2327 = INT8_MIN;
int8_t x2328 = INT8_MIN;
int16_t x2331 = 434;
int64_t x2345 = 614057878931689490LL;
int32_t x2347 = INT32_MAX;
volatile int64_t t117 = -1992990515747722LL;
int64_t x2407 = INT64_MAX;
uint8_t x2425 = 6U;
int32_t t121 = -152652;
int64_t x2445 = INT64_MAX;
volatile uint8_t x2447 = 12U;
static uint64_t t124 = 163543464987438LLU;
static int32_t x2497 = -45387;
volatile int32_t x2498 = 513637722;
volatile uint16_t x2502 = 3U;
uint32_t x2505 = UINT32_MAX;
static int64_t x2523 = INT64_MAX;
int8_t x2528 = -1;
int32_t x2612 = -1661;
static volatile uint64_t t133 = 1237952417942259356LLU;
int16_t x2696 = INT16_MAX;
int8_t x2718 = INT8_MIN;
int16_t x2793 = -1;
int64_t t139 = 5127851206LL;
volatile int16_t x2805 = INT16_MAX;
int8_t x2807 = 25;
uint64_t x2831 = 680292412LLU;
volatile int32_t t144 = 7345;
uint64_t x2838 = 173706982401171LLU;
uint64_t t145 = 1757845368933158LLU;
uint16_t x2854 = 8799U;
int32_t x2855 = INT32_MIN;
int32_t x2856 = INT32_MIN;
volatile uint64_t t150 = 474561LLU;
int64_t x2969 = 39LL;
int8_t x2972 = -3;
int64_t t154 = -378LL;
static int8_t x2981 = INT8_MAX;
uint64_t x3019 = 24LLU;
int32_t x3020 = INT32_MAX;
static uint8_t x3047 = 0U;
uint16_t x3070 = UINT16_MAX;
volatile uint32_t x3071 = 11U;
uint64_t x3073 = 10829905301LLU;
static uint8_t x3075 = 1U;
int8_t x3091 = 3;
uint16_t x3111 = 82U;
uint8_t x3126 = UINT8_MAX;
int16_t x3156 = -1;
int8_t x3157 = 0;
uint16_t x3159 = 0U;
int8_t x3167 = 9;
volatile uint8_t x3168 = UINT8_MAX;
int32_t t172 = -560187782;
int8_t x3182 = 3;
static uint8_t x3184 = 12U;
static int64_t x3195 = 641480740936749LL;
volatile int64_t x3257 = 1078368019467797118LL;
volatile int64_t x3304 = -1LL;
uint16_t x3329 = 2235U;
static uint32_t x3330 = 125U;
uint16_t x3407 = 88U;
uint16_t x3408 = 2U;
int32_t t187 = -432706;
uint64_t x3439 = UINT64_MAX;
volatile uint32_t x3465 = UINT32_MAX;
volatile int64_t x3466 = 87815343LL;
int32_t x3467 = 760567337;
static int16_t x3491 = 0;
static volatile uint32_t t193 = 56U;
static int32_t x3526 = INT32_MIN;
static uint16_t x3527 = 5U;
uint32_t x3554 = UINT32_MAX;
uint32_t t195 = 1299804709U;
volatile uint16_t x3562 = 49U;
int32_t x3592 = -1;
volatile int32_t t199 = -15;


void f0(void) {
    	uint64_t x17 = UINT64_MAX;
	int32_t x18 = INT32_MIN;
	uint8_t x19 = UINT8_MAX;
	static volatile int8_t x20 = INT8_MAX;
	static uint64_t t0 = 108646479LLU;

    t0 = ((x17+x18)>>(x19%x20));

    if (t0 != 9223372035781033983LLU) { NG(); } else { ; }
	
}

void f1(void) {
    	int32_t x26 = 5;
	int8_t x27 = 15;
	volatile uint64_t x28 = 715305859434LLU;
	static volatile uint64_t t1 = 43635741899LLU;

    t1 = ((x25+x26)>>(x27%x28));

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

void f2(void) {
    	uint8_t x57 = 0U;
	uint32_t x58 = 83973867U;
	int16_t x60 = INT16_MIN;
	volatile uint32_t t2 = 32893867U;

    t2 = ((x57+x58)>>(x59%x60));

    if (t2 != 83973867U) { NG(); } else { ; }
	
}

void f3(void) {
    	uint32_t x97 = UINT32_MAX;
	int64_t x98 = -1LL;
	volatile int8_t x99 = INT8_MAX;
	int32_t x100 = 1;
	int64_t t3 = -35092660652730LL;

    t3 = ((x97+x98)>>(x99%x100));

    if (t3 != 4294967294LL) { NG(); } else { ; }
	
}

void f4(void) {
    	uint64_t x129 = 1751LLU;
	uint32_t x130 = 1U;
	int8_t x131 = INT8_MIN;
	int32_t x132 = -1;
	static uint64_t t4 = 356084502995338LLU;

    t4 = ((x129+x130)>>(x131%x132));

    if (t4 != 1752LLU) { NG(); } else { ; }
	
}

void f5(void) {
    	static volatile uint8_t x153 = 14U;
	int16_t x155 = INT16_MIN;
	int8_t x156 = INT8_MIN;
	volatile uint32_t t5 = 8366U;

    t5 = ((x153+x154)>>(x155%x156));

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

void f6(void) {
    	volatile int64_t x157 = 6192LL;
	uint64_t x158 = 692LLU;
	volatile uint8_t x159 = 4U;
	int64_t x160 = -1LL;
	uint64_t t6 = 5734LLU;

    t6 = ((x157+x158)>>(x159%x160));

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

void f7(void) {
    	int32_t x169 = 139135354;
	uint8_t x170 = 9U;

    t7 = ((x169+x170)>>(x171%x172));

    if (t7 != 139135363) { NG(); } else { ; }
	
}

void f8(void) {
    	static int32_t x181 = INT32_MAX;
	static int32_t x183 = INT32_MAX;
	uint8_t x184 = 59U;
	volatile uint64_t t8 = 33753226132647LLU;

    t8 = ((x181+x182)>>(x183%x184));

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

void f9(void) {
    	uint16_t x193 = UINT16_MAX;
	int8_t x194 = INT8_MIN;
	volatile int8_t x196 = INT8_MIN;

    t9 = ((x193+x194)>>(x195%x196));

    if (t9 != 65407) { NG(); } else { ; }
	
}

void f10(void) {
    	int16_t x213 = INT16_MIN;
	uint64_t x214 = 266245196012LLU;
	volatile uint16_t x215 = 81U;
	uint8_t x216 = 1U;

    t10 = ((x213+x214)>>(x215%x216));

    if (t10 != 266245163244LLU) { NG(); } else { ; }
	
}

void f11(void) {
    	uint16_t x326 = UINT16_MAX;
	uint64_t x327 = 0LLU;
	int16_t x328 = INT16_MIN;
	int32_t t11 = -242383340;

    t11 = ((x325+x326)>>(x327%x328));

    if (t11 != 65539) { NG(); } else { ; }
	
}

void f12(void) {
    	int8_t x345 = -6;
	static uint8_t x346 = 56U;
	int64_t x347 = INT64_MIN;
	int8_t x348 = -1;
	int32_t t12 = 23;

    t12 = ((x345+x346)>>(x347%x348));

    if (t12 != 50) { NG(); } else { ; }
	
}

void f13(void) {
    	uint64_t x357 = 22313821205LLU;
	int32_t x359 = 1;
	uint64_t t13 = 317969LLU;

    t13 = ((x357+x358)>>(x359%x360));

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

void f14(void) {
    	int8_t x361 = -7;
	static uint16_t x362 = UINT16_MAX;
	int8_t x364 = 1;

    t14 = ((x361+x362)>>(x363%x364));

    if (t14 != 65528) { NG(); } else { ; }
	
}

void f15(void) {
    	volatile uint16_t x434 = 102U;
	int8_t x435 = -1;
	static int64_t x436 = -1LL;

    t15 = ((x433+x434)>>(x435%x436));

    if (t15 != 118) { NG(); } else { ; }
	
}

void f16(void) {
    	int8_t x438 = INT8_MIN;
	int8_t x440 = -1;

    t16 = ((x437+x438)>>(x439%x440));

    if (t16 != 127) { NG(); } else { ; }
	
}

void f17(void) {
    	static int16_t x461 = -1;
	uint16_t x462 = 26290U;
	int32_t x463 = INT32_MAX;
	int8_t x464 = INT8_MAX;
	int32_t t17 = 0;

    t17 = ((x461+x462)>>(x463%x464));

    if (t17 != 205) { NG(); } else { ; }
	
}

void f18(void) {
    	volatile uint64_t x478 = 260466LLU;
	int32_t x479 = INT32_MAX;
	volatile int8_t x480 = INT8_MAX;
	uint64_t t18 = 781298873598856286LLU;

    t18 = ((x477+x478)>>(x479%x480));

    if (t18 != 144115188059080690LLU) { NG(); } else { ; }
	
}

void f19(void) {
    	static uint32_t x485 = UINT32_MAX;
	int16_t x486 = 145;
	uint32_t x488 = 1U;
	uint32_t t19 = 662294U;

    t19 = ((x485+x486)>>(x487%x488));

    if (t19 != 144U) { NG(); } else { ; }
	
}

void f20(void) {
    	int8_t x489 = -22;
	uint32_t x490 = 262U;
	static volatile int16_t x491 = 0;
	volatile int32_t x492 = INT32_MAX;
	uint32_t t20 = 6U;

    t20 = ((x489+x490)>>(x491%x492));

    if (t20 != 240U) { NG(); } else { ; }
	
}

void f21(void) {
    	int8_t x493 = 1;
	int32_t x494 = -1;
	uint64_t x496 = UINT64_MAX;
	int32_t t21 = -456553022;

    t21 = ((x493+x494)>>(x495%x496));

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

void f22(void) {
    	static int8_t x501 = INT8_MIN;
	int32_t x502 = INT32_MAX;
	volatile uint16_t x503 = 12U;
	int32_t x504 = 303705173;

    t22 = ((x501+x502)>>(x503%x504));

    if (t22 != 524287) { NG(); } else { ; }
	
}

void f23(void) {
    	uint64_t x505 = 7338294253656782LLU;
	volatile int64_t x506 = -1LL;
	uint16_t x507 = 9665U;
	volatile int8_t x508 = INT8_MAX;
	uint64_t t23 = 984656491002824LLU;

    t23 = ((x505+x506)>>(x507%x508));

    if (t23 != 895787872760LLU) { NG(); } else { ; }
	
}

void f24(void) {
    	uint8_t x509 = UINT8_MAX;
	volatile uint8_t x510 = 0U;
	int16_t x511 = INT16_MAX;

    t24 = ((x509+x510)>>(x511%x512));

    if (t24 != 255) { NG(); } else { ; }
	
}

void f25(void) {
    	uint32_t x517 = 75013260U;
	static int16_t x518 = INT16_MAX;
	volatile int64_t x519 = -1LL;
	volatile uint32_t t25 = 66537U;

    t25 = ((x517+x518)>>(x519%x520));

    if (t25 != 75046027U) { NG(); } else { ; }
	
}

void f26(void) {
    	uint8_t x525 = 16U;
	volatile int64_t x527 = 408278228LL;
	int32_t x528 = -1;
	volatile uint64_t t26 = 11LLU;

    t26 = ((x525+x526)>>(x527%x528));

    if (t26 != 58873545606LLU) { NG(); } else { ; }
	
}

void f27(void) {
    	int16_t x529 = -50;
	static uint32_t x530 = 3870U;
	int8_t x531 = INT8_MIN;
	int64_t x532 = -1LL;
	static volatile uint32_t t27 = 40003U;

    t27 = ((x529+x530)>>(x531%x532));

    if (t27 != 3820U) { NG(); } else { ; }
	
}

void f28(void) {
    	volatile uint32_t x541 = 264752853U;
	uint64_t x542 = UINT64_MAX;
	uint32_t x543 = 307U;
	int8_t x544 = 1;
	uint64_t t28 = 240185LLU;

    t28 = ((x541+x542)>>(x543%x544));

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

void f29(void) {
    	uint32_t x561 = 498575U;
	uint16_t x562 = UINT16_MAX;
	uint8_t x563 = 70U;
	uint32_t t29 = 266U;

    t29 = ((x561+x562)>>(x563%x564));

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

void f30(void) {
    	static uint16_t x581 = 226U;
	uint64_t x582 = UINT64_MAX;
	static int32_t x583 = INT32_MIN;
	int8_t x584 = 1;
	volatile uint64_t t30 = 83058LLU;

    t30 = ((x581+x582)>>(x583%x584));

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

void f31(void) {
    	volatile int32_t x605 = INT32_MAX;
	static int64_t x606 = -1LL;
	uint8_t x607 = 0U;
	int64_t x608 = -1LL;

    t31 = ((x605+x606)>>(x607%x608));

    if (t31 != 2147483646LL) { NG(); } else { ; }
	
}

void f32(void) {
    	volatile int32_t x621 = INT32_MAX;
	uint32_t x622 = 86U;
	int8_t x623 = 18;
	static uint32_t t32 = 1669638U;

    t32 = ((x621+x622)>>(x623%x624));

    if (t32 != 8192U) { NG(); } else { ; }
	
}

void f33(void) {
    	uint16_t x641 = 43U;
	int8_t x642 = -1;
	int32_t x644 = -156468960;
	int32_t t33 = -1;

    t33 = ((x641+x642)>>(x643%x644));

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

void f34(void) {
    	uint64_t x645 = 3LLU;
	int16_t x646 = INT16_MIN;
	volatile int16_t x647 = INT16_MAX;
	volatile int8_t x648 = 12;
	static uint64_t t34 = 165427183LLU;

    t34 = ((x645+x646)>>(x647%x648));

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

void f35(void) {
    	int16_t x673 = 16174;
	int32_t x675 = 1;
	uint16_t x676 = UINT16_MAX;

    t35 = ((x673+x674)>>(x675%x676));

    if (t35 != 24470) { NG(); } else { ; }
	
}

void f36(void) {
    	volatile int64_t x677 = INT64_MAX;
	volatile uint64_t x679 = UINT64_MAX;
	volatile int64_t x680 = -1LL;
	int64_t t36 = 5283085LL;

    t36 = ((x677+x678)>>(x679%x680));

    if (t36 != 9223254598380427195LL) { NG(); } else { ; }
	
}

void f37(void) {
    	int16_t x685 = INT16_MIN;
	volatile uint64_t x686 = UINT64_MAX;
	int64_t x688 = -1LL;
	volatile uint64_t t37 = 26LLU;

    t37 = ((x685+x686)>>(x687%x688));

    if (t37 != 18446744073709518847LLU) { NG(); } else { ; }
	
}

void f38(void) {
    	volatile uint16_t x702 = 2U;
	uint8_t x703 = 31U;
	static uint64_t x704 = 10625294139LLU;
	static int64_t t38 = 0LL;

    t38 = ((x701+x702)>>(x703%x704));

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

void f39(void) {
    	int16_t x761 = INT16_MIN;
	uint16_t x762 = UINT16_MAX;
	uint8_t x763 = UINT8_MAX;
	volatile int32_t x764 = -1;
	int32_t t39 = -47297;

    t39 = ((x761+x762)>>(x763%x764));

    if (t39 != 32767) { NG(); } else { ; }
	
}

void f40(void) {
    	static uint16_t x765 = UINT16_MAX;
	int64_t x766 = 150714LL;
	static volatile uint64_t x768 = 197916208907009450LLU;
	int64_t t40 = -28618553917LL;

    t40 = ((x765+x766)>>(x767%x768));

    if (t40 != 6LL) { NG(); } else { ; }
	
}

void f41(void) {
    	int8_t x791 = 1;
	static int16_t x792 = INT16_MIN;

    t41 = ((x789+x790)>>(x791%x792));

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

void f42(void) {
    	int16_t x811 = 111;
	uint32_t x812 = 1U;
	volatile int32_t t42 = -73155590;

    t42 = ((x809+x810)>>(x811%x812));

    if (t42 != 65407) { NG(); } else { ; }
	
}

void f43(void) {
    	uint16_t x818 = 3U;
	uint8_t x819 = 15U;
	uint8_t x820 = UINT8_MAX;
	int32_t t43 = -109;

    t43 = ((x817+x818)>>(x819%x820));

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

void f44(void) {
    	int32_t x877 = -1;
	int64_t x878 = INT64_MAX;
	int16_t x879 = INT16_MIN;
	volatile int64_t x880 = -1LL;
	int64_t t44 = -210188LL;

    t44 = ((x877+x878)>>(x879%x880));

    if (t44 != 9223372036854775806LL) { NG(); } else { ; }
	
}

void f45(void) {
    	uint64_t x889 = 1365LLU;
	int8_t x890 = INT8_MIN;
	uint32_t x891 = 1U;
	static int32_t x892 = -2888338;

    t45 = ((x889+x890)>>(x891%x892));

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

void f46(void) {
    	static uint32_t x905 = UINT32_MAX;
	int16_t x906 = INT16_MIN;
	static int32_t x907 = INT32_MIN;
	int8_t x908 = INT8_MIN;
	volatile uint32_t t46 = 6U;

    t46 = ((x905+x906)>>(x907%x908));

    if (t46 != 4294934527U) { NG(); } else { ; }
	
}

void f47(void) {
    	int32_t x913 = -1;
	int16_t x914 = 1851;
	int16_t x915 = INT16_MIN;
	volatile int32_t t47 = 2106964;

    t47 = ((x913+x914)>>(x915%x916));

    if (t47 != 1850) { NG(); } else { ; }
	
}

void f48(void) {
    	static volatile int16_t x929 = INT16_MAX;
	uint16_t x930 = 613U;
	uint16_t x932 = 31U;
	volatile int32_t t48 = -6;

    t48 = ((x929+x930)>>(x931%x932));

    if (t48 != 8345) { NG(); } else { ; }
	
}

void f49(void) {
    	static volatile uint64_t x957 = 47779647LLU;
	static int16_t x958 = -2;
	int32_t x959 = INT32_MIN;
	int16_t x960 = INT16_MIN;
	volatile uint64_t t49 = 52116416LLU;

    t49 = ((x957+x958)>>(x959%x960));

    if (t49 != 47779645LLU) { NG(); } else { ; }
	
}

void f50(void) {
    	uint32_t x973 = UINT32_MAX;
	int8_t x975 = INT8_MIN;
	volatile uint16_t x976 = 4U;

    t50 = ((x973+x974)>>(x975%x976));

    if (t50 != 1014192U) { NG(); } else { ; }
	
}

void f51(void) {
    	static uint32_t x997 = 3534U;
	volatile uint32_t t51 = 0U;

    t51 = ((x997+x998)>>(x999%x1000));

    if (t51 != 2147487181U) { NG(); } else { ; }
	
}

void f52(void) {
    	uint32_t x1005 = UINT32_MAX;
	static int32_t x1006 = INT32_MAX;
	uint8_t x1007 = 23U;
	volatile uint32_t t52 = 3107606U;

    t52 = ((x1005+x1006)>>(x1007%x1008));

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

void f53(void) {
    	int64_t x1021 = 37515120168680LL;
	int32_t x1022 = INT32_MAX;
	uint8_t x1023 = UINT8_MAX;
	int32_t x1024 = -1;
	static int64_t t53 = -123LL;

    t53 = ((x1021+x1022)>>(x1023%x1024));

    if (t53 != 37517267652327LL) { NG(); } else { ; }
	
}

void f54(void) {
    	int32_t x1069 = INT32_MIN;
	uint64_t x1070 = 228512548LLU;
	uint64_t x1071 = 6LLU;
	int64_t x1072 = -483345608LL;

    t54 = ((x1069+x1070)>>(x1071%x1072));

    if (t54 != 288230376121727820LLU) { NG(); } else { ; }
	
}

void f55(void) {
    	int64_t x1089 = 291079898146469482LL;
	uint32_t x1090 = 119147376U;
	volatile int8_t x1091 = INT8_MIN;
	volatile int64_t t55 = -1598039227039525LL;

    t55 = ((x1089+x1090)>>(x1091%x1092));

    if (t55 != 291079898265616858LL) { NG(); } else { ; }
	
}

void f56(void) {
    	static int32_t x1117 = -1;
	uint16_t x1118 = 16114U;
	volatile int8_t x1120 = INT8_MIN;
	volatile int32_t t56 = 7;

    t56 = ((x1117+x1118)>>(x1119%x1120));

    if (t56 != 125) { NG(); } else { ; }
	
}

void f57(void) {
    	uint16_t x1153 = 0U;
	int64_t x1154 = INT64_MAX;
	volatile uint16_t x1155 = UINT16_MAX;
	volatile int8_t x1156 = INT8_MAX;
	volatile int64_t t57 = 586048LL;

    t57 = ((x1153+x1154)>>(x1155%x1156));

    if (t57 != 1152921504606846975LL) { NG(); } else { ; }
	
}

void f58(void) {
    	int8_t x1185 = -23;
	volatile int64_t x1186 = 555103445741185767LL;
	int64_t x1187 = INT64_MAX;
	int64_t t58 = -142203599409894LL;

    t58 = ((x1185+x1186)>>(x1187%x1188));

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

void f59(void) {
    	int16_t x1205 = 4;
	static int64_t x1206 = -1LL;
	int8_t x1208 = -1;
	volatile int64_t t59 = 2510923330401LL;

    t59 = ((x1205+x1206)>>(x1207%x1208));

    if (t59 != 3LL) { NG(); } else { ; }
	
}

void f60(void) {
    	static int16_t x1233 = 531;
	uint16_t x1234 = 15U;
	volatile int8_t x1235 = 0;
	uint16_t x1236 = 26U;
	int32_t t60 = -18;

    t60 = ((x1233+x1234)>>(x1235%x1236));

    if (t60 != 546) { NG(); } else { ; }
	
}

void f61(void) {
    	static uint8_t x1265 = 3U;
	int32_t x1266 = -1;
	volatile uint16_t x1267 = 5137U;
	volatile int32_t x1268 = -1;
	static int32_t t61 = -340199;

    t61 = ((x1265+x1266)>>(x1267%x1268));

    if (t61 != 2) { NG(); } else { ; }
	
}

void f62(void) {
    	int8_t x1325 = -1;
	uint32_t x1326 = 64873514U;
	volatile int64_t x1327 = INT64_MIN;
	volatile int32_t x1328 = -1;
	static uint32_t t62 = 951470U;

    t62 = ((x1325+x1326)>>(x1327%x1328));

    if (t62 != 64873513U) { NG(); } else { ; }
	
}

void f63(void) {
    	static uint64_t x1345 = UINT64_MAX;
	static volatile uint16_t x1347 = 1U;
	uint64_t t63 = 1367635890LLU;

    t63 = ((x1345+x1346)>>(x1347%x1348));

    if (t63 != 46LLU) { NG(); } else { ; }
	
}

void f64(void) {
    	uint8_t x1353 = UINT8_MAX;
	uint8_t x1354 = 6U;
	static int8_t x1355 = INT8_MIN;
	uint16_t x1356 = 8U;
	volatile int32_t t64 = -4960824;

    t64 = ((x1353+x1354)>>(x1355%x1356));

    if (t64 != 261) { NG(); } else { ; }
	
}

void f65(void) {
    	uint64_t x1397 = 32888532649072150LLU;
	uint8_t x1398 = 3U;
	int8_t x1399 = INT8_MIN;
	uint32_t x1400 = 1U;
	volatile uint64_t t65 = 2240LLU;

    t65 = ((x1397+x1398)>>(x1399%x1400));

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

void f66(void) {
    	uint64_t x1409 = UINT64_MAX;
	int8_t x1410 = INT8_MIN;
	int16_t x1411 = INT16_MAX;
	int32_t x1412 = -1;
	uint64_t t66 = 534581863607966324LLU;

    t66 = ((x1409+x1410)>>(x1411%x1412));

    if (t66 != 18446744073709551487LLU) { NG(); } else { ; }
	
}

void f67(void) {
    	uint8_t x1429 = 51U;
	volatile uint64_t x1430 = 90092113800379019LLU;
	int64_t x1431 = -3LL;
	int8_t x1432 = -1;
	uint64_t t67 = 324154LLU;

    t67 = ((x1429+x1430)>>(x1431%x1432));

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

void f68(void) {
    	uint16_t x1437 = 1162U;
	int64_t x1439 = INT64_MIN;

    t68 = ((x1437+x1438)>>(x1439%x1440));

    if (t68 != 1158) { NG(); } else { ; }
	
}

void f69(void) {
    	volatile uint32_t x1441 = 240150276U;
	int32_t x1442 = INT32_MIN;
	int16_t x1443 = -5885;
	int64_t x1444 = -1LL;
	volatile uint32_t t69 = 2089683250U;

    t69 = ((x1441+x1442)>>(x1443%x1444));

    if (t69 != 2387633924U) { NG(); } else { ; }
	
}

void f70(void) {
    	volatile int64_t x1445 = -1LL;
	int64_t x1446 = INT64_MAX;
	int16_t x1447 = INT16_MAX;
	int8_t x1448 = INT8_MAX;
	int64_t t70 = -4628971LL;

    t70 = ((x1445+x1446)>>(x1447%x1448));

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

void f71(void) {
    	uint8_t x1485 = 2U;
	volatile uint64_t x1486 = 28087155685501031LLU;
	uint8_t x1487 = 0U;
	static int8_t x1488 = INT8_MAX;

    t71 = ((x1485+x1486)>>(x1487%x1488));

    if (t71 != 28087155685501033LLU) { NG(); } else { ; }
	
}

void f72(void) {
    	uint16_t x1493 = 76U;
	uint16_t x1494 = 12285U;
	uint8_t x1495 = 0U;
	volatile int32_t x1496 = -1;
	volatile int32_t t72 = 3516441;

    t72 = ((x1493+x1494)>>(x1495%x1496));

    if (t72 != 12361) { NG(); } else { ; }
	
}

void f73(void) {
    	static uint64_t x1525 = 5821LLU;
	int32_t x1526 = -14;
	int32_t x1527 = INT32_MIN;
	int32_t x1528 = -1;
	volatile uint64_t t73 = 11369LLU;

    t73 = ((x1525+x1526)>>(x1527%x1528));

    if (t73 != 5807LLU) { NG(); } else { ; }
	
}

void f74(void) {
    	uint8_t x1533 = 15U;
	volatile uint32_t x1534 = 216185U;
	uint32_t t74 = 61193947U;

    t74 = ((x1533+x1534)>>(x1535%x1536));

    if (t74 != 108100U) { NG(); } else { ; }
	
}

void f75(void) {
    	int8_t x1582 = -63;
	uint8_t x1584 = 29U;
	int32_t t75 = -3;

    t75 = ((x1581+x1582)>>(x1583%x1584));

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

void f76(void) {
    	int16_t x1589 = INT16_MIN;
	int8_t x1591 = 0;
	uint32_t x1592 = UINT32_MAX;
	volatile int64_t t76 = -11LL;

    t76 = ((x1589+x1590)>>(x1591%x1592));

    if (t76 != 9223372036854743039LL) { NG(); } else { ; }
	
}

void f77(void) {
    	volatile int8_t x1593 = INT8_MAX;
	volatile uint64_t x1594 = 39383LLU;
	uint8_t x1596 = 2U;

    t77 = ((x1593+x1594)>>(x1595%x1596));

    if (t77 != 19755LLU) { NG(); } else { ; }
	
}

void f78(void) {
    	uint32_t x1602 = 5039U;
	int16_t x1603 = INT16_MAX;
	uint8_t x1604 = 12U;
	volatile uint32_t t78 = 215681U;

    t78 = ((x1601+x1602)>>(x1603%x1604));

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

void f79(void) {
    	int16_t x1615 = 0;
	volatile uint32_t t79 = 798460U;

    t79 = ((x1613+x1614)>>(x1615%x1616));

    if (t79 != 20086450U) { NG(); } else { ; }
	
}

void f80(void) {
    	static int8_t x1621 = INT8_MIN;
	volatile int16_t x1623 = INT16_MIN;
	int16_t x1624 = 1;
	uint64_t t80 = 14005363347162535LLU;

    t80 = ((x1621+x1622)>>(x1623%x1624));

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

void f81(void) {
    	int8_t x1629 = INT8_MAX;
	static int8_t x1630 = -1;
	int32_t x1631 = INT32_MAX;
	volatile int8_t x1632 = -1;
	static volatile int32_t t81 = -3;

    t81 = ((x1629+x1630)>>(x1631%x1632));

    if (t81 != 126) { NG(); } else { ; }
	
}

void f82(void) {
    	uint32_t x1637 = 1311423U;
	static uint64_t x1638 = 329102837008980LLU;
	int8_t x1639 = 0;
	static volatile int8_t x1640 = INT8_MIN;
	uint64_t t82 = 56993307368923477LLU;

    t82 = ((x1637+x1638)>>(x1639%x1640));

    if (t82 != 329102838320403LLU) { NG(); } else { ; }
	
}

void f83(void) {
    	static uint64_t x1641 = UINT64_MAX;
	static volatile int32_t x1642 = INT32_MAX;
	static int64_t x1643 = -1967443992014761LL;
	uint8_t x1644 = 1U;

    t83 = ((x1641+x1642)>>(x1643%x1644));

    if (t83 != 2147483646LLU) { NG(); } else { ; }
	
}

void f84(void) {
    	uint8_t x1649 = UINT8_MAX;
	uint16_t x1650 = 79U;
	uint8_t x1651 = 12U;
	uint8_t x1652 = 18U;
	static volatile int32_t t84 = 16560366;

    t84 = ((x1649+x1650)>>(x1651%x1652));

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

void f85(void) {
    	int8_t x1669 = 7;
	uint16_t x1670 = 7023U;
	int16_t x1672 = 3;

    t85 = ((x1669+x1670)>>(x1671%x1672));

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

void f86(void) {
    	static int8_t x1673 = INT8_MAX;
	static int16_t x1674 = -1;
	int32_t x1675 = 12;
	uint8_t x1676 = UINT8_MAX;
	int32_t t86 = 1;

    t86 = ((x1673+x1674)>>(x1675%x1676));

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

void f87(void) {
    	volatile int8_t x1681 = INT8_MAX;
	volatile int32_t x1682 = 66;
	volatile int32_t x1683 = 44240810;
	int16_t x1684 = -1;

    t87 = ((x1681+x1682)>>(x1683%x1684));

    if (t87 != 193) { NG(); } else { ; }
	
}

void f88(void) {
    	int8_t x1689 = -1;
	volatile uint16_t x1690 = 1103U;
	uint64_t x1691 = UINT64_MAX;
	static int8_t x1692 = -2;
	int32_t t88 = -7;

    t88 = ((x1689+x1690)>>(x1691%x1692));

    if (t88 != 551) { NG(); } else { ; }
	
}

void f89(void) {
    	volatile int32_t x1727 = 1;
	int8_t x1728 = INT8_MAX;
	static uint64_t t89 = 21977022LLU;

    t89 = ((x1725+x1726)>>(x1727%x1728));

    if (t89 != 1664767059746876994LLU) { NG(); } else { ; }
	
}

void f90(void) {
    	uint16_t x1733 = 319U;
	int16_t x1735 = INT16_MAX;
	int8_t x1736 = -37;
	volatile int32_t t90 = 678;

    t90 = ((x1733+x1734)>>(x1735%x1736));

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

void f91(void) {
    	int32_t x1741 = INT32_MIN;
	static uint64_t x1742 = UINT64_MAX;
	uint64_t x1743 = 51LLU;
	uint64_t t91 = 1301499792LLU;

    t91 = ((x1741+x1742)>>(x1743%x1744));

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

void f92(void) {
    	int32_t x1754 = INT32_MAX;
	uint32_t x1755 = 154104U;
	uint8_t x1756 = 41U;
	int32_t t92 = 1;

    t92 = ((x1753+x1754)>>(x1755%x1756));

    if (t92 != 31) { NG(); } else { ; }
	
}

void f93(void) {
    	int64_t x1813 = 1655818770083LL;
	int32_t x1814 = 5;
	uint64_t x1815 = 71751001LLU;
	volatile uint8_t x1816 = 8U;
	static volatile int64_t t93 = 0LL;

    t93 = ((x1813+x1814)>>(x1815%x1816));

    if (t93 != 827909385044LL) { NG(); } else { ; }
	
}

void f94(void) {
    	uint32_t x1825 = 41003U;
	int16_t x1826 = INT16_MIN;
	volatile int16_t x1827 = 0;
	volatile uint32_t t94 = 246193U;

    t94 = ((x1825+x1826)>>(x1827%x1828));

    if (t94 != 8235U) { NG(); } else { ; }
	
}

void f95(void) {
    	int16_t x1837 = -3;
	static uint8_t x1838 = 51U;
	int8_t x1839 = 60;
	int16_t x1840 = -1;
	int32_t t95 = 224;

    t95 = ((x1837+x1838)>>(x1839%x1840));

    if (t95 != 48) { NG(); } else { ; }
	
}

void f96(void) {
    	uint32_t x1877 = 237594173U;
	static int8_t x1878 = INT8_MIN;
	uint16_t x1879 = 3U;
	uint16_t x1880 = 42U;
	static uint32_t t96 = 29824841U;

    t96 = ((x1877+x1878)>>(x1879%x1880));

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

void f97(void) {
    	uint8_t x1929 = 51U;
	volatile uint64_t x1930 = UINT64_MAX;
	int32_t x1931 = 0;
	uint16_t x1932 = 28588U;

    t97 = ((x1929+x1930)>>(x1931%x1932));

    if (t97 != 50LLU) { NG(); } else { ; }
	
}

void f98(void) {
    	static int64_t x1945 = INT64_MAX;
	int32_t x1946 = -482;
	volatile int8_t x1947 = -2;
	volatile int16_t x1948 = -1;

    t98 = ((x1945+x1946)>>(x1947%x1948));

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

void f99(void) {
    	volatile uint8_t x1949 = UINT8_MAX;
	int16_t x1950 = 1;
	int64_t x1951 = 27138643LL;
	int8_t x1952 = -1;
	static volatile int32_t t99 = -1241;

    t99 = ((x1949+x1950)>>(x1951%x1952));

    if (t99 != 256) { NG(); } else { ; }
	
}

void f100(void) {
    	int32_t x1957 = 396937463;
	int8_t x1959 = INT8_MIN;
	static uint8_t x1960 = 1U;
	int64_t t100 = -1391938788132000612LL;

    t100 = ((x1957+x1958)>>(x1959%x1960));

    if (t100 != 396937462LL) { NG(); } else { ; }
	
}

void f101(void) {
    	int16_t x1963 = INT16_MAX;
	volatile int32_t t101 = 75944430;

    t101 = ((x1961+x1962)>>(x1963%x1964));

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

void f102(void) {
    	uint16_t x2013 = 3U;
	uint32_t x2014 = 4112U;
	int32_t x2016 = -1;
	volatile uint32_t t102 = 51014U;

    t102 = ((x2013+x2014)>>(x2015%x2016));

    if (t102 != 4115U) { NG(); } else { ; }
	
}

void f103(void) {
    	int8_t x2033 = INT8_MIN;
	uint32_t x2034 = 40U;
	uint64_t x2035 = UINT64_MAX;
	uint32_t x2036 = 3U;
	uint32_t t103 = 48224U;

    t103 = ((x2033+x2034)>>(x2035%x2036));

    if (t103 != 4294967208U) { NG(); } else { ; }
	
}

void f104(void) {
    	uint8_t x2037 = 1U;
	volatile uint8_t x2038 = 81U;
	int8_t x2039 = INT8_MAX;

    t104 = ((x2037+x2038)>>(x2039%x2040));

    if (t104 != 41) { NG(); } else { ; }
	
}

void f105(void) {
    	uint16_t x2097 = 1856U;
	static uint16_t x2098 = 14U;
	uint8_t x2100 = 6U;
	int32_t t105 = -218470;

    t105 = ((x2097+x2098)>>(x2099%x2100));

    if (t105 != 233) { NG(); } else { ; }
	
}

void f106(void) {
    	static int8_t x2133 = INT8_MIN;
	uint8_t x2134 = UINT8_MAX;
	uint16_t x2135 = 2U;
	volatile int32_t t106 = -1811421;

    t106 = ((x2133+x2134)>>(x2135%x2136));

    if (t106 != 31) { NG(); } else { ; }
	
}

void f107(void) {
    	static volatile int64_t x2137 = 12252421LL;
	volatile int8_t x2138 = INT8_MAX;
	volatile int64_t x2140 = INT64_MIN;

    t107 = ((x2137+x2138)>>(x2139%x2140));

    if (t107 != 1531568LL) { NG(); } else { ; }
	
}

void f108(void) {
    	static uint32_t x2179 = UINT32_MAX;
	int64_t t108 = -2056LL;

    t108 = ((x2177+x2178)>>(x2179%x2180));

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

void f109(void) {
    	uint64_t x2182 = UINT64_MAX;
	static int8_t x2183 = 1;
	uint64_t t109 = 4549752920LLU;

    t109 = ((x2181+x2182)>>(x2183%x2184));

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

void f110(void) {
    	static uint64_t x2217 = UINT64_MAX;
	uint32_t x2218 = 2526U;
	volatile uint64_t t110 = 647890900021599568LLU;

    t110 = ((x2217+x2218)>>(x2219%x2220));

    if (t110 != 1262LLU) { NG(); } else { ; }
	
}

void f111(void) {
    	uint64_t x2257 = UINT64_MAX;
	int64_t x2258 = INT64_MIN;
	uint32_t x2259 = 24U;
	uint32_t x2260 = 10365487U;
	volatile uint64_t t111 = 32697544LLU;

    t111 = ((x2257+x2258)>>(x2259%x2260));

    if (t111 != 549755813887LLU) { NG(); } else { ; }
	
}

void f112(void) {
    	uint32_t x2285 = UINT32_MAX;
	volatile int64_t x2286 = 40328964781285LL;
	uint8_t x2287 = 50U;
	uint64_t x2288 = 59474234743504LLU;
	int64_t t112 = -1LL;

    t112 = ((x2285+x2286)>>(x2287%x2288));

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

void f113(void) {
    	uint32_t x2294 = 51U;
	int8_t x2295 = 0;
	volatile uint32_t t113 = 181383U;

    t113 = ((x2293+x2294)>>(x2295%x2296));

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

void f114(void) {
    	int64_t x2297 = INT64_MAX;
	int16_t x2298 = INT16_MIN;
	uint64_t x2299 = 23LLU;
	static volatile int16_t x2300 = INT16_MIN;
	volatile int64_t t114 = 15888LL;

    t114 = ((x2297+x2298)>>(x2299%x2300));

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

void f115(void) {
    	int16_t x2325 = INT16_MAX;
	int8_t x2326 = 0;
	volatile int32_t t115 = 305910248;

    t115 = ((x2325+x2326)>>(x2327%x2328));

    if (t115 != 32767) { NG(); } else { ; }
	
}

void f116(void) {
    	uint32_t x2329 = 160432U;
	static int64_t x2330 = 79992LL;
	int16_t x2332 = -1;
	volatile int64_t t116 = 58056063LL;

    t116 = ((x2329+x2330)>>(x2331%x2332));

    if (t116 != 240424LL) { NG(); } else { ; }
	
}

void f117(void) {
    	int16_t x2346 = 1;
	static uint16_t x2348 = 2U;

    t117 = ((x2345+x2346)>>(x2347%x2348));

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

void f118(void) {
    	volatile int64_t x2361 = 19736211LL;
	uint16_t x2362 = 404U;
	uint64_t x2363 = 14LLU;
	int32_t x2364 = INT32_MAX;
	int64_t t118 = -1478LL;

    t118 = ((x2361+x2362)>>(x2363%x2364));

    if (t118 != 1204LL) { NG(); } else { ; }
	
}

void f119(void) {
    	uint64_t x2365 = 61273620908246841LLU;
	int8_t x2366 = 18;
	int16_t x2367 = 1678;
	volatile uint16_t x2368 = 1U;
	uint64_t t119 = 506220511440283LLU;

    t119 = ((x2365+x2366)>>(x2367%x2368));

    if (t119 != 61273620908246859LLU) { NG(); } else { ; }
	
}

void f120(void) {
    	int64_t x2405 = 1LL;
	static volatile int8_t x2406 = -1;
	volatile uint8_t x2408 = 75U;
	int64_t t120 = 2979493150326282LL;

    t120 = ((x2405+x2406)>>(x2407%x2408));

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

void f121(void) {
    	int8_t x2426 = 1;
	static uint8_t x2427 = UINT8_MAX;
	int8_t x2428 = -1;

    t121 = ((x2425+x2426)>>(x2427%x2428));

    if (t121 != 7) { NG(); } else { ; }
	
}

void f122(void) {
    	int32_t x2446 = INT32_MIN;
	int16_t x2448 = INT16_MAX;
	static int64_t t122 = 10589518003688LL;

    t122 = ((x2445+x2446)>>(x2447%x2448));

    if (t122 != 2251799813160959LL) { NG(); } else { ; }
	
}

void f123(void) {
    	int8_t x2473 = -1;
	volatile uint8_t x2474 = 3U;
	uint8_t x2475 = 6U;
	static int64_t x2476 = INT64_MIN;
	volatile int32_t t123 = 1;

    t123 = ((x2473+x2474)>>(x2475%x2476));

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

void f124(void) {
    	volatile uint64_t x2485 = 57496179LLU;
	int16_t x2486 = -185;
	volatile uint16_t x2487 = 36U;
	int64_t x2488 = -85492659LL;

    t124 = ((x2485+x2486)>>(x2487%x2488));

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

void f125(void) {
    	int32_t x2499 = 1;
	int32_t x2500 = INT32_MIN;
	int32_t t125 = -488191;

    t125 = ((x2497+x2498)>>(x2499%x2500));

    if (t125 != 256796167) { NG(); } else { ; }
	
}

void f126(void) {
    	int64_t x2501 = 5860314160579407LL;
	static uint16_t x2503 = 1130U;
	int16_t x2504 = -1;
	static int64_t t126 = 3356455224LL;

    t126 = ((x2501+x2502)>>(x2503%x2504));

    if (t126 != 5860314160579410LL) { NG(); } else { ; }
	
}

void f127(void) {
    	uint64_t x2506 = UINT64_MAX;
	uint64_t x2507 = 22LLU;
	int32_t x2508 = 1;
	uint64_t t127 = 2153717274771311121LLU;

    t127 = ((x2505+x2506)>>(x2507%x2508));

    if (t127 != 4294967294LLU) { NG(); } else { ; }
	
}

void f128(void) {
    	uint64_t x2521 = UINT64_MAX;
	int64_t x2522 = INT64_MIN;
	static uint8_t x2524 = 6U;
	uint64_t t128 = 146912LLU;

    t128 = ((x2521+x2522)>>(x2523%x2524));

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

void f129(void) {
    	static volatile uint8_t x2525 = UINT8_MAX;
	volatile int8_t x2526 = -1;
	int64_t x2527 = -1842701170949295501LL;
	volatile int32_t t129 = 7920851;

    t129 = ((x2525+x2526)>>(x2527%x2528));

    if (t129 != 254) { NG(); } else { ; }
	
}

void f130(void) {
    	int16_t x2561 = -1;
	uint16_t x2562 = 14114U;
	volatile uint64_t x2563 = 6403269LLU;
	int8_t x2564 = 1;
	volatile int32_t t130 = 14329;

    t130 = ((x2561+x2562)>>(x2563%x2564));

    if (t130 != 14113) { NG(); } else { ; }
	
}

void f131(void) {
    	volatile int64_t x2585 = INT64_MAX;
	int8_t x2586 = INT8_MIN;
	uint64_t x2587 = UINT64_MAX;
	uint8_t x2588 = 1U;
	volatile int64_t t131 = 3LL;

    t131 = ((x2585+x2586)>>(x2587%x2588));

    if (t131 != 9223372036854775679LL) { NG(); } else { ; }
	
}

void f132(void) {
    	int32_t x2609 = INT32_MAX;
	int16_t x2610 = INT16_MIN;
	static volatile int64_t x2611 = INT64_MAX;
	int32_t t132 = 64824370;

    t132 = ((x2609+x2610)>>(x2611%x2612));

    if (t132 != 16776959) { NG(); } else { ; }
	
}

void f133(void) {
    	volatile uint64_t x2645 = UINT64_MAX;
	int8_t x2646 = -1;
	int64_t x2647 = INT64_MIN;
	volatile int64_t x2648 = -1LL;

    t133 = ((x2645+x2646)>>(x2647%x2648));

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

void f134(void) {
    	int32_t x2657 = INT32_MAX;
	volatile int32_t x2658 = -9811450;
	static int8_t x2659 = -1;
	volatile uint8_t x2660 = 1U;
	int32_t t134 = 173;

    t134 = ((x2657+x2658)>>(x2659%x2660));

    if (t134 != 2137672197) { NG(); } else { ; }
	
}

void f135(void) {
    	int32_t x2693 = 12300925;
	static int64_t x2694 = 10868515627LL;
	uint8_t x2695 = 0U;
	static volatile int64_t t135 = -15LL;

    t135 = ((x2693+x2694)>>(x2695%x2696));

    if (t135 != 10880816552LL) { NG(); } else { ; }
	
}

void f136(void) {
    	volatile uint8_t x2709 = UINT8_MAX;
	int16_t x2710 = -3;
	static int64_t x2711 = INT64_MIN;
	static volatile int16_t x2712 = INT16_MIN;
	volatile int32_t t136 = -218864;

    t136 = ((x2709+x2710)>>(x2711%x2712));

    if (t136 != 252) { NG(); } else { ; }
	
}

void f137(void) {
    	static uint32_t x2717 = UINT32_MAX;
	int64_t x2719 = -109LL;
	static int32_t x2720 = -1;
	volatile uint32_t t137 = 1549196264U;

    t137 = ((x2717+x2718)>>(x2719%x2720));

    if (t137 != 4294967167U) { NG(); } else { ; }
	
}

void f138(void) {
    	volatile uint32_t x2745 = UINT32_MAX;
	int16_t x2746 = INT16_MAX;
	int32_t x2747 = INT32_MIN;
	int16_t x2748 = -1;
	uint32_t t138 = 158806U;

    t138 = ((x2745+x2746)>>(x2747%x2748));

    if (t138 != 32766U) { NG(); } else { ; }
	
}

void f139(void) {
    	static int64_t x2794 = 18503309849LL;
	uint8_t x2795 = 26U;
	int8_t x2796 = INT8_MIN;

    t139 = ((x2793+x2794)>>(x2795%x2796));

    if (t139 != 275LL) { NG(); } else { ; }
	
}

void f140(void) {
    	uint8_t x2797 = UINT8_MAX;
	volatile uint32_t x2798 = UINT32_MAX;
	static int8_t x2799 = 1;
	volatile int32_t x2800 = -1;
	uint32_t t140 = 13U;

    t140 = ((x2797+x2798)>>(x2799%x2800));

    if (t140 != 254U) { NG(); } else { ; }
	
}

void f141(void) {
    	uint64_t x2801 = UINT64_MAX;
	static uint64_t x2802 = 13514LLU;
	volatile uint16_t x2803 = 2180U;
	static volatile int8_t x2804 = 25;
	uint64_t t141 = 453LLU;

    t141 = ((x2801+x2802)>>(x2803%x2804));

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

void f142(void) {
    	int64_t x2806 = 12941053504LL;
	int16_t x2808 = INT16_MIN;
	int64_t t142 = 32102LL;

    t142 = ((x2805+x2806)>>(x2807%x2808));

    if (t142 != 385LL) { NG(); } else { ; }
	
}

void f143(void) {
    	uint64_t x2829 = 53216506924LLU;
	volatile int8_t x2830 = 41;
	int8_t x2832 = 1;
	volatile uint64_t t143 = 580596499408568685LLU;

    t143 = ((x2829+x2830)>>(x2831%x2832));

    if (t143 != 53216506965LLU) { NG(); } else { ; }
	
}

void f144(void) {
    	static uint16_t x2833 = 8443U;
	static volatile int16_t x2834 = INT16_MAX;
	uint16_t x2835 = 63U;
	int8_t x2836 = 2;

    t144 = ((x2833+x2834)>>(x2835%x2836));

    if (t144 != 20605) { NG(); } else { ; }
	
}

void f145(void) {
    	volatile uint32_t x2837 = 16166U;
	uint8_t x2839 = 1U;
	static int16_t x2840 = -9;

    t145 = ((x2837+x2838)>>(x2839%x2840));

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

void f146(void) {
    	uint16_t x2841 = 0U;
	uint32_t x2842 = UINT32_MAX;
	int16_t x2843 = INT16_MIN;
	uint32_t x2844 = 2042U;
	uint32_t t146 = 13056U;

    t146 = ((x2841+x2842)>>(x2843%x2844));

    if (t146 != 1048575U) { NG(); } else { ; }
	
}

void f147(void) {
    	volatile uint8_t x2853 = 0U;
	int32_t t147 = -11147535;

    t147 = ((x2853+x2854)>>(x2855%x2856));

    if (t147 != 8799) { NG(); } else { ; }
	
}

void f148(void) {
    	int16_t x2857 = 2;
	uint64_t x2858 = 3968595LLU;
	uint8_t x2859 = 5U;
	int32_t x2860 = INT32_MIN;
	uint64_t t148 = 871740290032466LLU;

    t148 = ((x2857+x2858)>>(x2859%x2860));

    if (t148 != 124018LLU) { NG(); } else { ; }
	
}

void f149(void) {
    	int32_t x2869 = INT32_MIN;
	volatile int64_t x2870 = INT64_MAX;
	uint16_t x2871 = 2026U;
	volatile int16_t x2872 = 1;
	volatile int64_t t149 = -242LL;

    t149 = ((x2869+x2870)>>(x2871%x2872));

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

void f150(void) {
    	uint64_t x2873 = 146707LLU;
	int8_t x2874 = -1;
	volatile int8_t x2875 = 53;
	int64_t x2876 = -479546583157795LL;

    t150 = ((x2873+x2874)>>(x2875%x2876));

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

void f151(void) {
    	int16_t x2877 = 470;
	volatile int8_t x2878 = -1;
	int16_t x2879 = INT16_MIN;
	volatile int8_t x2880 = -1;
	int32_t t151 = -1;

    t151 = ((x2877+x2878)>>(x2879%x2880));

    if (t151 != 469) { NG(); } else { ; }
	
}

void f152(void) {
    	uint32_t x2893 = 17949061U;
	static uint64_t x2894 = 604LLU;
	int64_t x2895 = INT64_MIN;
	volatile int16_t x2896 = 1;
	static volatile uint64_t t152 = 638301615539204792LLU;

    t152 = ((x2893+x2894)>>(x2895%x2896));

    if (t152 != 17949665LLU) { NG(); } else { ; }
	
}

void f153(void) {
    	static uint8_t x2929 = 7U;
	int64_t x2930 = -1LL;
	uint8_t x2931 = 14U;
	static int16_t x2932 = INT16_MIN;
	volatile int64_t t153 = -5808331730030644LL;

    t153 = ((x2929+x2930)>>(x2931%x2932));

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

void f154(void) {
    	static volatile int16_t x2970 = INT16_MAX;
	uint16_t x2971 = 972U;

    t154 = ((x2969+x2970)>>(x2971%x2972));

    if (t154 != 32806LL) { NG(); } else { ; }
	
}

void f155(void) {
    	uint32_t x2982 = 7U;
	uint8_t x2983 = 3U;
	volatile int8_t x2984 = INT8_MIN;
	uint32_t t155 = 219U;

    t155 = ((x2981+x2982)>>(x2983%x2984));

    if (t155 != 16U) { NG(); } else { ; }
	
}

void f156(void) {
    	volatile int16_t x3017 = INT16_MAX;
	int16_t x3018 = -1;
	int32_t t156 = 6;

    t156 = ((x3017+x3018)>>(x3019%x3020));

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

void f157(void) {
    	volatile int8_t x3021 = INT8_MIN;
	int64_t x3022 = 349LL;
	volatile uint16_t x3023 = 0U;
	int64_t x3024 = INT64_MIN;
	static int64_t t157 = 1077714395LL;

    t157 = ((x3021+x3022)>>(x3023%x3024));

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

void f158(void) {
    	uint64_t x3045 = 5LLU;
	uint32_t x3046 = UINT32_MAX;
	uint8_t x3048 = 1U;
	uint64_t t158 = 302212295402849876LLU;

    t158 = ((x3045+x3046)>>(x3047%x3048));

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

void f159(void) {
    	uint16_t x3049 = UINT16_MAX;
	static int16_t x3050 = INT16_MIN;
	int64_t x3051 = INT64_MAX;
	int16_t x3052 = 12;
	volatile int32_t t159 = 2;

    t159 = ((x3049+x3050)>>(x3051%x3052));

    if (t159 != 255) { NG(); } else { ; }
	
}

void f160(void) {
    	int8_t x3053 = 1;
	int16_t x3054 = -1;
	uint8_t x3055 = 12U;
	int16_t x3056 = INT16_MIN;
	int32_t t160 = 3648142;

    t160 = ((x3053+x3054)>>(x3055%x3056));

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

void f161(void) {
    	int16_t x3069 = INT16_MAX;
	volatile int32_t x3072 = INT32_MIN;
	static int32_t t161 = -16229934;

    t161 = ((x3069+x3070)>>(x3071%x3072));

    if (t161 != 47) { NG(); } else { ; }
	
}

void f162(void) {
    	volatile int16_t x3074 = INT16_MIN;
	int32_t x3076 = INT32_MAX;
	volatile uint64_t t162 = 27LLU;

    t162 = ((x3073+x3074)>>(x3075%x3076));

    if (t162 != 5414936266LLU) { NG(); } else { ; }
	
}

void f163(void) {
    	uint16_t x3089 = 0U;
	int8_t x3090 = INT8_MAX;
	int8_t x3092 = 1;
	volatile int32_t t163 = 119367400;

    t163 = ((x3089+x3090)>>(x3091%x3092));

    if (t163 != 127) { NG(); } else { ; }
	
}

void f164(void) {
    	uint16_t x3109 = 4U;
	int16_t x3110 = INT16_MAX;
	uint64_t x3112 = 58LLU;
	static volatile int32_t t164 = -1;

    t164 = ((x3109+x3110)>>(x3111%x3112));

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

void f165(void) {
    	volatile int32_t x3113 = -49;
	static int32_t x3114 = INT32_MAX;
	int8_t x3115 = 0;
	int32_t x3116 = -1;
	int32_t t165 = 9578282;

    t165 = ((x3113+x3114)>>(x3115%x3116));

    if (t165 != 2147483598) { NG(); } else { ; }
	
}

void f166(void) {
    	volatile uint64_t x3117 = 829478454LLU;
	uint32_t x3118 = 1U;
	uint8_t x3119 = 4U;
	int8_t x3120 = 1;
	volatile uint64_t t166 = 32623927LLU;

    t166 = ((x3117+x3118)>>(x3119%x3120));

    if (t166 != 829478455LLU) { NG(); } else { ; }
	
}

void f167(void) {
    	uint8_t x3125 = UINT8_MAX;
	int8_t x3127 = 3;
	static int32_t x3128 = 2309356;
	static volatile int32_t t167 = -4892;

    t167 = ((x3125+x3126)>>(x3127%x3128));

    if (t167 != 63) { NG(); } else { ; }
	
}

void f168(void) {
    	uint16_t x3133 = 2U;
	int16_t x3134 = -2;
	static int16_t x3135 = 9625;
	static int64_t x3136 = -10LL;
	int32_t t168 = -1533;

    t168 = ((x3133+x3134)>>(x3135%x3136));

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

void f169(void) {
    	volatile uint32_t x3137 = 1U;
	uint8_t x3138 = 5U;
	int64_t x3139 = -112815629076LL;
	int16_t x3140 = -1;
	static uint32_t t169 = 906974854U;

    t169 = ((x3137+x3138)>>(x3139%x3140));

    if (t169 != 6U) { NG(); } else { ; }
	
}

void f170(void) {
    	volatile int16_t x3153 = 3496;
	int32_t x3154 = -1;
	uint16_t x3155 = 43U;
	int32_t t170 = 109303805;

    t170 = ((x3153+x3154)>>(x3155%x3156));

    if (t170 != 3495) { NG(); } else { ; }
	
}

void f171(void) {
    	static int8_t x3158 = 11;
	volatile int64_t x3160 = -1473657902810534LL;
	static volatile int32_t t171 = -863656;

    t171 = ((x3157+x3158)>>(x3159%x3160));

    if (t171 != 11) { NG(); } else { ; }
	
}

void f172(void) {
    	static uint16_t x3165 = 1502U;
	int8_t x3166 = 1;

    t172 = ((x3165+x3166)>>(x3167%x3168));

    if (t172 != 2) { NG(); } else { ; }
	
}

void f173(void) {
    	volatile uint8_t x3177 = 11U;
	int16_t x3178 = INT16_MAX;
	static uint32_t x3179 = UINT32_MAX;
	int32_t x3180 = -28;
	int32_t t173 = 24657037;

    t173 = ((x3177+x3178)>>(x3179%x3180));

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

void f174(void) {
    	static int8_t x3181 = 1;
	int8_t x3183 = INT8_MAX;
	int32_t t174 = 1050342;

    t174 = ((x3181+x3182)>>(x3183%x3184));

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

void f175(void) {
    	uint64_t x3193 = 537397020940861045LLU;
	int64_t x3194 = -1LL;
	volatile uint64_t x3196 = 1LLU;
	volatile uint64_t t175 = 100359667643180429LLU;

    t175 = ((x3193+x3194)>>(x3195%x3196));

    if (t175 != 537397020940861044LLU) { NG(); } else { ; }
	
}

void f176(void) {
    	volatile uint64_t x3237 = UINT64_MAX;
	volatile uint32_t x3238 = 366898787U;
	volatile int64_t x3239 = INT64_MIN;
	int32_t x3240 = INT32_MIN;
	uint64_t t176 = 4824353713LLU;

    t176 = ((x3237+x3238)>>(x3239%x3240));

    if (t176 != 366898786LLU) { NG(); } else { ; }
	
}

void f177(void) {
    	static uint32_t x3258 = UINT32_MAX;
	uint16_t x3259 = 28U;
	int64_t x3260 = INT64_MIN;
	static volatile int64_t t177 = 8654890365013547LL;

    t177 = ((x3257+x3258)>>(x3259%x3260));

    if (t177 != 4017233937LL) { NG(); } else { ; }
	
}

void f178(void) {
    	uint8_t x3301 = UINT8_MAX;
	int64_t x3302 = -1LL;
	int16_t x3303 = -12;
	int64_t t178 = -43209663LL;

    t178 = ((x3301+x3302)>>(x3303%x3304));

    if (t178 != 254LL) { NG(); } else { ; }
	
}

void f179(void) {
    	volatile uint8_t x3331 = 9U;
	volatile uint16_t x3332 = 851U;
	volatile uint32_t t179 = 38309303U;

    t179 = ((x3329+x3330)>>(x3331%x3332));

    if (t179 != 4U) { NG(); } else { ; }
	
}

void f180(void) {
    	uint32_t x3337 = 5U;
	volatile int8_t x3338 = 0;
	int16_t x3339 = INT16_MIN;
	uint16_t x3340 = 16U;
	volatile uint32_t t180 = 21091U;

    t180 = ((x3337+x3338)>>(x3339%x3340));

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

void f181(void) {
    	static uint16_t x3349 = 317U;
	int8_t x3350 = INT8_MIN;
	static int64_t x3351 = INT64_MIN;
	int8_t x3352 = -1;
	volatile int32_t t181 = 0;

    t181 = ((x3349+x3350)>>(x3351%x3352));

    if (t181 != 189) { NG(); } else { ; }
	
}

void f182(void) {
    	uint32_t x3369 = 15U;
	int8_t x3370 = -1;
	int32_t x3371 = INT32_MIN;
	volatile int32_t x3372 = INT32_MIN;
	volatile uint32_t t182 = 432528711U;

    t182 = ((x3369+x3370)>>(x3371%x3372));

    if (t182 != 14U) { NG(); } else { ; }
	
}

void f183(void) {
    	int64_t x3377 = -1LL;
	uint16_t x3378 = UINT16_MAX;
	int8_t x3379 = INT8_MIN;
	int16_t x3380 = 16;
	int64_t t183 = 4291061LL;

    t183 = ((x3377+x3378)>>(x3379%x3380));

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

void f184(void) {
    	volatile int16_t x3397 = INT16_MAX;
	int64_t x3398 = 16LL;
	static uint16_t x3399 = 7U;
	uint8_t x3400 = UINT8_MAX;
	int64_t t184 = 96779792497750LL;

    t184 = ((x3397+x3398)>>(x3399%x3400));

    if (t184 != 256LL) { NG(); } else { ; }
	
}

void f185(void) {
    	uint64_t x3401 = 791288LLU;
	int8_t x3402 = INT8_MAX;
	int32_t x3403 = INT32_MIN;
	static int16_t x3404 = -1;
	static volatile uint64_t t185 = 38300LLU;

    t185 = ((x3401+x3402)>>(x3403%x3404));

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

void f186(void) {
    	int64_t x3405 = -1LL;
	uint16_t x3406 = UINT16_MAX;
	volatile int64_t t186 = -5746987LL;

    t186 = ((x3405+x3406)>>(x3407%x3408));

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

void f187(void) {
    	int8_t x3417 = 0;
	int32_t x3418 = INT32_MAX;
	int8_t x3419 = 4;
	int64_t x3420 = INT64_MAX;

    t187 = ((x3417+x3418)>>(x3419%x3420));

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

void f188(void) {
    	int16_t x3421 = INT16_MAX;
	int16_t x3422 = INT16_MAX;
	int16_t x3423 = INT16_MAX;
	int64_t x3424 = -1LL;
	int32_t t188 = 657;

    t188 = ((x3421+x3422)>>(x3423%x3424));

    if (t188 != 65534) { NG(); } else { ; }
	
}

void f189(void) {
    	volatile uint64_t x3437 = 702140156480LLU;
	static int32_t x3438 = -1;
	static volatile uint8_t x3440 = 122U;
	volatile uint64_t t189 = 2162383155232LLU;

    t189 = ((x3437+x3438)>>(x3439%x3440));

    if (t189 != 21427617LLU) { NG(); } else { ; }
	
}

void f190(void) {
    	static uint32_t x3441 = 14161299U;
	int16_t x3442 = -926;
	int8_t x3443 = -1;
	volatile int64_t x3444 = -1LL;
	uint32_t t190 = 106U;

    t190 = ((x3441+x3442)>>(x3443%x3444));

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

void f191(void) {
    	static int64_t x3468 = -14LL;
	static volatile int64_t t191 = -1134174984226489840LL;

    t191 = ((x3465+x3466)>>(x3467%x3468));

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

void f192(void) {
    	int64_t x3469 = INT64_MAX;
	int16_t x3470 = INT16_MIN;
	volatile int32_t x3471 = INT32_MIN;
	int16_t x3472 = INT16_MIN;
	int64_t t192 = 935935618772356899LL;

    t192 = ((x3469+x3470)>>(x3471%x3472));

    if (t192 != 9223372036854743039LL) { NG(); } else { ; }
	
}

void f193(void) {
    	int16_t x3489 = INT16_MIN;
	uint32_t x3490 = UINT32_MAX;
	uint8_t x3492 = 6U;

    t193 = ((x3489+x3490)>>(x3491%x3492));

    if (t193 != 4294934527U) { NG(); } else { ; }
	
}

void f194(void) {
    	int64_t x3525 = INT64_MAX;
	int32_t x3528 = INT32_MIN;
	volatile int64_t t194 = 9049794LL;

    t194 = ((x3525+x3526)>>(x3527%x3528));

    if (t194 != 288230376084602879LL) { NG(); } else { ; }
	
}

void f195(void) {
    	uint32_t x3553 = 1789834U;
	uint16_t x3555 = 0U;
	static uint16_t x3556 = 14U;

    t195 = ((x3553+x3554)>>(x3555%x3556));

    if (t195 != 1789833U) { NG(); } else { ; }
	
}

void f196(void) {
    	uint16_t x3561 = UINT16_MAX;
	static int32_t x3563 = -798605;
	int16_t x3564 = -1;
	volatile int32_t t196 = 6756;

    t196 = ((x3561+x3562)>>(x3563%x3564));

    if (t196 != 65584) { NG(); } else { ; }
	
}

void f197(void) {
    	int16_t x3569 = INT16_MIN;
	uint32_t x3570 = 14347U;
	volatile uint8_t x3571 = 2U;
	int8_t x3572 = INT8_MIN;
	uint32_t t197 = 1317567U;

    t197 = ((x3569+x3570)>>(x3571%x3572));

    if (t197 != 1073737218U) { NG(); } else { ; }
	
}

void f198(void) {
    	uint64_t x3585 = 20263LLU;
	uint8_t x3586 = 31U;
	uint32_t x3587 = 9U;
	int16_t x3588 = INT16_MIN;
	volatile uint64_t t198 = 8265619432843186LLU;

    t198 = ((x3585+x3586)>>(x3587%x3588));

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

void f199(void) {
    	volatile int8_t x3589 = INT8_MIN;
	uint16_t x3590 = 3928U;
	int16_t x3591 = -1;

    t199 = ((x3589+x3590)>>(x3591%x3592));

    if (t199 != 3800) { 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;
}

