
/*
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 int32_t t0 = 223;
int8_t x6 = -1;
int16_t x10 = INT16_MAX;
int32_t x13 = INT32_MAX;
static int8_t x16 = -11;
int64_t x21 = INT64_MIN;
int16_t x22 = -13;
int64_t t5 = INT64_MIN;
int32_t x31 = INT32_MIN;
int16_t x38 = -1;
int16_t x41 = INT16_MIN;
int32_t t10 = 1;
static volatile uint16_t x46 = UINT16_MAX;
int32_t x49 = INT32_MAX;
int32_t x51 = -1;
static uint64_t x61 = UINT64_MAX;
static uint16_t x72 = 11866U;
volatile int32_t t18 = 519092;
int64_t x77 = -4359665LL;
uint64_t x83 = 112LLU;
volatile int32_t t20 = INT32_MIN;
int32_t x87 = INT32_MIN;
int8_t x95 = -1;
int8_t x102 = INT8_MIN;
int64_t x104 = 1672080891635LL;
static int16_t x106 = 6682;
uint64_t x111 = 2022993698729157LLU;
static volatile int64_t x112 = INT64_MIN;
uint16_t x118 = 71U;
int16_t x121 = 4;
int32_t t30 = -842;
static int32_t x125 = -21;
int32_t x127 = -1;
int8_t x130 = INT8_MIN;
int64_t x131 = -2905LL;
uint16_t x136 = 4330U;
uint32_t x138 = 258U;
int32_t x142 = INT32_MIN;
volatile int8_t x143 = 13;
volatile int32_t t35 = 892;
int32_t t36 = -1058615942;
static int64_t x150 = 263527106LL;
int64_t t38 = -15LL;
int32_t x158 = -231;
volatile uint64_t t40 = 13634636553510LLU;
volatile int32_t t42 = 55183;
uint64_t x173 = 6506436320212231LLU;
uint8_t x179 = UINT8_MAX;
int32_t t48 = -46057082;
static int8_t x201 = 0;
volatile int64_t x209 = INT64_MIN;
int32_t x210 = -1;
int64_t x211 = INT64_MIN;
volatile int8_t x216 = INT8_MAX;
volatile int32_t x219 = -1;
int32_t x224 = 29;
int64_t t57 = INT64_MAX;
volatile int64_t x246 = -1LL;
volatile int32_t x247 = -1;
static uint16_t x248 = 428U;
static uint32_t x252 = UINT32_MAX;
volatile uint8_t x257 = 6U;
int32_t x265 = 11;
static int16_t x266 = INT16_MIN;
volatile uint16_t x268 = 31788U;
volatile int64_t x270 = -1LL;
volatile int32_t t68 = 196183191;
int64_t x279 = INT64_MIN;
static volatile int32_t x280 = 857330;
static int64_t x285 = 11024213786LL;
static uint8_t x290 = 4U;
uint32_t x294 = UINT32_MAX;
static uint64_t x298 = 289866204377412545LLU;
uint8_t x300 = 37U;
int64_t x304 = -499167512966513575LL;
int32_t t76 = -37145;
volatile int16_t x314 = INT16_MAX;
static uint32_t t79 = 2U;
int32_t x322 = INT32_MIN;
int32_t x323 = -780710660;
int32_t x328 = INT32_MIN;
volatile int32_t x347 = -9108818;
volatile uint64_t x351 = UINT64_MAX;
volatile int32_t t87 = 0;
int16_t x355 = INT16_MIN;
int64_t x357 = 7616757049897LL;
int64_t x358 = 34828854680LL;
int64_t x361 = INT64_MIN;
uint16_t x364 = 81U;
static int32_t x367 = INT32_MIN;
int16_t x368 = -4393;
uint16_t x369 = 5958U;
static uint8_t x377 = 116U;
uint8_t x387 = UINT8_MAX;
int16_t x388 = 1;
static uint16_t x389 = 2911U;
uint8_t x391 = UINT8_MAX;
volatile uint32_t x393 = 203U;
int32_t x400 = -932124;
static int64_t x401 = 108LL;
int64_t t100 = -9870131LL;
int16_t x405 = -6;
int8_t x407 = 63;
int16_t x409 = -1;
int64_t x419 = INT64_MIN;
int8_t x420 = INT8_MIN;
int32_t x424 = INT32_MIN;
volatile int16_t x427 = INT16_MIN;
uint16_t x429 = UINT16_MAX;
uint64_t x433 = 51382LLU;
static int64_t x436 = INT64_MIN;
int16_t x439 = INT16_MIN;
int8_t x443 = -2;
int8_t x444 = -1;
static volatile int32_t t110 = -23;
uint32_t x445 = 22878U;
int64_t x453 = -1LL;
int32_t x454 = -488202;
static uint8_t x465 = UINT8_MAX;
volatile int8_t x466 = -1;
volatile int32_t t116 = 205;
volatile uint16_t x471 = UINT16_MAX;
int64_t x474 = -1LL;
volatile int16_t x475 = INT16_MAX;
int16_t x478 = -7;
uint8_t x480 = UINT8_MAX;
volatile int8_t x483 = INT8_MIN;
int16_t x484 = 12980;
int64_t x490 = -1LL;
static uint8_t x493 = 3U;
uint32_t x494 = 11794U;
volatile int32_t t123 = -1;
uint16_t x499 = 46U;
static volatile int8_t x505 = INT8_MAX;
static volatile uint16_t x515 = 12U;
int16_t x516 = INT16_MIN;
int64_t x519 = -2036564222137772LL;
int32_t t130 = -4;
volatile int64_t x526 = INT64_MAX;
int32_t x549 = INT32_MIN;
static int16_t x566 = 1;
int8_t x567 = 0;
uint8_t x574 = 1U;
uint64_t x579 = UINT64_MAX;
static int32_t x586 = -1;
volatile int32_t t146 = -7234385;
uint64_t x589 = UINT64_MAX;
uint16_t x595 = 2386U;
int64_t x598 = INT64_MAX;
int32_t t151 = -115608525;
int32_t t152 = 207472923;
int32_t x615 = INT32_MIN;
static uint16_t x617 = 43U;
int32_t t157 = 15659;
int16_t x634 = INT16_MAX;
uint32_t x635 = UINT32_MAX;
static int64_t x639 = INT64_MIN;
uint64_t x641 = 997617LLU;
uint8_t x644 = UINT8_MAX;
uint16_t x652 = 5U;
volatile uint32_t x653 = 42154001U;
static uint8_t x655 = 1U;
int16_t x666 = -1;
uint32_t x668 = 28U;
int32_t t166 = 29461;
volatile int16_t x673 = INT16_MIN;
int32_t t168 = -7;
uint8_t x677 = UINT8_MAX;
volatile int64_t x685 = INT64_MIN;
uint32_t x709 = UINT32_MAX;
static int8_t x710 = INT8_MIN;
uint16_t x720 = 4U;
static int64_t x723 = INT64_MIN;
uint32_t x726 = UINT32_MAX;
int32_t x732 = INT32_MAX;
int8_t x740 = INT8_MAX;
volatile uint64_t t185 = 662251LLU;
uint64_t x750 = UINT64_MAX;
int32_t t187 = 6257024;
uint16_t x758 = UINT16_MAX;
int64_t x762 = -354LL;
int16_t x764 = -33;
static uint32_t x775 = 0U;
volatile uint32_t t193 = 2388334U;
static uint16_t x778 = UINT16_MAX;
volatile int32_t x783 = -1;
uint64_t x785 = 269231537203017LLU;
volatile int32_t x792 = -1;
int8_t x793 = INT8_MAX;
static int8_t x795 = INT8_MIN;
int32_t t198 = -7951;
int64_t x800 = INT64_MIN;


void f0(void) {
    	int8_t x1 = -1;
	static volatile int8_t x2 = INT8_MIN;
	volatile int16_t x3 = -15819;
	uint8_t x4 = UINT8_MAX;

    t0 = (x1^(x2>(x3>x4)));

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

void f1(void) {
    	int32_t x5 = INT32_MIN;
	int32_t x7 = INT32_MIN;
	int64_t x8 = INT64_MIN;
	int32_t t1 = INT32_MIN;

    t1 = (x5^(x6>(x7>x8)));

    if (t1 != INT32_MIN) { NG(); } else { ; }
	
}

void f2(void) {
    	uint32_t x9 = 23365085U;
	int64_t x11 = -494867923134719750LL;
	int32_t x12 = INT32_MIN;
	volatile uint32_t t2 = 1326317U;

    t2 = (x9^(x10>(x11>x12)));

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

void f3(void) {
    	static volatile uint16_t x14 = 21U;
	static int64_t x15 = INT64_MIN;
	int32_t t3 = -72755;

    t3 = (x13^(x14>(x15>x16)));

    if (t3 != 2147483646) { NG(); } else { ; }
	
}

void f4(void) {
    	int16_t x17 = INT16_MAX;
	uint8_t x18 = 81U;
	volatile int16_t x19 = 3;
	volatile int8_t x20 = INT8_MAX;
	volatile int32_t t4 = -1361;

    t4 = (x17^(x18>(x19>x20)));

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

void f5(void) {
    	volatile int64_t x23 = 391LL;
	int64_t x24 = INT64_MIN;

    t5 = (x21^(x22>(x23>x24)));

    if (t5 != INT64_MIN) { NG(); } else { ; }
	
}

void f6(void) {
    	uint32_t x25 = 1238939U;
	volatile int32_t x26 = -1;
	static int8_t x27 = -1;
	int16_t x28 = -1;
	volatile uint32_t t6 = 7U;

    t6 = (x25^(x26>(x27>x28)));

    if (t6 != 1238939U) { NG(); } else { ; }
	
}

void f7(void) {
    	uint8_t x29 = 15U;
	int32_t x30 = INT32_MIN;
	volatile int32_t x32 = 1885247;
	volatile int32_t t7 = -31;

    t7 = (x29^(x30>(x31>x32)));

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

void f8(void) {
    	int8_t x33 = INT8_MAX;
	int32_t x34 = 116568;
	int32_t x35 = -1;
	int64_t x36 = INT64_MIN;
	volatile int32_t t8 = 14;

    t8 = (x33^(x34>(x35>x36)));

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

void f9(void) {
    	static volatile uint64_t x37 = 8911LLU;
	uint8_t x39 = UINT8_MAX;
	uint16_t x40 = 252U;
	static volatile uint64_t t9 = 340480463906633LLU;

    t9 = (x37^(x38>(x39>x40)));

    if (t9 != 8911LLU) { NG(); } else { ; }
	
}

void f10(void) {
    	int8_t x42 = -1;
	int16_t x43 = -31;
	uint16_t x44 = UINT16_MAX;

    t10 = (x41^(x42>(x43>x44)));

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

void f11(void) {
    	uint8_t x45 = UINT8_MAX;
	int8_t x47 = INT8_MIN;
	int64_t x48 = -1LL;
	volatile int32_t t11 = 3862;

    t11 = (x45^(x46>(x47>x48)));

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

void f12(void) {
    	int64_t x50 = 26LL;
	int8_t x52 = -3;
	static int32_t t12 = 225;

    t12 = (x49^(x50>(x51>x52)));

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

void f13(void) {
    	int16_t x53 = INT16_MIN;
	uint64_t x54 = 536424930656LLU;
	int16_t x55 = 0;
	uint64_t x56 = UINT64_MAX;
	int32_t t13 = 0;

    t13 = (x53^(x54>(x55>x56)));

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

void f14(void) {
    	volatile uint16_t x57 = 2198U;
	volatile int16_t x58 = -1;
	int32_t x59 = -1;
	volatile int64_t x60 = 965330217413027LL;
	int32_t t14 = 1417917;

    t14 = (x57^(x58>(x59>x60)));

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

void f15(void) {
    	volatile int8_t x62 = INT8_MIN;
	static int32_t x63 = 54;
	uint64_t x64 = 2138LLU;
	uint64_t t15 = UINT64_MAX;

    t15 = (x61^(x62>(x63>x64)));

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

void f16(void) {
    	int32_t x65 = INT32_MIN;
	int64_t x66 = -899LL;
	static int64_t x67 = INT64_MIN;
	int64_t x68 = INT64_MAX;
	int32_t t16 = INT32_MIN;

    t16 = (x65^(x66>(x67>x68)));

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

void f17(void) {
    	static int8_t x69 = INT8_MIN;
	volatile uint16_t x70 = 905U;
	uint32_t x71 = UINT32_MAX;
	volatile int32_t t17 = 480;

    t17 = (x69^(x70>(x71>x72)));

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

void f18(void) {
    	volatile int16_t x73 = INT16_MIN;
	int16_t x74 = INT16_MIN;
	int16_t x75 = INT16_MIN;
	static uint64_t x76 = 484441765187352308LLU;

    t18 = (x73^(x74>(x75>x76)));

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

void f19(void) {
    	int16_t x78 = INT16_MAX;
	static uint64_t x79 = 30LLU;
	int64_t x80 = -1LL;
	volatile int64_t t19 = 58414236LL;

    t19 = (x77^(x78>(x79>x80)));

    if (t19 != -4359666LL) { NG(); } else { ; }
	
}

void f20(void) {
    	int32_t x81 = INT32_MIN;
	int32_t x82 = -768319683;
	volatile uint16_t x84 = UINT16_MAX;

    t20 = (x81^(x82>(x83>x84)));

    if (t20 != INT32_MIN) { NG(); } else { ; }
	
}

void f21(void) {
    	static volatile int8_t x85 = INT8_MAX;
	static uint64_t x86 = 1791LLU;
	uint8_t x88 = 43U;
	volatile int32_t t21 = -41296039;

    t21 = (x85^(x86>(x87>x88)));

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

void f22(void) {
    	uint8_t x89 = 0U;
	int8_t x90 = -30;
	uint16_t x91 = 2U;
	uint8_t x92 = 123U;
	volatile int32_t t22 = 8;

    t22 = (x89^(x90>(x91>x92)));

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

void f23(void) {
    	volatile int8_t x93 = 12;
	int8_t x94 = 1;
	uint8_t x96 = 1U;
	static volatile int32_t t23 = 898;

    t23 = (x93^(x94>(x95>x96)));

    if (t23 != 13) { NG(); } else { ; }
	
}

void f24(void) {
    	volatile int8_t x97 = 1;
	int32_t x98 = -113603420;
	volatile uint64_t x99 = 3601LLU;
	int8_t x100 = INT8_MIN;
	static volatile int32_t t24 = 11510;

    t24 = (x97^(x98>(x99>x100)));

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

void f25(void) {
    	uint8_t x101 = UINT8_MAX;
	volatile int64_t x103 = -13LL;
	volatile int32_t t25 = -7447859;

    t25 = (x101^(x102>(x103>x104)));

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

void f26(void) {
    	uint16_t x105 = 116U;
	int16_t x107 = -3352;
	uint32_t x108 = 0U;
	static int32_t t26 = -1;

    t26 = (x105^(x106>(x107>x108)));

    if (t26 != 117) { NG(); } else { ; }
	
}

void f27(void) {
    	uint64_t x109 = 3891616LLU;
	volatile int64_t x110 = -1LL;
	uint64_t t27 = 15800007249LLU;

    t27 = (x109^(x110>(x111>x112)));

    if (t27 != 3891616LLU) { NG(); } else { ; }
	
}

void f28(void) {
    	int16_t x113 = -1;
	int32_t x114 = INT32_MIN;
	int16_t x115 = 147;
	int64_t x116 = INT64_MIN;
	volatile int32_t t28 = 202493;

    t28 = (x113^(x114>(x115>x116)));

    if (t28 != -1) { NG(); } else { ; }
	
}

void f29(void) {
    	uint32_t x117 = 68U;
	uint8_t x119 = 9U;
	int16_t x120 = 1;
	volatile uint32_t t29 = 51U;

    t29 = (x117^(x118>(x119>x120)));

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

void f30(void) {
    	int32_t x122 = INT32_MIN;
	uint32_t x123 = 135905257U;
	uint16_t x124 = 4234U;

    t30 = (x121^(x122>(x123>x124)));

    if (t30 != 4) { NG(); } else { ; }
	
}

void f31(void) {
    	volatile int64_t x126 = -1465LL;
	int16_t x128 = INT16_MAX;
	static int32_t t31 = -47166306;

    t31 = (x125^(x126>(x127>x128)));

    if (t31 != -21) { NG(); } else { ; }
	
}

void f32(void) {
    	volatile int64_t x129 = -1LL;
	static int64_t x132 = INT64_MIN;
	volatile int64_t t32 = -131059875587151781LL;

    t32 = (x129^(x130>(x131>x132)));

    if (t32 != -1LL) { NG(); } else { ; }
	
}

void f33(void) {
    	uint64_t x133 = 1348LLU;
	int16_t x134 = INT16_MIN;
	int64_t x135 = -1LL;
	volatile uint64_t t33 = 86562425952LLU;

    t33 = (x133^(x134>(x135>x136)));

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

void f34(void) {
    	uint8_t x137 = UINT8_MAX;
	int16_t x139 = INT16_MIN;
	int64_t x140 = -1LL;
	int32_t t34 = 147031;

    t34 = (x137^(x138>(x139>x140)));

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

void f35(void) {
    	volatile int8_t x141 = INT8_MIN;
	volatile int64_t x144 = INT64_MIN;

    t35 = (x141^(x142>(x143>x144)));

    if (t35 != -128) { NG(); } else { ; }
	
}

void f36(void) {
    	static volatile int32_t x145 = -1;
	uint16_t x146 = UINT16_MAX;
	static int64_t x147 = -122820581684998LL;
	uint16_t x148 = 3418U;

    t36 = (x145^(x146>(x147>x148)));

    if (t36 != -2) { NG(); } else { ; }
	
}

void f37(void) {
    	volatile int64_t x149 = 28739981785264LL;
	int16_t x151 = 0;
	int32_t x152 = -124;
	static int64_t t37 = -1013041192232LL;

    t37 = (x149^(x150>(x151>x152)));

    if (t37 != 28739981785265LL) { NG(); } else { ; }
	
}

void f38(void) {
    	int64_t x153 = 7979LL;
	static int16_t x154 = 22;
	int32_t x155 = -1;
	int16_t x156 = -1;

    t38 = (x153^(x154>(x155>x156)));

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

void f39(void) {
    	int64_t x157 = INT64_MIN;
	static int64_t x159 = INT64_MIN;
	static uint16_t x160 = 47U;
	int64_t t39 = INT64_MIN;

    t39 = (x157^(x158>(x159>x160)));

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

void f40(void) {
    	uint64_t x161 = 6448665LLU;
	uint8_t x162 = 44U;
	int64_t x163 = INT64_MIN;
	volatile int16_t x164 = -1;

    t40 = (x161^(x162>(x163>x164)));

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

void f41(void) {
    	uint16_t x165 = 13U;
	static volatile uint32_t x166 = UINT32_MAX;
	int16_t x167 = -1;
	volatile int8_t x168 = 3;
	int32_t t41 = -2640275;

    t41 = (x165^(x166>(x167>x168)));

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

void f42(void) {
    	uint16_t x169 = 13U;
	int32_t x170 = -1;
	volatile int16_t x171 = INT16_MIN;
	int64_t x172 = INT64_MIN;

    t42 = (x169^(x170>(x171>x172)));

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

void f43(void) {
    	int64_t x174 = INT64_MAX;
	int16_t x175 = INT16_MAX;
	volatile int64_t x176 = 85800LL;
	uint64_t t43 = 605093319215158LLU;

    t43 = (x173^(x174>(x175>x176)));

    if (t43 != 6506436320212230LLU) { NG(); } else { ; }
	
}

void f44(void) {
    	int8_t x177 = INT8_MIN;
	int32_t x178 = INT32_MIN;
	static volatile int16_t x180 = 15501;
	int32_t t44 = -3666526;

    t44 = (x177^(x178>(x179>x180)));

    if (t44 != -128) { NG(); } else { ; }
	
}

void f45(void) {
    	static int16_t x181 = INT16_MAX;
	int16_t x182 = INT16_MAX;
	static uint32_t x183 = UINT32_MAX;
	uint64_t x184 = UINT64_MAX;
	int32_t t45 = -5250;

    t45 = (x181^(x182>(x183>x184)));

    if (t45 != 32766) { NG(); } else { ; }
	
}

void f46(void) {
    	int8_t x185 = INT8_MAX;
	static int64_t x186 = INT64_MAX;
	int64_t x187 = INT64_MIN;
	volatile int16_t x188 = -251;
	int32_t t46 = -139625606;

    t46 = (x185^(x186>(x187>x188)));

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

void f47(void) {
    	uint16_t x189 = 0U;
	volatile uint16_t x190 = 287U;
	int32_t x191 = INT32_MIN;
	static uint32_t x192 = UINT32_MAX;
	int32_t t47 = 88;

    t47 = (x189^(x190>(x191>x192)));

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

void f48(void) {
    	uint16_t x193 = 0U;
	int64_t x194 = INT64_MIN;
	int64_t x195 = INT64_MAX;
	uint16_t x196 = UINT16_MAX;

    t48 = (x193^(x194>(x195>x196)));

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

void f49(void) {
    	volatile int32_t x197 = -92540;
	int8_t x198 = INT8_MIN;
	volatile int16_t x199 = INT16_MIN;
	static int8_t x200 = 15;
	int32_t t49 = -2822351;

    t49 = (x197^(x198>(x199>x200)));

    if (t49 != -92540) { NG(); } else { ; }
	
}

void f50(void) {
    	volatile uint32_t x202 = UINT32_MAX;
	uint16_t x203 = UINT16_MAX;
	uint64_t x204 = UINT64_MAX;
	int32_t t50 = -1;

    t50 = (x201^(x202>(x203>x204)));

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

void f51(void) {
    	int16_t x205 = 113;
	int8_t x206 = -14;
	int8_t x207 = -1;
	int16_t x208 = INT16_MAX;
	int32_t t51 = -31189;

    t51 = (x205^(x206>(x207>x208)));

    if (t51 != 113) { NG(); } else { ; }
	
}

void f52(void) {
    	int64_t x212 = -1LL;
	int64_t t52 = INT64_MIN;

    t52 = (x209^(x210>(x211>x212)));

    if (t52 != INT64_MIN) { NG(); } else { ; }
	
}

void f53(void) {
    	int8_t x213 = -1;
	int64_t x214 = INT64_MIN;
	int16_t x215 = -1;
	static volatile int32_t t53 = -1;

    t53 = (x213^(x214>(x215>x216)));

    if (t53 != -1) { NG(); } else { ; }
	
}

void f54(void) {
    	int64_t x217 = INT64_MIN;
	uint32_t x218 = 11U;
	static volatile int8_t x220 = INT8_MIN;
	volatile int64_t t54 = -249581574753LL;

    t54 = (x217^(x218>(x219>x220)));

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

void f55(void) {
    	int32_t x221 = 0;
	static uint16_t x222 = UINT16_MAX;
	uint8_t x223 = UINT8_MAX;
	volatile int32_t t55 = -7913421;

    t55 = (x221^(x222>(x223>x224)));

    if (t55 != 1) { NG(); } else { ; }
	
}

void f56(void) {
    	static int8_t x225 = -16;
	uint8_t x226 = 3U;
	int64_t x227 = -1LL;
	uint32_t x228 = UINT32_MAX;
	static volatile int32_t t56 = 75;

    t56 = (x225^(x226>(x227>x228)));

    if (t56 != -15) { NG(); } else { ; }
	
}

void f57(void) {
    	int64_t x229 = INT64_MAX;
	volatile int32_t x230 = INT32_MIN;
	int8_t x231 = INT8_MIN;
	int64_t x232 = -1LL;

    t57 = (x229^(x230>(x231>x232)));

    if (t57 != INT64_MAX) { NG(); } else { ; }
	
}

void f58(void) {
    	int64_t x233 = 11159131025867491LL;
	int64_t x234 = INT64_MIN;
	static int16_t x235 = INT16_MAX;
	int32_t x236 = -880993115;
	volatile int64_t t58 = 93LL;

    t58 = (x233^(x234>(x235>x236)));

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

void f59(void) {
    	static volatile uint16_t x237 = UINT16_MAX;
	static int64_t x238 = INT64_MIN;
	int32_t x239 = INT32_MIN;
	volatile uint32_t x240 = 3533U;
	static int32_t t59 = 58793;

    t59 = (x237^(x238>(x239>x240)));

    if (t59 != 65535) { NG(); } else { ; }
	
}

void f60(void) {
    	int8_t x241 = -1;
	int64_t x242 = INT64_MAX;
	int64_t x243 = INT64_MIN;
	int16_t x244 = INT16_MAX;
	volatile int32_t t60 = -24;

    t60 = (x241^(x242>(x243>x244)));

    if (t60 != -2) { NG(); } else { ; }
	
}

void f61(void) {
    	int8_t x245 = -1;
	int32_t t61 = 10307;

    t61 = (x245^(x246>(x247>x248)));

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

void f62(void) {
    	volatile uint32_t x249 = 740929U;
	int32_t x250 = INT32_MAX;
	uint16_t x251 = UINT16_MAX;
	volatile uint32_t t62 = 1U;

    t62 = (x249^(x250>(x251>x252)));

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

void f63(void) {
    	int16_t x253 = INT16_MIN;
	volatile int16_t x254 = 8632;
	int16_t x255 = -1;
	uint16_t x256 = 3U;
	volatile int32_t t63 = 0;

    t63 = (x253^(x254>(x255>x256)));

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

void f64(void) {
    	uint8_t x258 = 58U;
	uint64_t x259 = UINT64_MAX;
	int8_t x260 = -1;
	static volatile int32_t t64 = 362844;

    t64 = (x257^(x258>(x259>x260)));

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

void f65(void) {
    	uint32_t x261 = 220096005U;
	int64_t x262 = -1LL;
	int8_t x263 = -1;
	volatile int64_t x264 = -4892236LL;
	volatile uint32_t t65 = 656937209U;

    t65 = (x261^(x262>(x263>x264)));

    if (t65 != 220096005U) { NG(); } else { ; }
	
}

void f66(void) {
    	int32_t x267 = -75387;
	int32_t t66 = -7;

    t66 = (x265^(x266>(x267>x268)));

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

void f67(void) {
    	uint8_t x269 = UINT8_MAX;
	int16_t x271 = -1;
	int64_t x272 = INT64_MAX;
	int32_t t67 = -226;

    t67 = (x269^(x270>(x271>x272)));

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

void f68(void) {
    	volatile int8_t x273 = -1;
	int16_t x274 = -1;
	volatile uint16_t x275 = UINT16_MAX;
	int16_t x276 = -1;

    t68 = (x273^(x274>(x275>x276)));

    if (t68 != -1) { NG(); } else { ; }
	
}

void f69(void) {
    	int16_t x277 = INT16_MIN;
	int64_t x278 = 11045497857LL;
	static volatile int32_t t69 = 7130;

    t69 = (x277^(x278>(x279>x280)));

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

void f70(void) {
    	uint64_t x281 = 121624555193446LLU;
	uint16_t x282 = 14U;
	static uint16_t x283 = UINT16_MAX;
	uint8_t x284 = 6U;
	static uint64_t t70 = 161209700398943LLU;

    t70 = (x281^(x282>(x283>x284)));

    if (t70 != 121624555193447LLU) { NG(); } else { ; }
	
}

void f71(void) {
    	static int32_t x286 = INT32_MIN;
	int8_t x287 = -1;
	int16_t x288 = INT16_MIN;
	static int64_t t71 = 3707651851750LL;

    t71 = (x285^(x286>(x287>x288)));

    if (t71 != 11024213786LL) { NG(); } else { ; }
	
}

void f72(void) {
    	static volatile int8_t x289 = -5;
	volatile int16_t x291 = -1;
	int32_t x292 = INT32_MIN;
	int32_t t72 = -1507;

    t72 = (x289^(x290>(x291>x292)));

    if (t72 != -6) { NG(); } else { ; }
	
}

void f73(void) {
    	volatile int16_t x293 = INT16_MIN;
	static uint32_t x295 = 9806U;
	uint16_t x296 = 6U;
	volatile int32_t t73 = 151;

    t73 = (x293^(x294>(x295>x296)));

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

void f74(void) {
    	uint16_t x297 = 1U;
	static volatile int64_t x299 = INT64_MAX;
	int32_t t74 = -82171;

    t74 = (x297^(x298>(x299>x300)));

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

void f75(void) {
    	int16_t x301 = -1;
	static int16_t x302 = INT16_MIN;
	static int64_t x303 = -1LL;
	volatile int32_t t75 = -3345220;

    t75 = (x301^(x302>(x303>x304)));

    if (t75 != -1) { NG(); } else { ; }
	
}

void f76(void) {
    	uint16_t x305 = UINT16_MAX;
	static uint16_t x306 = UINT16_MAX;
	int32_t x307 = 8601;
	int16_t x308 = INT16_MIN;

    t76 = (x305^(x306>(x307>x308)));

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

void f77(void) {
    	int32_t x309 = 43781;
	volatile int64_t x310 = INT64_MIN;
	int64_t x311 = INT64_MIN;
	static int64_t x312 = -1LL;
	static int32_t t77 = 156;

    t77 = (x309^(x310>(x311>x312)));

    if (t77 != 43781) { NG(); } else { ; }
	
}

void f78(void) {
    	uint32_t x313 = 24750U;
	uint64_t x315 = 18800350070LLU;
	int64_t x316 = 117LL;
	volatile uint32_t t78 = 12760495U;

    t78 = (x313^(x314>(x315>x316)));

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

void f79(void) {
    	volatile uint32_t x317 = 444231109U;
	uint32_t x318 = 1866U;
	volatile int64_t x319 = INT64_MAX;
	int16_t x320 = INT16_MIN;

    t79 = (x317^(x318>(x319>x320)));

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

void f80(void) {
    	int64_t x321 = -1LL;
	static int8_t x324 = INT8_MIN;
	int64_t t80 = -32239208221883995LL;

    t80 = (x321^(x322>(x323>x324)));

    if (t80 != -1LL) { NG(); } else { ; }
	
}

void f81(void) {
    	int8_t x325 = INT8_MAX;
	int32_t x326 = INT32_MIN;
	static int16_t x327 = INT16_MAX;
	int32_t t81 = -6718339;

    t81 = (x325^(x326>(x327>x328)));

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

void f82(void) {
    	static volatile uint32_t x329 = 40342U;
	uint32_t x330 = 1U;
	uint64_t x331 = 64919516383320598LLU;
	uint64_t x332 = 22407LLU;
	uint32_t t82 = 1470589U;

    t82 = (x329^(x330>(x331>x332)));

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

void f83(void) {
    	volatile int32_t x333 = INT32_MIN;
	static int32_t x334 = 670;
	int8_t x335 = INT8_MIN;
	int64_t x336 = -454388303LL;
	int32_t t83 = -36647518;

    t83 = (x333^(x334>(x335>x336)));

    if (t83 != -2147483647) { NG(); } else { ; }
	
}

void f84(void) {
    	uint8_t x337 = UINT8_MAX;
	int8_t x338 = INT8_MAX;
	int8_t x339 = INT8_MIN;
	volatile uint64_t x340 = UINT64_MAX;
	volatile int32_t t84 = 727370595;

    t84 = (x337^(x338>(x339>x340)));

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

void f85(void) {
    	uint16_t x341 = UINT16_MAX;
	uint32_t x342 = 133U;
	int16_t x343 = INT16_MAX;
	static volatile uint32_t x344 = 87282803U;
	static int32_t t85 = -234739;

    t85 = (x341^(x342>(x343>x344)));

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

void f86(void) {
    	static int32_t x345 = -1;
	uint8_t x346 = 8U;
	uint8_t x348 = UINT8_MAX;
	int32_t t86 = -187635;

    t86 = (x345^(x346>(x347>x348)));

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

void f87(void) {
    	int8_t x349 = INT8_MIN;
	volatile int32_t x350 = -100;
	int32_t x352 = INT32_MIN;

    t87 = (x349^(x350>(x351>x352)));

    if (t87 != -128) { NG(); } else { ; }
	
}

void f88(void) {
    	volatile uint16_t x353 = 909U;
	volatile uint64_t x354 = UINT64_MAX;
	uint16_t x356 = 28U;
	int32_t t88 = 968686370;

    t88 = (x353^(x354>(x355>x356)));

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

void f89(void) {
    	uint32_t x359 = 228862100U;
	int16_t x360 = INT16_MAX;
	volatile int64_t t89 = -687487434898531806LL;

    t89 = (x357^(x358>(x359>x360)));

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

void f90(void) {
    	volatile int8_t x362 = -1;
	uint64_t x363 = 13780860542498LLU;
	volatile int64_t t90 = INT64_MIN;

    t90 = (x361^(x362>(x363>x364)));

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

void f91(void) {
    	uint8_t x365 = 42U;
	uint64_t x366 = UINT64_MAX;
	int32_t t91 = 212;

    t91 = (x365^(x366>(x367>x368)));

    if (t91 != 43) { NG(); } else { ; }
	
}

void f92(void) {
    	static uint8_t x370 = 76U;
	int32_t x371 = -1;
	volatile int8_t x372 = 4;
	int32_t t92 = -28;

    t92 = (x369^(x370>(x371>x372)));

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

void f93(void) {
    	uint8_t x373 = 14U;
	volatile uint16_t x374 = 11U;
	int8_t x375 = INT8_MIN;
	uint8_t x376 = 57U;
	int32_t t93 = 3825;

    t93 = (x373^(x374>(x375>x376)));

    if (t93 != 15) { NG(); } else { ; }
	
}

void f94(void) {
    	static uint32_t x378 = 80U;
	int8_t x379 = -1;
	int64_t x380 = 7483LL;
	static volatile int32_t t94 = 35420623;

    t94 = (x377^(x378>(x379>x380)));

    if (t94 != 117) { NG(); } else { ; }
	
}

void f95(void) {
    	static uint32_t x381 = UINT32_MAX;
	static int64_t x382 = INT64_MIN;
	volatile int8_t x383 = INT8_MIN;
	uint16_t x384 = UINT16_MAX;
	uint32_t t95 = UINT32_MAX;

    t95 = (x381^(x382>(x383>x384)));

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

void f96(void) {
    	static int32_t x385 = -1;
	uint16_t x386 = UINT16_MAX;
	volatile int32_t t96 = 14085199;

    t96 = (x385^(x386>(x387>x388)));

    if (t96 != -2) { NG(); } else { ; }
	
}

void f97(void) {
    	int8_t x390 = -1;
	int8_t x392 = INT8_MIN;
	int32_t t97 = -36434024;

    t97 = (x389^(x390>(x391>x392)));

    if (t97 != 2911) { NG(); } else { ; }
	
}

void f98(void) {
    	static int32_t x394 = INT32_MAX;
	int64_t x395 = 2152395549252931LL;
	volatile uint64_t x396 = 685999625426610LLU;
	uint32_t t98 = 1025583U;

    t98 = (x393^(x394>(x395>x396)));

    if (t98 != 202U) { NG(); } else { ; }
	
}

void f99(void) {
    	int16_t x397 = -1;
	volatile uint16_t x398 = UINT16_MAX;
	int64_t x399 = INT64_MAX;
	volatile int32_t t99 = -3389;

    t99 = (x397^(x398>(x399>x400)));

    if (t99 != -2) { NG(); } else { ; }
	
}

void f100(void) {
    	static int32_t x402 = INT32_MIN;
	int8_t x403 = -4;
	int64_t x404 = -1LL;

    t100 = (x401^(x402>(x403>x404)));

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

void f101(void) {
    	uint8_t x406 = 118U;
	static uint64_t x408 = UINT64_MAX;
	int32_t t101 = 491;

    t101 = (x405^(x406>(x407>x408)));

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

void f102(void) {
    	uint16_t x410 = 247U;
	int8_t x411 = -38;
	int64_t x412 = INT64_MIN;
	volatile int32_t t102 = -249323;

    t102 = (x409^(x410>(x411>x412)));

    if (t102 != -2) { NG(); } else { ; }
	
}

void f103(void) {
    	int32_t x413 = 63;
	int32_t x414 = INT32_MAX;
	static uint32_t x415 = 8353U;
	volatile int32_t x416 = INT32_MAX;
	int32_t t103 = -185105752;

    t103 = (x413^(x414>(x415>x416)));

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

void f104(void) {
    	int64_t x417 = -1LL;
	int8_t x418 = 29;
	int64_t t104 = 357LL;

    t104 = (x417^(x418>(x419>x420)));

    if (t104 != -2LL) { NG(); } else { ; }
	
}

void f105(void) {
    	volatile int32_t x421 = INT32_MAX;
	int64_t x422 = -96679LL;
	volatile int16_t x423 = -136;
	int32_t t105 = INT32_MAX;

    t105 = (x421^(x422>(x423>x424)));

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

void f106(void) {
    	uint16_t x425 = UINT16_MAX;
	int16_t x426 = 1;
	int16_t x428 = -5;
	volatile int32_t t106 = -21723800;

    t106 = (x425^(x426>(x427>x428)));

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

void f107(void) {
    	int8_t x430 = -1;
	int16_t x431 = INT16_MIN;
	volatile int8_t x432 = 15;
	volatile int32_t t107 = -751521;

    t107 = (x429^(x430>(x431>x432)));

    if (t107 != 65535) { NG(); } else { ; }
	
}

void f108(void) {
    	int16_t x434 = -2205;
	uint8_t x435 = 44U;
	volatile uint64_t t108 = 13924215103LLU;

    t108 = (x433^(x434>(x435>x436)));

    if (t108 != 51382LLU) { NG(); } else { ; }
	
}

void f109(void) {
    	uint16_t x437 = 31428U;
	uint32_t x438 = 5594U;
	volatile int64_t x440 = INT64_MIN;
	volatile int32_t t109 = 17241011;

    t109 = (x437^(x438>(x439>x440)));

    if (t109 != 31429) { NG(); } else { ; }
	
}

void f110(void) {
    	int8_t x441 = INT8_MAX;
	int32_t x442 = -2433;

    t110 = (x441^(x442>(x443>x444)));

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

void f111(void) {
    	volatile int16_t x446 = INT16_MAX;
	uint64_t x447 = UINT64_MAX;
	uint64_t x448 = 9532LLU;
	static uint32_t t111 = 493U;

    t111 = (x445^(x446>(x447>x448)));

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

void f112(void) {
    	static int64_t x449 = 4654838038606157LL;
	int8_t x450 = INT8_MIN;
	volatile int32_t x451 = INT32_MIN;
	uint32_t x452 = 1010059463U;
	int64_t t112 = -342LL;

    t112 = (x449^(x450>(x451>x452)));

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

void f113(void) {
    	int32_t x455 = -1;
	int32_t x456 = INT32_MIN;
	int64_t t113 = -327376265480670061LL;

    t113 = (x453^(x454>(x455>x456)));

    if (t113 != -1LL) { NG(); } else { ; }
	
}

void f114(void) {
    	uint64_t x457 = 686946LLU;
	int8_t x458 = -7;
	int64_t x459 = -1LL;
	int8_t x460 = INT8_MIN;
	volatile uint64_t t114 = 937641LLU;

    t114 = (x457^(x458>(x459>x460)));

    if (t114 != 686946LLU) { NG(); } else { ; }
	
}

void f115(void) {
    	int16_t x461 = -1;
	static int8_t x462 = -1;
	int16_t x463 = INT16_MIN;
	volatile uint64_t x464 = 14408222LLU;
	int32_t t115 = 557;

    t115 = (x461^(x462>(x463>x464)));

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

void f116(void) {
    	static int8_t x467 = INT8_MIN;
	uint64_t x468 = UINT64_MAX;

    t116 = (x465^(x466>(x467>x468)));

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

void f117(void) {
    	volatile int16_t x469 = -1;
	int32_t x470 = -25841432;
	int16_t x472 = INT16_MIN;
	static volatile int32_t t117 = -3;

    t117 = (x469^(x470>(x471>x472)));

    if (t117 != -1) { NG(); } else { ; }
	
}

void f118(void) {
    	volatile uint16_t x473 = 537U;
	uint32_t x476 = 5U;
	int32_t t118 = 108044169;

    t118 = (x473^(x474>(x475>x476)));

    if (t118 != 537) { NG(); } else { ; }
	
}

void f119(void) {
    	int16_t x477 = -1;
	static volatile int16_t x479 = -1;
	volatile int32_t t119 = 80776;

    t119 = (x477^(x478>(x479>x480)));

    if (t119 != -1) { NG(); } else { ; }
	
}

void f120(void) {
    	uint64_t x481 = 920265066273775056LLU;
	static uint16_t x482 = 4067U;
	static uint64_t t120 = 4800LLU;

    t120 = (x481^(x482>(x483>x484)));

    if (t120 != 920265066273775057LLU) { NG(); } else { ; }
	
}

void f121(void) {
    	static volatile int64_t x485 = -1LL;
	int64_t x486 = INT64_MIN;
	uint64_t x487 = 3914629813265LLU;
	int64_t x488 = -1LL;
	int64_t t121 = -1118235162901127LL;

    t121 = (x485^(x486>(x487>x488)));

    if (t121 != -1LL) { NG(); } else { ; }
	
}

void f122(void) {
    	int32_t x489 = -1;
	uint32_t x491 = 99501U;
	static int64_t x492 = 14146LL;
	int32_t t122 = -58048;

    t122 = (x489^(x490>(x491>x492)));

    if (t122 != -1) { NG(); } else { ; }
	
}

void f123(void) {
    	int8_t x495 = -1;
	volatile int32_t x496 = 0;

    t123 = (x493^(x494>(x495>x496)));

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

void f124(void) {
    	int16_t x497 = INT16_MIN;
	int64_t x498 = INT64_MIN;
	volatile uint64_t x500 = UINT64_MAX;
	int32_t t124 = 1025216;

    t124 = (x497^(x498>(x499>x500)));

    if (t124 != -32768) { NG(); } else { ; }
	
}

void f125(void) {
    	int16_t x501 = -1;
	uint16_t x502 = 32005U;
	static uint8_t x503 = UINT8_MAX;
	uint16_t x504 = 15U;
	int32_t t125 = 143352667;

    t125 = (x501^(x502>(x503>x504)));

    if (t125 != -2) { NG(); } else { ; }
	
}

void f126(void) {
    	int8_t x506 = 0;
	uint8_t x507 = 0U;
	int16_t x508 = -6135;
	volatile int32_t t126 = -6994;

    t126 = (x505^(x506>(x507>x508)));

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

void f127(void) {
    	uint64_t x509 = 5878673648166290LLU;
	uint64_t x510 = UINT64_MAX;
	static int16_t x511 = 562;
	uint16_t x512 = UINT16_MAX;
	volatile uint64_t t127 = 2028650LLU;

    t127 = (x509^(x510>(x511>x512)));

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

void f128(void) {
    	volatile uint8_t x513 = 7U;
	uint64_t x514 = 260666LLU;
	volatile int32_t t128 = -105;

    t128 = (x513^(x514>(x515>x516)));

    if (t128 != 6) { NG(); } else { ; }
	
}

void f129(void) {
    	int8_t x517 = INT8_MIN;
	uint64_t x518 = 9108738059658935057LLU;
	static uint32_t x520 = 5U;
	static volatile int32_t t129 = 1038520604;

    t129 = (x517^(x518>(x519>x520)));

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

void f130(void) {
    	int16_t x521 = 1;
	int8_t x522 = INT8_MIN;
	static uint16_t x523 = 50U;
	int32_t x524 = -1912;

    t130 = (x521^(x522>(x523>x524)));

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

void f131(void) {
    	static int16_t x525 = -1;
	static uint64_t x527 = UINT64_MAX;
	int32_t x528 = 67533901;
	volatile int32_t t131 = 0;

    t131 = (x525^(x526>(x527>x528)));

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

void f132(void) {
    	uint32_t x529 = 602692919U;
	static int64_t x530 = 911444908039988618LL;
	int32_t x531 = INT32_MAX;
	int32_t x532 = -1;
	volatile uint32_t t132 = 1U;

    t132 = (x529^(x530>(x531>x532)));

    if (t132 != 602692918U) { NG(); } else { ; }
	
}

void f133(void) {
    	int64_t x533 = -1LL;
	uint8_t x534 = 9U;
	int32_t x535 = -1;
	int64_t x536 = INT64_MAX;
	volatile int64_t t133 = -418LL;

    t133 = (x533^(x534>(x535>x536)));

    if (t133 != -2LL) { NG(); } else { ; }
	
}

void f134(void) {
    	uint64_t x537 = 8444754087013959249LLU;
	int32_t x538 = INT32_MAX;
	int32_t x539 = 5444;
	uint16_t x540 = 7841U;
	volatile uint64_t t134 = 5596016449168264271LLU;

    t134 = (x537^(x538>(x539>x540)));

    if (t134 != 8444754087013959248LLU) { NG(); } else { ; }
	
}

void f135(void) {
    	volatile uint16_t x541 = 13U;
	static int16_t x542 = INT16_MAX;
	int32_t x543 = -8613206;
	int32_t x544 = INT32_MIN;
	volatile int32_t t135 = -6520;

    t135 = (x541^(x542>(x543>x544)));

    if (t135 != 12) { NG(); } else { ; }
	
}

void f136(void) {
    	int8_t x545 = -1;
	int64_t x546 = -1LL;
	uint16_t x547 = UINT16_MAX;
	uint64_t x548 = UINT64_MAX;
	volatile int32_t t136 = -31;

    t136 = (x545^(x546>(x547>x548)));

    if (t136 != -1) { NG(); } else { ; }
	
}

void f137(void) {
    	static volatile int8_t x550 = 8;
	int16_t x551 = INT16_MIN;
	volatile int64_t x552 = INT64_MIN;
	volatile int32_t t137 = 57743178;

    t137 = (x549^(x550>(x551>x552)));

    if (t137 != -2147483647) { NG(); } else { ; }
	
}

void f138(void) {
    	static volatile int16_t x553 = INT16_MAX;
	volatile int32_t x554 = -1;
	int32_t x555 = INT32_MIN;
	uint16_t x556 = 33U;
	int32_t t138 = 22700;

    t138 = (x553^(x554>(x555>x556)));

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

void f139(void) {
    	static int16_t x557 = INT16_MIN;
	int64_t x558 = INT64_MAX;
	int8_t x559 = -7;
	int16_t x560 = -858;
	int32_t t139 = -7;

    t139 = (x557^(x558>(x559>x560)));

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

void f140(void) {
    	uint32_t x561 = UINT32_MAX;
	static uint8_t x562 = UINT8_MAX;
	uint16_t x563 = UINT16_MAX;
	uint32_t x564 = 14476209U;
	uint32_t t140 = 362652172U;

    t140 = (x561^(x562>(x563>x564)));

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

void f141(void) {
    	int16_t x565 = INT16_MAX;
	volatile int8_t x568 = INT8_MAX;
	int32_t t141 = 9007;

    t141 = (x565^(x566>(x567>x568)));

    if (t141 != 32766) { NG(); } else { ; }
	
}

void f142(void) {
    	volatile uint32_t x569 = UINT32_MAX;
	static int32_t x570 = INT32_MAX;
	static int64_t x571 = INT64_MAX;
	static int16_t x572 = -5;
	uint32_t t142 = 4U;

    t142 = (x569^(x570>(x571>x572)));

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

void f143(void) {
    	static volatile int8_t x573 = INT8_MIN;
	int64_t x575 = -1LL;
	static volatile int32_t x576 = 823417290;
	int32_t t143 = 625056803;

    t143 = (x573^(x574>(x575>x576)));

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

void f144(void) {
    	volatile int64_t x577 = -1LL;
	int8_t x578 = 10;
	uint16_t x580 = 17U;
	volatile int64_t t144 = -1167528495LL;

    t144 = (x577^(x578>(x579>x580)));

    if (t144 != -2LL) { NG(); } else { ; }
	
}

void f145(void) {
    	int32_t x581 = INT32_MAX;
	volatile int16_t x582 = INT16_MAX;
	int32_t x583 = 177424;
	int8_t x584 = INT8_MAX;
	volatile int32_t t145 = -151783;

    t145 = (x581^(x582>(x583>x584)));

    if (t145 != 2147483646) { NG(); } else { ; }
	
}

void f146(void) {
    	static int8_t x585 = INT8_MIN;
	uint16_t x587 = UINT16_MAX;
	volatile int8_t x588 = INT8_MIN;

    t146 = (x585^(x586>(x587>x588)));

    if (t146 != -128) { NG(); } else { ; }
	
}

void f147(void) {
    	int32_t x590 = -23611163;
	uint32_t x591 = 726U;
	int64_t x592 = INT64_MAX;
	static volatile uint64_t t147 = UINT64_MAX;

    t147 = (x589^(x590>(x591>x592)));

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

void f148(void) {
    	int32_t x593 = -1;
	uint64_t x594 = UINT64_MAX;
	volatile int16_t x596 = 0;
	static volatile int32_t t148 = 0;

    t148 = (x593^(x594>(x595>x596)));

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

void f149(void) {
    	int16_t x597 = INT16_MAX;
	volatile int32_t x599 = 717431;
	static volatile uint16_t x600 = 100U;
	volatile int32_t t149 = -1573888;

    t149 = (x597^(x598>(x599>x600)));

    if (t149 != 32766) { NG(); } else { ; }
	
}

void f150(void) {
    	static int16_t x601 = INT16_MIN;
	static uint8_t x602 = 49U;
	volatile int64_t x603 = INT64_MAX;
	int32_t x604 = INT32_MIN;
	int32_t t150 = -30069;

    t150 = (x601^(x602>(x603>x604)));

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

void f151(void) {
    	static int32_t x605 = INT32_MIN;
	uint32_t x606 = 51644174U;
	volatile int32_t x607 = INT32_MAX;
	static volatile int32_t x608 = INT32_MIN;

    t151 = (x605^(x606>(x607>x608)));

    if (t151 != -2147483647) { NG(); } else { ; }
	
}

void f152(void) {
    	int32_t x609 = -1;
	volatile int32_t x610 = 0;
	int8_t x611 = -1;
	int64_t x612 = 1641648399980LL;

    t152 = (x609^(x610>(x611>x612)));

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

void f153(void) {
    	int8_t x613 = -30;
	int8_t x614 = INT8_MIN;
	int16_t x616 = -1;
	int32_t t153 = -1419659;

    t153 = (x613^(x614>(x615>x616)));

    if (t153 != -30) { NG(); } else { ; }
	
}

void f154(void) {
    	int64_t x618 = INT64_MIN;
	static int16_t x619 = 0;
	int16_t x620 = 23;
	int32_t t154 = 0;

    t154 = (x617^(x618>(x619>x620)));

    if (t154 != 43) { NG(); } else { ; }
	
}

void f155(void) {
    	int64_t x621 = -1LL;
	uint32_t x622 = 4U;
	int8_t x623 = INT8_MAX;
	int16_t x624 = 987;
	volatile int64_t t155 = 2098LL;

    t155 = (x621^(x622>(x623>x624)));

    if (t155 != -2LL) { NG(); } else { ; }
	
}

void f156(void) {
    	uint64_t x625 = UINT64_MAX;
	static int16_t x626 = -16014;
	volatile int8_t x627 = -3;
	int32_t x628 = -1;
	uint64_t t156 = UINT64_MAX;

    t156 = (x625^(x626>(x627>x628)));

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

void f157(void) {
    	uint16_t x629 = 71U;
	int32_t x630 = INT32_MIN;
	static volatile int64_t x631 = INT64_MIN;
	uint64_t x632 = 46LLU;

    t157 = (x629^(x630>(x631>x632)));

    if (t157 != 71) { NG(); } else { ; }
	
}

void f158(void) {
    	int32_t x633 = -1;
	uint64_t x636 = 4330616982446LLU;
	static volatile int32_t t158 = 238826932;

    t158 = (x633^(x634>(x635>x636)));

    if (t158 != -2) { NG(); } else { ; }
	
}

void f159(void) {
    	volatile int16_t x637 = INT16_MIN;
	int32_t x638 = INT32_MIN;
	static volatile uint64_t x640 = 1561LLU;
	int32_t t159 = 14633;

    t159 = (x637^(x638>(x639>x640)));

    if (t159 != -32768) { NG(); } else { ; }
	
}

void f160(void) {
    	volatile int64_t x642 = INT64_MIN;
	int64_t x643 = -1LL;
	uint64_t t160 = 13631471355LLU;

    t160 = (x641^(x642>(x643>x644)));

    if (t160 != 997617LLU) { NG(); } else { ; }
	
}

void f161(void) {
    	volatile uint32_t x645 = 3U;
	int64_t x646 = 6675LL;
	int64_t x647 = INT64_MAX;
	volatile int16_t x648 = INT16_MAX;
	uint32_t t161 = 189U;

    t161 = (x645^(x646>(x647>x648)));

    if (t161 != 2U) { NG(); } else { ; }
	
}

void f162(void) {
    	static uint32_t x649 = 167269U;
	uint8_t x650 = UINT8_MAX;
	int16_t x651 = 2;
	static volatile uint32_t t162 = 200U;

    t162 = (x649^(x650>(x651>x652)));

    if (t162 != 167268U) { NG(); } else { ; }
	
}

void f163(void) {
    	static int32_t x654 = -1;
	int32_t x656 = INT32_MAX;
	static volatile uint32_t t163 = 205119U;

    t163 = (x653^(x654>(x655>x656)));

    if (t163 != 42154001U) { NG(); } else { ; }
	
}

void f164(void) {
    	int16_t x657 = INT16_MAX;
	static uint64_t x658 = UINT64_MAX;
	volatile uint32_t x659 = 376465993U;
	int16_t x660 = INT16_MAX;
	int32_t t164 = 84820;

    t164 = (x657^(x658>(x659>x660)));

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

void f165(void) {
    	uint16_t x661 = 0U;
	uint64_t x662 = 52951866271LLU;
	int8_t x663 = INT8_MIN;
	uint16_t x664 = UINT16_MAX;
	static int32_t t165 = 84882603;

    t165 = (x661^(x662>(x663>x664)));

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

void f166(void) {
    	int16_t x665 = 6122;
	uint16_t x667 = 24243U;

    t166 = (x665^(x666>(x667>x668)));

    if (t166 != 6122) { NG(); } else { ; }
	
}

void f167(void) {
    	volatile int16_t x669 = INT16_MAX;
	volatile int8_t x670 = 0;
	int64_t x671 = -60139701353352LL;
	volatile int16_t x672 = -5;
	int32_t t167 = -173709;

    t167 = (x669^(x670>(x671>x672)));

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

void f168(void) {
    	int64_t x674 = INT64_MIN;
	int64_t x675 = INT64_MIN;
	volatile uint16_t x676 = UINT16_MAX;

    t168 = (x673^(x674>(x675>x676)));

    if (t168 != -32768) { NG(); } else { ; }
	
}

void f169(void) {
    	int8_t x678 = INT8_MIN;
	int16_t x679 = 108;
	int8_t x680 = -5;
	volatile int32_t t169 = 593362016;

    t169 = (x677^(x678>(x679>x680)));

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

void f170(void) {
    	int8_t x681 = -1;
	uint16_t x682 = 445U;
	static int32_t x683 = INT32_MIN;
	static int64_t x684 = -1LL;
	volatile int32_t t170 = -13120;

    t170 = (x681^(x682>(x683>x684)));

    if (t170 != -2) { NG(); } else { ; }
	
}

void f171(void) {
    	int16_t x686 = INT16_MAX;
	uint8_t x687 = 1U;
	static uint64_t x688 = 1183LLU;
	int64_t t171 = 6693549812943LL;

    t171 = (x685^(x686>(x687>x688)));

    if (t171 != -9223372036854775807LL) { NG(); } else { ; }
	
}

void f172(void) {
    	int32_t x689 = 63906;
	uint16_t x690 = 1088U;
	int16_t x691 = 0;
	int16_t x692 = INT16_MIN;
	static volatile int32_t t172 = -1;

    t172 = (x689^(x690>(x691>x692)));

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

void f173(void) {
    	static int8_t x693 = INT8_MIN;
	int64_t x694 = INT64_MIN;
	uint8_t x695 = UINT8_MAX;
	int16_t x696 = 15;
	int32_t t173 = 211;

    t173 = (x693^(x694>(x695>x696)));

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

void f174(void) {
    	int64_t x697 = INT64_MAX;
	static int16_t x698 = INT16_MIN;
	uint16_t x699 = UINT16_MAX;
	volatile uint8_t x700 = 23U;
	volatile int64_t t174 = INT64_MAX;

    t174 = (x697^(x698>(x699>x700)));

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

void f175(void) {
    	int32_t x701 = -1445;
	volatile uint32_t x702 = 3759621U;
	volatile uint16_t x703 = 142U;
	uint8_t x704 = UINT8_MAX;
	int32_t t175 = 307452535;

    t175 = (x701^(x702>(x703>x704)));

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

void f176(void) {
    	int16_t x705 = -10;
	static int32_t x706 = -1;
	uint16_t x707 = UINT16_MAX;
	volatile int8_t x708 = -1;
	volatile int32_t t176 = -3993091;

    t176 = (x705^(x706>(x707>x708)));

    if (t176 != -10) { NG(); } else { ; }
	
}

void f177(void) {
    	static int16_t x711 = 51;
	int8_t x712 = -1;
	volatile uint32_t t177 = UINT32_MAX;

    t177 = (x709^(x710>(x711>x712)));

    if (t177 != UINT32_MAX) { NG(); } else { ; }
	
}

void f178(void) {
    	int8_t x713 = -53;
	uint8_t x714 = UINT8_MAX;
	static uint32_t x715 = 0U;
	volatile uint16_t x716 = UINT16_MAX;
	int32_t t178 = -23;

    t178 = (x713^(x714>(x715>x716)));

    if (t178 != -54) { NG(); } else { ; }
	
}

void f179(void) {
    	int8_t x717 = 3;
	volatile int32_t x718 = INT32_MIN;
	uint16_t x719 = UINT16_MAX;
	static volatile int32_t t179 = -8551114;

    t179 = (x717^(x718>(x719>x720)));

    if (t179 != 3) { NG(); } else { ; }
	
}

void f180(void) {
    	int8_t x721 = INT8_MAX;
	volatile int8_t x722 = INT8_MIN;
	uint16_t x724 = UINT16_MAX;
	int32_t t180 = 203;

    t180 = (x721^(x722>(x723>x724)));

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

void f181(void) {
    	static int64_t x725 = INT64_MAX;
	int16_t x727 = INT16_MIN;
	static int64_t x728 = INT64_MIN;
	int64_t t181 = 72473003821941019LL;

    t181 = (x725^(x726>(x727>x728)));

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

void f182(void) {
    	volatile int32_t x729 = INT32_MAX;
	uint32_t x730 = UINT32_MAX;
	int8_t x731 = INT8_MAX;
	int32_t t182 = -24728897;

    t182 = (x729^(x730>(x731>x732)));

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

void f183(void) {
    	volatile int8_t x733 = 0;
	uint16_t x734 = 1U;
	int32_t x735 = INT32_MIN;
	volatile uint8_t x736 = 51U;
	int32_t t183 = 669153166;

    t183 = (x733^(x734>(x735>x736)));

    if (t183 != 1) { NG(); } else { ; }
	
}

void f184(void) {
    	int64_t x737 = -1511LL;
	volatile int16_t x738 = 38;
	volatile int16_t x739 = -1;
	int64_t t184 = -13752099383336LL;

    t184 = (x737^(x738>(x739>x740)));

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

void f185(void) {
    	uint64_t x741 = 56832LLU;
	int8_t x742 = INT8_MIN;
	uint8_t x743 = 127U;
	int32_t x744 = INT32_MIN;

    t185 = (x741^(x742>(x743>x744)));

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

void f186(void) {
    	volatile int32_t x745 = INT32_MIN;
	static uint8_t x746 = 0U;
	static int8_t x747 = 3;
	uint64_t x748 = 10329LLU;
	int32_t t186 = INT32_MIN;

    t186 = (x745^(x746>(x747>x748)));

    if (t186 != INT32_MIN) { NG(); } else { ; }
	
}

void f187(void) {
    	volatile int32_t x749 = INT32_MIN;
	int32_t x751 = -1;
	uint64_t x752 = 97LLU;

    t187 = (x749^(x750>(x751>x752)));

    if (t187 != -2147483647) { NG(); } else { ; }
	
}

void f188(void) {
    	uint64_t x753 = 28736425442047116LLU;
	int16_t x754 = 13;
	uint8_t x755 = UINT8_MAX;
	static volatile uint16_t x756 = 279U;
	uint64_t t188 = 1054804845LLU;

    t188 = (x753^(x754>(x755>x756)));

    if (t188 != 28736425442047117LLU) { NG(); } else { ; }
	
}

void f189(void) {
    	volatile uint8_t x757 = 50U;
	int64_t x759 = 6291LL;
	int32_t x760 = INT32_MIN;
	static int32_t t189 = 6503;

    t189 = (x757^(x758>(x759>x760)));

    if (t189 != 51) { NG(); } else { ; }
	
}

void f190(void) {
    	uint8_t x761 = 10U;
	volatile uint16_t x763 = UINT16_MAX;
	volatile int32_t t190 = 3139;

    t190 = (x761^(x762>(x763>x764)));

    if (t190 != 10) { NG(); } else { ; }
	
}

void f191(void) {
    	uint8_t x765 = UINT8_MAX;
	volatile int64_t x766 = -1LL;
	static volatile int32_t x767 = INT32_MIN;
	uint32_t x768 = 455911U;
	static int32_t t191 = -500;

    t191 = (x765^(x766>(x767>x768)));

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

void f192(void) {
    	int64_t x769 = INT64_MIN;
	volatile uint32_t x770 = UINT32_MAX;
	static int16_t x771 = -1;
	uint32_t x772 = 221U;
	volatile int64_t t192 = 34919648110644852LL;

    t192 = (x769^(x770>(x771>x772)));

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

void f193(void) {
    	static uint32_t x773 = UINT32_MAX;
	static int16_t x774 = 81;
	static uint8_t x776 = 3U;

    t193 = (x773^(x774>(x775>x776)));

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

void f194(void) {
    	int8_t x777 = -1;
	int32_t x779 = 19920390;
	int8_t x780 = 9;
	int32_t t194 = -2;

    t194 = (x777^(x778>(x779>x780)));

    if (t194 != -2) { NG(); } else { ; }
	
}

void f195(void) {
    	int64_t x781 = INT64_MIN;
	int64_t x782 = INT64_MIN;
	int16_t x784 = 1229;
	volatile int64_t t195 = INT64_MIN;

    t195 = (x781^(x782>(x783>x784)));

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

void f196(void) {
    	int8_t x786 = 1;
	uint8_t x787 = 54U;
	int16_t x788 = INT16_MAX;
	volatile uint64_t t196 = 1346500255984LLU;

    t196 = (x785^(x786>(x787>x788)));

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

void f197(void) {
    	int16_t x789 = INT16_MIN;
	volatile uint16_t x790 = UINT16_MAX;
	int32_t x791 = -1;
	volatile int32_t t197 = -24156;

    t197 = (x789^(x790>(x791>x792)));

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

void f198(void) {
    	static int64_t x794 = INT64_MIN;
	uint8_t x796 = UINT8_MAX;

    t198 = (x793^(x794>(x795>x796)));

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

void f199(void) {
    	volatile int16_t x797 = INT16_MIN;
	int8_t x798 = -1;
	int8_t x799 = -1;
	static volatile int32_t t199 = 7;

    t199 = (x797^(x798>(x799>x800)));

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

