text: 
  /*
  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"
  
  uint8_t x4 = 1U;
  int64_t x43 = INT64_MIN;
  uint8_t x44 = UINT8_MAX;
  uint32_t t3 = 3U;
  static uint32_t x45 = 2U;
  int16_t x46 = INT16_MIN;
  uint64_t x54 = 93194682685486587LLU;
  int32_t x68 = 595071678;
  uint8_t x132 = UINT8_MAX;
  int64_t x140 = -1LL;
  int8_t x165 = INT8_MIN;
  static int32_t t12 = 2686471;
  int64_t x169 = -1115455045672LL;
  int64_t x172 = INT64_MAX;
  int16_t x178 = -1;
  uint32_t x179 = 515275U;
  int16_t x185 = INT16_MAX;
  static int16_t x187 = -25;
  static int64_t x192 = INT64_MAX;
  volatile int32_t x213 = 139728;
  static uint64_t x217 = 156LLU;
  static volatile int16_t x226 = 3254;
  uint32_t x235 = 4213U;
  int32_t x236 = -1;
  static uint64_t x239 = 8675650308020LLU;
  int8_t x240 = -1;
  static int32_t t24 = -409;
  static uint64_t x251 = UINT64_MAX;
  int64_t x252 = -1LL;
  uint32_t t25 = 241U;
  uint32_t x258 = 16587330U;
  int32_t x259 = INT32_MIN;
  volatile int8_t x266 = INT8_MIN;
  int16_t x267 = INT16_MAX;
  int64_t x277 = -813665LL;
  int32_t x278 = INT32_MIN;
  volatile int32_t x292 = INT32_MIN;
  uint16_t x333 = UINT16_MAX;
  uint64_t x372 = 3147055502418LLU;
  volatile uint64_t t38 = 61210LLU;
  volatile uint32_t x407 = 283509U;
  static volatile int32_t t39 = 0;
  int32_t t40 = -62;
  int32_t x428 = INT32_MAX;
  static uint8_t x437 = 19U;
  static uint8_t x452 = 1U;
  volatile uint16_t x454 = UINT16_MAX;
  uint32_t x477 = 46281775U;
  uint64_t x478 = 31853LLU;
  int16_t x552 = -1;
  int64_t x554 = 2346681711770LL;
  uint64_t x555 = 6659312279249LLU;
  volatile int16_t x556 = -1;
  int8_t x557 = INT8_MIN;
  int8_t x559 = -1;
  int16_t x593 = 16091;
  int32_t t57 = -591;
  uint16_t x625 = 20697U;
  volatile uint64_t x640 = UINT64_MAX;
  static volatile int16_t x642 = -1664;
  int16_t x670 = INT16_MIN;
  int16_t x674 = INT16_MAX;
  static volatile uint32_t t67 = 15704U;
  uint8_t x689 = 8U;
  int8_t x691 = INT8_MAX;
  int16_t x696 = INT16_MIN;
  uint64_t x708 = 4115657LLU;
  static uint8_t x721 = 25U;
  int8_t x724 = INT8_MAX;
  uint64_t x753 = 1695419538287LLU;
  static uint64_t t73 = 252292954210172LLU;
  int64_t x760 = -1LL;
  volatile int64_t t75 = -1423338LL;
  volatile int8_t x765 = INT8_MAX;
  static volatile int16_t x768 = -1;
  int32_t x775 = INT32_MIN;
  uint32_t x779 = 117366751U;
  volatile uint32_t t78 = 56U;
  int64_t x792 = INT64_MIN;
  uint32_t x793 = 47822374U;
  int64_t x794 = -2LL;
  int8_t x803 = -1;
  int8_t x831 = -1;
  int32_t x834 = -1;
  int32_t x836 = 14636739;
  int16_t x838 = -2559;
  uint64_t x866 = 525397LLU;
  int32_t t89 = -431415972;
  int64_t x938 = 496538940598328LL;
  int8_t x960 = INT8_MAX;
  int16_t x981 = INT16_MIN;
  int8_t x988 = INT8_MAX;
  static int8_t x1020 = INT8_MAX;
  int8_t x1032 = -1;
  uint32_t t103 = 4477858U;
  int16_t x1054 = INT16_MIN;
  uint16_t x1057 = UINT16_MAX;
  int16_t x1103 = INT16_MIN;
  int64_t x1129 = 18181LL;
  static int16_t x1132 = -3;
  static uint16_t x1142 = UINT16_MAX;
  int32_t x1157 = 58724;
  int64_t x1158 = -131940327399503LL;
  uint64_t x1160 = 326LLU;
  static int64_t x1182 = -1LL;
  int32_t x1195 = INT32_MIN;
  volatile int32_t t114 = -386;
  int8_t x1213 = INT8_MAX;
  int32_t x1215 = INT32_MIN;
  uint64_t x1254 = 13591156393040LLU;
  volatile uint64_t t118 = 1838153493LLU;
  volatile uint32_t x1265 = 8955090U;
  volatile int16_t x1266 = -510;
  uint32_t x1288 = UINT32_MAX;
  volatile int32_t t122 = -11480;
  int64_t x1295 = INT64_MIN;
  volatile uint32_t t123 = 20604597U;
  int16_t x1315 = INT16_MIN;
  int32_t t126 = -201;
  int16_t x1325 = -1;
  int32_t t127 = 11653;
  static uint32_t x1339 = 3U;
  int32_t x1346 = 6527702;
  static int64_t x1347 = INT64_MIN;
  uint16_t x1380 = UINT16_MAX;
  volatile int32_t t131 = 395;
  static uint32_t x1406 = UINT32_MAX;
  static int64_t x1407 = -1LL;
  int16_t x1412 = INT16_MAX;
  volatile int32_t t133 = 1472826;
  int64_t x1451 = INT64_MIN;
  volatile int64_t x1455 = INT64_MIN;
  volatile int32_t t137 = -64876167;
  int16_t x1503 = INT16_MIN;
  static int32_t t142 = 156;
  uint32_t x1511 = 6U;
  static int32_t x1512 = INT32_MAX;
  uint8_t x1535 = UINT8_MAX;
  volatile int64_t x1536 = 9883886LL;
  uint16_t x1542 = UINT16_MAX;
  static int16_t x1549 = -299;
  static int8_t x1551 = INT8_MIN;
  int16_t x1553 = 7166;
  volatile int32_t t148 = -51972;
  int16_t x1596 = INT16_MAX;
  int32_t x1621 = -1;
  static int16_t x1624 = -56;
  int32_t t152 = 137;
  uint8_t x1634 = UINT8_MAX;
  static uint64_t x1658 = 21LLU;
  volatile int8_t x1691 = INT8_MIN;
  int8_t x1692 = INT8_MIN;
  static int64_t x1702 = -1LL;
  uint32_t x1703 = 453932U;
  int16_t x1718 = 1;
  volatile int32_t t157 = -501;
  static volatile int64_t x1746 = -96737599LL;
  static int64_t t159 = 62792068750LL;
  volatile int8_t x1752 = 27;
  int32_t x1758 = -1;
  volatile int32_t t161 = -3;
  volatile uint32_t x1766 = 4157U;
  uint16_t x1785 = 191U;
  int32_t t165 = 4;
  int16_t x1797 = -962;
  uint64_t x1800 = UINT64_MAX;
  volatile int64_t t168 = 72410LL;
  static uint16_t x1813 = 56U;
  int32_t t170 = -18;
  static uint16_t x1829 = UINT16_MAX;
  volatile int16_t x1832 = 2699;
  int16_t x1835 = INT16_MAX;
  volatile uint32_t x1836 = 183993U;
  static volatile uint32_t t174 = 153869U;
  int16_t x1849 = 9390;
  int64_t x1858 = -1LL;
  uint64_t x1860 = 3336778319544451514LLU;
  int32_t x1868 = 1647;
  int64_t x1878 = -1LL;
  volatile int64_t x1898 = -1LL;
  volatile int64_t t181 = -61747100686LL;
  volatile int16_t x1912 = INT16_MAX;
  volatile int64_t t183 = -1088384002975494LL;
  uint32_t t184 = 1U;
  volatile uint64_t t185 = 1769388472LLU;
  uint32_t x2036 = UINT32_MAX;
  static int64_t x2054 = INT64_MIN;
  uint16_t x2076 = 65U;
  int64_t x2085 = -1LL;
  uint64_t x2103 = 76LLU;
  static volatile int64_t t195 = -196987412720641312LL;
  uint64_t x2158 = 141792889LLU;
  
  
  void f0(void) {
      	volatile int8_t x1 = 0;
  	static uint16_t x2 = UINT16_MAX;
  	int32_t x3 = -1;
  	volatile int32_t t0 = -2232133;
  
      t0 = ((x1*x2)%(x3<=x4));
  
      if (t0 != 0) { NG(); } else { ; }
  	
  }
  
  void f1(void) {
      	int16_t x17 = -1;
  	int64_t x18 = INT64_MAX;
  	static volatile int64_t x19 = INT64_MIN;
  	static uint32_t x20 = 8U;
  	static int64_t t1 = -1339592346659602781LL;
  
      t1 = ((x17*x18)%(x19<=x20));
  
      if (t1 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f2(void) {
      	int8_t x29 = -5;
  	int64_t x30 = -685884709735LL;
  	int64_t x31 = -1099039LL;
  	uint16_t x32 = UINT16_MAX;
  	volatile int64_t t2 = 62685470067LL;
  
      t2 = ((x29*x30)%(x31<=x32));
  
      if (t2 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f3(void) {
      	uint32_t x41 = 497U;
  	int32_t x42 = INT32_MIN;
  
      t3 = ((x41*x42)%(x43<=x44));
  
      if (t3 != 0U) { NG(); } else { ; }
  	
  }
  
  void f4(void) {
      	uint16_t x47 = 47U;
  	uint64_t x48 = 2176156403626679LLU;
  	volatile uint32_t t4 = 619189158U;
  
      t4 = ((x45*x46)%(x47<=x48));
  
      if (t4 != 0U) { NG(); } else { ; }
  	
  }
  
  void f5(void) {
      	int16_t x53 = -119;
  	uint64_t x55 = 7523LLU;
  	int16_t x56 = INT16_MIN;
  	uint64_t t5 = 23488273625LLU;
  
      t5 = ((x53*x54)%(x55<=x56));
  
      if (t5 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f6(void) {
      	int32_t x65 = 251792991;
  	uint32_t x66 = 18179649U;
  	int64_t x67 = -1LL;
  	static volatile uint32_t t6 = 16389209U;
  
      t6 = ((x65*x66)%(x67<=x68));
  
      if (t6 != 0U) { NG(); } else { ; }
  	
  }
  
  void f7(void) {
      	int32_t x77 = 983517150;
  	volatile uint8_t x78 = 0U;
  	int32_t x79 = INT32_MIN;
  	int16_t x80 = INT16_MIN;
  	int32_t t7 = 39;
  
      t7 = ((x77*x78)%(x79<=x80));
  
      if (t7 != 0) { NG(); } else { ; }
  	
  }
  
  void f8(void) {
      	volatile int32_t x93 = -1;
  	static int32_t x94 = INT32_MAX;
  	static volatile int16_t x95 = -1;
  	int16_t x96 = -1;
  	static int32_t t8 = 0;
  
      t8 = ((x93*x94)%(x95<=x96));
  
      if (t8 != 0) { NG(); } else { ; }
  	
  }
  
  void f9(void) {
      	static int16_t x113 = 186;
  	volatile int16_t x114 = INT16_MAX;
  	int64_t x115 = 459950641LL;
  	uint32_t x116 = UINT32_MAX;
  	static volatile int32_t t9 = -91;
  
      t9 = ((x113*x114)%(x115<=x116));
  
      if (t9 != 0) { NG(); } else { ; }
  	
  }
  
  void f10(void) {
      	uint8_t x129 = 7U;
  	uint16_t x130 = 5U;
  	uint8_t x131 = UINT8_MAX;
  	int32_t t10 = -25378;
  
      t10 = ((x129*x130)%(x131<=x132));
  
      if (t10 != 0) { NG(); } else { ; }
  	
  }
  
  void f11(void) {
      	volatile int16_t x137 = INT16_MAX;
  	int16_t x138 = 7311;
  	static volatile int32_t x139 = -1;
  	volatile int32_t t11 = 108;
  
      t11 = ((x137*x138)%(x139<=x140));
  
      if (t11 != 0) { NG(); } else { ; }
  	
  }
  
  void f12(void) {
      	int8_t x166 = INT8_MIN;
  	int16_t x167 = INT16_MIN;
  	int8_t x168 = 0;
  
      t12 = ((x165*x166)%(x167<=x168));
  
      if (t12 != 0) { NG(); } else { ; }
  	
  }
  
  void f13(void) {
      	int8_t x170 = -1;
  	int8_t x171 = -1;
  	int64_t t13 = 223516303934LL;
  
      t13 = ((x169*x170)%(x171<=x172));
  
      if (t13 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f14(void) {
      	static uint16_t x173 = 1U;
  	uint64_t x174 = 3857413LLU;
  	static int64_t x175 = INT64_MIN;
  	volatile uint8_t x176 = 48U;
  	uint64_t t14 = 2880769231789LLU;
  
      t14 = ((x173*x174)%(x175<=x176));
  
      if (t14 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f15(void) {
      	int16_t x177 = 1;
  	int8_t x180 = INT8_MIN;
  	int32_t t15 = 27135762;
  
      t15 = ((x177*x178)%(x179<=x180));
  
      if (t15 != 0) { NG(); } else { ; }
  	
  }
  
  void f16(void) {
      	static int8_t x186 = INT8_MIN;
  	int32_t x188 = INT32_MAX;
  	volatile int32_t t16 = 5464163;
  
      t16 = ((x185*x186)%(x187<=x188));
  
      if (t16 != 0) { NG(); } else { ; }
  	
  }
  
  void f17(void) {
      	int32_t x189 = -348;
  	static uint16_t x190 = 2377U;
  	static int8_t x191 = INT8_MAX;
  	int32_t t17 = 22;
  
      t17 = ((x189*x190)%(x191<=x192));
  
      if (t17 != 0) { NG(); } else { ; }
  	
  }
  
  void f18(void) {
      	static int64_t x201 = INT64_MAX;
  	volatile uint64_t x202 = UINT64_MAX;
  	volatile int32_t x203 = -1;
  	int64_t x204 = INT64_MAX;
  	volatile uint64_t t18 = 904LLU;
  
      t18 = ((x201*x202)%(x203<=x204));
  
      if (t18 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f19(void) {
      	int8_t x205 = -1;
  	uint32_t x206 = 16U;
  	int64_t x207 = INT64_MIN;
  	int64_t x208 = INT64_MIN;
  	volatile uint32_t t19 = 2964346U;
  
      t19 = ((x205*x206)%(x207<=x208));
  
      if (t19 != 0U) { NG(); } else { ; }
  	
  }
  
  void f20(void) {
      	int16_t x214 = -1;
  	volatile int64_t x215 = INT64_MIN;
  	int16_t x216 = INT16_MIN;
  	int32_t t20 = 1799966;
  
      t20 = ((x213*x214)%(x215<=x216));
  
      if (t20 != 0) { NG(); } else { ; }
  	
  }
  
  void f21(void) {
      	int32_t x218 = INT32_MIN;
  	int16_t x219 = INT16_MIN;
  	int32_t x220 = INT32_MAX;
  	volatile uint64_t t21 = 211853979122613LLU;
  
      t21 = ((x217*x218)%(x219<=x220));
  
      if (t21 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f22(void) {
      	static int64_t x225 = -521427340LL;
  	int64_t x227 = INT64_MIN;
  	static uint8_t x228 = 54U;
  	int64_t t22 = 26717LL;
  
      t22 = ((x225*x226)%(x227<=x228));
  
      if (t22 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f23(void) {
      	int16_t x233 = INT16_MIN;
  	uint64_t x234 = 21571306205158LLU;
  	volatile uint64_t t23 = 1831877551LLU;
  
      t23 = ((x233*x234)%(x235<=x236));
  
      if (t23 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f24(void) {
      	int32_t x237 = -1;
  	static uint16_t x238 = 240U;
  
      t24 = ((x237*x238)%(x239<=x240));
  
      if (t24 != 0) { NG(); } else { ; }
  	
  }
  
  void f25(void) {
      	uint32_t x249 = 198U;
  	static uint32_t x250 = 644U;
  
      t25 = ((x249*x250)%(x251<=x252));
  
      if (t25 != 0U) { NG(); } else { ; }
  	
  }
  
  void f26(void) {
      	int8_t x257 = -1;
  	int8_t x260 = 0;
  	volatile uint32_t t26 = 44049U;
  
      t26 = ((x257*x258)%(x259<=x260));
  
      if (t26 != 0U) { NG(); } else { ; }
  	
  }
  
  void f27(void) {
      	int64_t x265 = 742699LL;
  	static volatile uint64_t x268 = UINT64_MAX;
  	static int64_t t27 = -2802474573833860LL;
  
      t27 = ((x265*x266)%(x267<=x268));
  
      if (t27 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f28(void) {
      	int32_t x279 = INT32_MIN;
  	uint8_t x280 = 15U;
  	volatile int64_t t28 = 2LL;
  
      t28 = ((x277*x278)%(x279<=x280));
  
      if (t28 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f29(void) {
      	volatile uint32_t x289 = 6521094U;
  	uint64_t x290 = 248233LLU;
  	uint32_t x291 = 1U;
  	uint64_t t29 = 201474LLU;
  
      t29 = ((x289*x290)%(x291<=x292));
  
      if (t29 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f30(void) {
      	int16_t x293 = -26;
  	static int8_t x294 = INT8_MAX;
  	int8_t x295 = -1;
  	int32_t x296 = 0;
  	int32_t t30 = -3;
  
      t30 = ((x293*x294)%(x295<=x296));
  
      if (t30 != 0) { NG(); } else { ; }
  	
  }
  
  void f31(void) {
      	uint8_t x313 = UINT8_MAX;
  	uint64_t x314 = 1667958109439476228LLU;
  	volatile int64_t x315 = INT64_MIN;
  	volatile int8_t x316 = 8;
  	volatile uint64_t t31 = 430LLU;
  
      t31 = ((x313*x314)%(x315<=x316));
  
      if (t31 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f32(void) {
      	int16_t x321 = 1554;
  	int64_t x322 = -1675696579256LL;
  	static uint32_t x323 = 36864774U;
  	int16_t x324 = INT16_MIN;
  	volatile int64_t t32 = -1657451058101LL;
  
      t32 = ((x321*x322)%(x323<=x324));
  
      if (t32 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f33(void) {
      	static uint16_t x334 = 46U;
  	static uint64_t x335 = 93LLU;
  	volatile int32_t x336 = -1;
  	static volatile int32_t t33 = -992424191;
  
      t33 = ((x333*x334)%(x335<=x336));
  
      if (t33 != 0) { NG(); } else { ; }
  	
  }
  
  void f34(void) {
      	volatile int64_t x353 = -1LL;
  	int32_t x354 = INT32_MIN;
  	uint32_t x355 = UINT32_MAX;
  	int32_t x356 = -1;
  	static int64_t t34 = 1LL;
  
      t34 = ((x353*x354)%(x355<=x356));
  
      if (t34 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f35(void) {
      	uint8_t x365 = 3U;
  	volatile int16_t x366 = 0;
  	static int32_t x367 = INT32_MIN;
  	uint16_t x368 = 16028U;
  	static volatile int32_t t35 = 68519;
  
      t35 = ((x365*x366)%(x367<=x368));
  
      if (t35 != 0) { NG(); } else { ; }
  	
  }
  
  void f36(void) {
      	int16_t x369 = 11;
  	int16_t x370 = -1;
  	uint32_t x371 = 4031913U;
  	volatile int32_t t36 = -835;
  
      t36 = ((x369*x370)%(x371<=x372));
  
      if (t36 != 0) { NG(); } else { ; }
  	
  }
  
  void f37(void) {
      	int32_t x393 = -1;
  	uint16_t x394 = 497U;
  	uint64_t x395 = 35408154952LLU;
  	int16_t x396 = -62;
  	volatile int32_t t37 = 5;
  
      t37 = ((x393*x394)%(x395<=x396));
  
      if (t37 != 0) { NG(); } else { ; }
  	
  }
  
  void f38(void) {
      	int16_t x401 = -1;
  	static uint64_t x402 = UINT64_MAX;
  	volatile int16_t x403 = INT16_MIN;
  	int16_t x404 = INT16_MAX;
  
      t38 = ((x401*x402)%(x403<=x404));
  
      if (t38 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f39(void) {
      	static int16_t x405 = -1;
  	int32_t x406 = -1;
  	uint64_t x408 = 338533949LLU;
  
      t39 = ((x405*x406)%(x407<=x408));
  
      if (t39 != 0) { NG(); } else { ; }
  	
  }
  
  void f40(void) {
      	uint8_t x413 = 0U;
  	volatile int32_t x414 = INT32_MAX;
  	uint64_t x415 = 42025727LLU;
  	int32_t x416 = INT32_MAX;
  
      t40 = ((x413*x414)%(x415<=x416));
  
      if (t40 != 0) { NG(); } else { ; }
  	
  }
  
  void f41(void) {
      	volatile int8_t x425 = -1;
  	int8_t x426 = INT8_MIN;
  	static volatile int8_t x427 = 0;
  	static volatile int32_t t41 = -33959;
  
      t41 = ((x425*x426)%(x427<=x428));
  
      if (t41 != 0) { NG(); } else { ; }
  	
  }
  
  void f42(void) {
      	uint64_t x429 = 8281428124725LLU;
  	static volatile int32_t x430 = INT32_MAX;
  	static int32_t x431 = 110;
  	int16_t x432 = INT16_MAX;
  	static volatile uint64_t t42 = 364580458073LLU;
  
      t42 = ((x429*x430)%(x431<=x432));
  
      if (t42 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f43(void) {
      	uint8_t x438 = UINT8_MAX;
  	int8_t x439 = INT8_MAX;
  	int32_t x440 = INT32_MAX;
  	int32_t t43 = -40;
  
      t43 = ((x437*x438)%(x439<=x440));
  
      if (t43 != 0) { NG(); } else { ; }
  	
  }
  
  void f44(void) {
      	int16_t x441 = 1;
  	static int16_t x442 = INT16_MIN;
  	int8_t x443 = -1;
  	int8_t x444 = -1;
  	static int32_t t44 = -126873412;
  
      t44 = ((x441*x442)%(x443<=x444));
  
      if (t44 != 0) { NG(); } else { ; }
  	
  }
  
  void f45(void) {
      	int32_t x449 = INT32_MAX;
  	static uint32_t x450 = 12U;
  	static int32_t x451 = INT32_MIN;
  	uint32_t t45 = 1026U;
  
      t45 = ((x449*x450)%(x451<=x452));
  
      if (t45 != 0U) { NG(); } else { ; }
  	
  }
  
  void f46(void) {
      	volatile int8_t x453 = -5;
  	int64_t x455 = INT64_MIN;
  	uint32_t x456 = UINT32_MAX;
  	volatile int32_t t46 = 195875556;
  
      t46 = ((x453*x454)%(x455<=x456));
  
      if (t46 != 0) { NG(); } else { ; }
  	
  }
  
  void f47(void) {
      	volatile int64_t x479 = -2735478129209LL;
  	uint16_t x480 = 173U;
  	uint64_t t47 = 746652784850741LLU;
  
      t47 = ((x477*x478)%(x479<=x480));
  
      if (t47 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f48(void) {
      	int16_t x501 = INT16_MIN;
  	static uint16_t x502 = 187U;
  	static volatile int8_t x503 = -1;
  	volatile uint64_t x504 = UINT64_MAX;
  	static int32_t t48 = -12436;
  
      t48 = ((x501*x502)%(x503<=x504));
  
      if (t48 != 0) { NG(); } else { ; }
  	
  }
  
  void f49(void) {
      	static uint16_t x513 = UINT16_MAX;
  	int8_t x514 = 59;
  	int32_t x515 = -1;
  	int16_t x516 = 386;
  	int32_t t49 = -6;
  
      t49 = ((x513*x514)%(x515<=x516));
  
      if (t49 != 0) { NG(); } else { ; }
  	
  }
  
  void f50(void) {
      	static int64_t x537 = -1LL;
  	uint16_t x538 = 47U;
  	int32_t x539 = -1;
  	static volatile uint64_t x540 = UINT64_MAX;
  	int64_t t50 = 55943408LL;
  
      t50 = ((x537*x538)%(x539<=x540));
  
      if (t50 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f51(void) {
      	int16_t x549 = 9482;
  	volatile int16_t x550 = -14319;
  	int64_t x551 = -6521986528477LL;
  	int32_t t51 = -122718989;
  
      t51 = ((x549*x550)%(x551<=x552));
  
      if (t51 != 0) { NG(); } else { ; }
  	
  }
  
  void f52(void) {
      	int8_t x553 = INT8_MIN;
  	volatile int64_t t52 = -1LL;
  
      t52 = ((x553*x554)%(x555<=x556));
  
      if (t52 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f53(void) {
      	volatile int16_t x558 = INT16_MAX;
  	int32_t x560 = -1;
  	volatile int32_t t53 = 504;
  
      t53 = ((x557*x558)%(x559<=x560));
  
      if (t53 != 0) { NG(); } else { ; }
  	
  }
  
  void f54(void) {
      	uint32_t x565 = 77379U;
  	int8_t x566 = INT8_MIN;
  	static uint32_t x567 = 624438504U;
  	int8_t x568 = INT8_MIN;
  	volatile uint32_t t54 = 1U;
  
      t54 = ((x565*x566)%(x567<=x568));
  
      if (t54 != 0U) { NG(); } else { ; }
  	
  }
  
  void f55(void) {
      	volatile int16_t x581 = 484;
  	volatile uint8_t x582 = UINT8_MAX;
  	uint32_t x583 = 10436692U;
  	uint32_t x584 = UINT32_MAX;
  	int32_t t55 = -3;
  
      t55 = ((x581*x582)%(x583<=x584));
  
      if (t55 != 0) { NG(); } else { ; }
  	
  }
  
  void f56(void) {
      	uint32_t x594 = UINT32_MAX;
  	volatile int64_t x595 = INT64_MIN;
  	int64_t x596 = INT64_MAX;
  	volatile uint32_t t56 = 2016386U;
  
      t56 = ((x593*x594)%(x595<=x596));
  
      if (t56 != 0U) { NG(); } else { ; }
  	
  }
  
  void f57(void) {
      	int8_t x601 = INT8_MIN;
  	int16_t x602 = -1;
  	static int8_t x603 = INT8_MIN;
  	int8_t x604 = 45;
  
      t57 = ((x601*x602)%(x603<=x604));
  
      if (t57 != 0) { NG(); } else { ; }
  	
  }
  
  void f58(void) {
      	static uint16_t x605 = 0U;
  	uint64_t x606 = UINT64_MAX;
  	uint8_t x607 = UINT8_MAX;
  	int64_t x608 = INT64_MAX;
  	volatile uint64_t t58 = 184530200360989917LLU;
  
      t58 = ((x605*x606)%(x607<=x608));
  
      if (t58 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f59(void) {
      	uint32_t x626 = UINT32_MAX;
  	int32_t x627 = INT32_MIN;
  	int64_t x628 = -1LL;
  	volatile uint32_t t59 = 30453U;
  
      t59 = ((x625*x626)%(x627<=x628));
  
      if (t59 != 0U) { NG(); } else { ; }
  	
  }
  
  void f60(void) {
      	int16_t x637 = -1;
  	int16_t x638 = INT16_MAX;
  	static uint32_t x639 = 2U;
  	volatile int32_t t60 = -660175601;
  
      t60 = ((x637*x638)%(x639<=x640));
  
      if (t60 != 0) { NG(); } else { ; }
  	
  }
  
  void f61(void) {
      	static int8_t x641 = INT8_MIN;
  	uint8_t x643 = 38U;
  	static int32_t x644 = INT32_MAX;
  	volatile int32_t t61 = 324614224;
  
      t61 = ((x641*x642)%(x643<=x644));
  
      if (t61 != 0) { NG(); } else { ; }
  	
  }
  
  void f62(void) {
      	int64_t x653 = INT64_MIN;
  	uint64_t x654 = UINT64_MAX;
  	int16_t x655 = INT16_MIN;
  	uint8_t x656 = 0U;
  	uint64_t t62 = 203970928448LLU;
  
      t62 = ((x653*x654)%(x655<=x656));
  
      if (t62 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f63(void) {
      	int32_t x657 = 0;
  	static int16_t x658 = 166;
  	volatile int32_t x659 = INT32_MIN;
  	volatile int16_t x660 = 14473;
  	static volatile int32_t t63 = 2180864;
  
      t63 = ((x657*x658)%(x659<=x660));
  
      if (t63 != 0) { NG(); } else { ; }
  	
  }
  
  void f64(void) {
      	uint32_t x661 = 100011U;
  	uint16_t x662 = 9U;
  	int8_t x663 = -1;
  	volatile int8_t x664 = 19;
  	static uint32_t t64 = 710U;
  
      t64 = ((x661*x662)%(x663<=x664));
  
      if (t64 != 0U) { NG(); } else { ; }
  	
  }
  
  void f65(void) {
      	uint32_t x669 = 1U;
  	static uint32_t x671 = UINT32_MAX;
  	uint64_t x672 = 4781264862LLU;
  	volatile uint32_t t65 = 890725088U;
  
      t65 = ((x669*x670)%(x671<=x672));
  
      if (t65 != 0U) { NG(); } else { ; }
  	
  }
  
  void f66(void) {
      	int16_t x673 = INT16_MAX;
  	int64_t x675 = INT64_MIN;
  	uint8_t x676 = 63U;
  	int32_t t66 = -2;
  
      t66 = ((x673*x674)%(x675<=x676));
  
      if (t66 != 0) { NG(); } else { ; }
  	
  }
  
  void f67(void) {
      	uint32_t x677 = 449202769U;
  	static int8_t x678 = INT8_MIN;
  	volatile int16_t x679 = 7;
  	static volatile int64_t x680 = INT64_MAX;
  
      t67 = ((x677*x678)%(x679<=x680));
  
      if (t67 != 0U) { NG(); } else { ; }
  	
  }
  
  void f68(void) {
      	int8_t x690 = INT8_MIN;
  	uint32_t x692 = 840197674U;
  	volatile int32_t t68 = -43525953;
  
      t68 = ((x689*x690)%(x691<=x692));
  
      if (t68 != 0) { NG(); } else { ; }
  	
  }
  
  void f69(void) {
      	static int64_t x693 = -1LL;
  	volatile int64_t x694 = INT64_MAX;
  	uint32_t x695 = 82U;
  	static volatile int64_t t69 = 11127LL;
  
      t69 = ((x693*x694)%(x695<=x696));
  
      if (t69 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f70(void) {
      	int32_t x705 = -12;
  	uint32_t x706 = UINT32_MAX;
  	uint16_t x707 = UINT16_MAX;
  	static uint32_t t70 = 2038U;
  
      t70 = ((x705*x706)%(x707<=x708));
  
      if (t70 != 0U) { NG(); } else { ; }
  	
  }
  
  void f71(void) {
      	static int64_t x709 = -1LL;
  	int32_t x710 = -25382;
  	int8_t x711 = INT8_MIN;
  	uint16_t x712 = 6382U;
  	volatile int64_t t71 = -1LL;
  
      t71 = ((x709*x710)%(x711<=x712));
  
      if (t71 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f72(void) {
      	int64_t x722 = -27175864055594LL;
  	int16_t x723 = 1;
  	int64_t t72 = 76027944338LL;
  
      t72 = ((x721*x722)%(x723<=x724));
  
      if (t72 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f73(void) {
      	uint64_t x754 = 243155895542083LLU;
  	int8_t x755 = 25;
  	static uint8_t x756 = 62U;
  
      t73 = ((x753*x754)%(x755<=x756));
  
      if (t73 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f74(void) {
      	uint8_t x757 = UINT8_MAX;
  	int16_t x758 = INT16_MIN;
  	static int32_t x759 = -1;
  	static volatile int32_t t74 = -214;
  
      t74 = ((x757*x758)%(x759<=x760));
  
      if (t74 != 0) { NG(); } else { ; }
  	
  }
  
  void f75(void) {
      	int8_t x761 = -3;
  	int64_t x762 = 70289385990924717LL;
  	uint8_t x763 = UINT8_MAX;
  	int32_t x764 = INT32_MAX;
  
      t75 = ((x761*x762)%(x763<=x764));
  
      if (t75 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f76(void) {
      	static uint32_t x766 = UINT32_MAX;
  	int32_t x767 = -1;
  	uint32_t t76 = 2523U;
  
      t76 = ((x765*x766)%(x767<=x768));
  
      if (t76 != 0U) { NG(); } else { ; }
  	
  }
  
  void f77(void) {
      	uint16_t x773 = 5U;
  	int8_t x774 = -1;
  	uint16_t x776 = UINT16_MAX;
  	volatile int32_t t77 = 7;
  
      t77 = ((x773*x774)%(x775<=x776));
  
      if (t77 != 0) { NG(); } else { ; }
  	
  }
  
  void f78(void) {
      	uint32_t x777 = UINT32_MAX;
  	volatile uint16_t x778 = 5794U;
  	static volatile int8_t x780 = INT8_MIN;
  
      t78 = ((x777*x778)%(x779<=x780));
  
      if (t78 != 0U) { NG(); } else { ; }
  	
  }
  
  void f79(void) {
      	static uint16_t x785 = 5048U;
  	int32_t x786 = -3;
  	uint8_t x787 = 43U;
  	uint64_t x788 = UINT64_MAX;
  	volatile int32_t t79 = -4385;
  
      t79 = ((x785*x786)%(x787<=x788));
  
      if (t79 != 0) { NG(); } else { ; }
  	
  }
  
  void f80(void) {
      	static volatile uint32_t x789 = 232U;
  	uint32_t x790 = UINT32_MAX;
  	int64_t x791 = INT64_MIN;
  	uint32_t t80 = 59212U;
  
      t80 = ((x789*x790)%(x791<=x792));
  
      if (t80 != 0U) { NG(); } else { ; }
  	
  }
  
  void f81(void) {
      	int8_t x795 = 27;
  	volatile int64_t x796 = 5257836430623LL;
  	int64_t t81 = 117396793431489103LL;
  
      t81 = ((x793*x794)%(x795<=x796));
  
      if (t81 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f82(void) {
      	int8_t x801 = INT8_MAX;
  	int8_t x802 = INT8_MIN;
  	static uint8_t x804 = UINT8_MAX;
  	int32_t t82 = -1001573391;
  
      t82 = ((x801*x802)%(x803<=x804));
  
      if (t82 != 0) { NG(); } else { ; }
  	
  }
  
  void f83(void) {
      	uint16_t x829 = UINT16_MAX;
  	int32_t x830 = -1;
  	int32_t x832 = 2126432;
  	int32_t t83 = 109;
  
      t83 = ((x829*x830)%(x831<=x832));
  
      if (t83 != 0) { NG(); } else { ; }
  	
  }
  
  void f84(void) {
      	int32_t x833 = -1;
  	int64_t x835 = INT64_MIN;
  	volatile int32_t t84 = -1041313646;
  
      t84 = ((x833*x834)%(x835<=x836));
  
      if (t84 != 0) { NG(); } else { ; }
  	
  }
  
  void f85(void) {
      	volatile int8_t x837 = INT8_MAX;
  	uint32_t x839 = 2U;
  	uint32_t x840 = UINT32_MAX;
  	int32_t t85 = -10630;
  
      t85 = ((x837*x838)%(x839<=x840));
  
      if (t85 != 0) { NG(); } else { ; }
  	
  }
  
  void f86(void) {
      	volatile int16_t x853 = 0;
  	static volatile uint64_t x854 = 1LLU;
  	int16_t x855 = -1;
  	uint32_t x856 = UINT32_MAX;
  	uint64_t t86 = 187675847410LLU;
  
      t86 = ((x853*x854)%(x855<=x856));
  
      if (t86 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f87(void) {
      	uint16_t x857 = 2U;
  	volatile uint64_t x858 = 222LLU;
  	static int32_t x859 = -1;
  	uint8_t x860 = 12U;
  	volatile uint64_t t87 = 171550619867LLU;
  
      t87 = ((x857*x858)%(x859<=x860));
  
      if (t87 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f88(void) {
      	volatile int8_t x865 = -1;
  	static int32_t x867 = INT32_MAX;
  	volatile uint32_t x868 = UINT32_MAX;
  	volatile uint64_t t88 = 188026LLU;
  
      t88 = ((x865*x866)%(x867<=x868));
  
      if (t88 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f89(void) {
      	int8_t x869 = INT8_MIN;
  	int8_t x870 = INT8_MAX;
  	int8_t x871 = INT8_MAX;
  	static uint64_t x872 = 335574LLU;
  
      t89 = ((x869*x870)%(x871<=x872));
  
      if (t89 != 0) { NG(); } else { ; }
  	
  }
  
  void f90(void) {
      	int16_t x877 = -1;
  	uint8_t x878 = 1U;
  	volatile int64_t x879 = -212979031191LL;
  	int8_t x880 = -9;
  	int32_t t90 = -29467098;
  
      t90 = ((x877*x878)%(x879<=x880));
  
      if (t90 != 0) { NG(); } else { ; }
  	
  }
  
  void f91(void) {
      	int8_t x897 = INT8_MIN;
  	uint32_t x898 = 518735716U;
  	int64_t x899 = -123277671846629LL;
  	volatile uint32_t x900 = 8161U;
  	static volatile uint32_t t91 = 0U;
  
      t91 = ((x897*x898)%(x899<=x900));
  
      if (t91 != 0U) { NG(); } else { ; }
  	
  }
  
  void f92(void) {
      	uint32_t x905 = 4504U;
  	int8_t x906 = -1;
  	uint8_t x907 = 0U;
  	uint32_t x908 = 863U;
  	static uint32_t t92 = 31902958U;
  
      t92 = ((x905*x906)%(x907<=x908));
  
      if (t92 != 0U) { NG(); } else { ; }
  	
  }
  
  void f93(void) {
      	int8_t x937 = INT8_MIN;
  	int8_t x939 = -1;
  	uint32_t x940 = UINT32_MAX;
  	volatile int64_t t93 = 165LL;
  
      t93 = ((x937*x938)%(x939<=x940));
  
      if (t93 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f94(void) {
      	int32_t x945 = -1;
  	uint16_t x946 = UINT16_MAX;
  	int32_t x947 = INT32_MIN;
  	static int64_t x948 = 10177191LL;
  	static volatile int32_t t94 = -7941;
  
      t94 = ((x945*x946)%(x947<=x948));
  
      if (t94 != 0) { NG(); } else { ; }
  	
  }
  
  void f95(void) {
      	volatile int16_t x949 = INT16_MIN;
  	static int8_t x950 = INT8_MIN;
  	int32_t x951 = INT32_MIN;
  	uint8_t x952 = 15U;
  	int32_t t95 = -15;
  
      t95 = ((x949*x950)%(x951<=x952));
  
      if (t95 != 0) { NG(); } else { ; }
  	
  }
  
  void f96(void) {
      	static uint32_t x957 = 815U;
  	int8_t x958 = INT8_MIN;
  	int64_t x959 = INT64_MIN;
  	volatile uint32_t t96 = 246U;
  
      t96 = ((x957*x958)%(x959<=x960));
  
      if (t96 != 0U) { NG(); } else { ; }
  	
  }
  
  void f97(void) {
      	int16_t x961 = INT16_MIN;
  	volatile int8_t x962 = INT8_MIN;
  	int16_t x963 = INT16_MIN;
  	uint32_t x964 = UINT32_MAX;
  	volatile int32_t t97 = 10;
  
      t97 = ((x961*x962)%(x963<=x964));
  
      if (t97 != 0) { NG(); } else { ; }
  	
  }
  
  void f98(void) {
      	uint64_t x982 = 17730930292446828LLU;
  	static uint16_t x983 = 2339U;
  	int32_t x984 = INT32_MAX;
  	volatile uint64_t t98 = 1490332063217157LLU;
  
      t98 = ((x981*x982)%(x983<=x984));
  
      if (t98 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f99(void) {
      	uint8_t x985 = UINT8_MAX;
  	int16_t x986 = INT16_MIN;
  	static uint8_t x987 = 42U;
  	volatile int32_t t99 = -274;
  
      t99 = ((x985*x986)%(x987<=x988));
  
      if (t99 != 0) { NG(); } else { ; }
  	
  }
  
  void f100(void) {
      	int64_t x1001 = -51LL;
  	uint16_t x1002 = 2500U;
  	static int32_t x1003 = INT32_MIN;
  	int16_t x1004 = INT16_MIN;
  	int64_t t100 = 8LL;
  
      t100 = ((x1001*x1002)%(x1003<=x1004));
  
      if (t100 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f101(void) {
      	static volatile uint64_t x1017 = UINT64_MAX;
  	static int32_t x1018 = INT32_MIN;
  	static int64_t x1019 = INT64_MIN;
  	uint64_t t101 = 227138LLU;
  
      t101 = ((x1017*x1018)%(x1019<=x1020));
  
      if (t101 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f102(void) {
      	static uint32_t x1029 = UINT32_MAX;
  	uint64_t x1030 = 12309456LLU;
  	volatile uint32_t x1031 = UINT32_MAX;
  	uint64_t t102 = 409LLU;
  
      t102 = ((x1029*x1030)%(x1031<=x1032));
  
      if (t102 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f103(void) {
      	volatile uint32_t x1049 = 1U;
  	int16_t x1050 = -149;
  	static volatile uint32_t x1051 = 482121U;
  	int32_t x1052 = INT32_MAX;
  
      t103 = ((x1049*x1050)%(x1051<=x1052));
  
      if (t103 != 0U) { NG(); } else { ; }
  	
  }
  
  void f104(void) {
      	int8_t x1053 = -1;
  	static int64_t x1055 = INT64_MIN;
  	volatile int64_t x1056 = INT64_MAX;
  	int32_t t104 = 173099;
  
      t104 = ((x1053*x1054)%(x1055<=x1056));
  
      if (t104 != 0) { NG(); } else { ; }
  	
  }
  
  void f105(void) {
      	uint64_t x1058 = 667032505137532LLU;
  	static uint32_t x1059 = 517432699U;
  	static int32_t x1060 = -1;
  	uint64_t t105 = 8572518542LLU;
  
      t105 = ((x1057*x1058)%(x1059<=x1060));
  
      if (t105 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f106(void) {
      	static uint16_t x1101 = 119U;
  	int8_t x1102 = INT8_MAX;
  	int64_t x1104 = -1LL;
  	volatile int32_t t106 = -53951527;
  
      t106 = ((x1101*x1102)%(x1103<=x1104));
  
      if (t106 != 0) { NG(); } else { ; }
  	
  }
  
  void f107(void) {
      	uint64_t x1130 = UINT64_MAX;
  	static volatile int8_t x1131 = INT8_MIN;
  	static uint64_t t107 = 24237533620471LLU;
  
      t107 = ((x1129*x1130)%(x1131<=x1132));
  
      if (t107 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f108(void) {
      	static uint32_t x1141 = UINT32_MAX;
  	volatile int16_t x1143 = INT16_MIN;
  	int16_t x1144 = 1;
  	uint32_t t108 = 18055U;
  
      t108 = ((x1141*x1142)%(x1143<=x1144));
  
      if (t108 != 0U) { NG(); } else { ; }
  	
  }
  
  void f109(void) {
      	uint8_t x1159 = 2U;
  	static volatile int64_t t109 = 121030186LL;
  
      t109 = ((x1157*x1158)%(x1159<=x1160));
  
      if (t109 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f110(void) {
      	uint64_t x1177 = 182944241LLU;
  	volatile int32_t x1178 = INT32_MIN;
  	int16_t x1179 = -3608;
  	static int64_t x1180 = -1LL;
  	volatile uint64_t t110 = 250633491LLU;
  
      t110 = ((x1177*x1178)%(x1179<=x1180));
  
      if (t110 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f111(void) {
      	int16_t x1181 = 12;
  	int64_t x1183 = INT64_MIN;
  	static int64_t x1184 = INT64_MAX;
  	int64_t t111 = -59902136523003LL;
  
      t111 = ((x1181*x1182)%(x1183<=x1184));
  
      if (t111 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f112(void) {
      	int16_t x1185 = INT16_MIN;
  	static int8_t x1186 = 31;
  	int32_t x1187 = 938;
  	volatile int32_t x1188 = INT32_MAX;
  	static int32_t t112 = 3;
  
      t112 = ((x1185*x1186)%(x1187<=x1188));
  
      if (t112 != 0) { NG(); } else { ; }
  	
  }
  
  void f113(void) {
      	uint32_t x1189 = 50363U;
  	uint16_t x1190 = 15U;
  	int8_t x1191 = INT8_MIN;
  	int64_t x1192 = 4310865006116986499LL;
  	uint32_t t113 = 1615732U;
  
      t113 = ((x1189*x1190)%(x1191<=x1192));
  
      if (t113 != 0U) { NG(); } else { ; }
  	
  }
  
  void f114(void) {
      	uint8_t x1193 = UINT8_MAX;
  	volatile uint8_t x1194 = UINT8_MAX;
  	int8_t x1196 = 1;
  
      t114 = ((x1193*x1194)%(x1195<=x1196));
  
      if (t114 != 0) { NG(); } else { ; }
  	
  }
  
  void f115(void) {
      	static volatile int8_t x1205 = INT8_MIN;
  	int8_t x1206 = -1;
  	int64_t x1207 = INT64_MIN;
  	int32_t x1208 = 1;
  	int32_t t115 = -329154531;
  
      t115 = ((x1205*x1206)%(x1207<=x1208));
  
      if (t115 != 0) { NG(); } else { ; }
  	
  }
  
  void f116(void) {
      	volatile uint16_t x1214 = 2035U;
  	int64_t x1216 = 5LL;
  	static int32_t t116 = 0;
  
      t116 = ((x1213*x1214)%(x1215<=x1216));
  
      if (t116 != 0) { NG(); } else { ; }
  	
  }
  
  void f117(void) {
      	volatile uint64_t x1221 = 337504739436453693LLU;
  	int8_t x1222 = -1;
  	int8_t x1223 = -2;
  	int16_t x1224 = -1;
  	static uint64_t t117 = 839275501654510LLU;
  
      t117 = ((x1221*x1222)%(x1223<=x1224));
  
      if (t117 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f118(void) {
      	int32_t x1253 = 19180663;
  	uint8_t x1255 = 0U;
  	uint64_t x1256 = 407LLU;
  
      t118 = ((x1253*x1254)%(x1255<=x1256));
  
      if (t118 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f119(void) {
      	static volatile uint32_t x1257 = 347943296U;
  	int32_t x1258 = -12185599;
  	int8_t x1259 = -7;
  	int8_t x1260 = INT8_MAX;
  	volatile uint32_t t119 = 199U;
  
      t119 = ((x1257*x1258)%(x1259<=x1260));
  
      if (t119 != 0U) { NG(); } else { ; }
  	
  }
  
  void f120(void) {
      	int64_t x1267 = INT64_MIN;
  	int32_t x1268 = 1;
  	volatile uint32_t t120 = 3U;
  
      t120 = ((x1265*x1266)%(x1267<=x1268));
  
      if (t120 != 0U) { NG(); } else { ; }
  	
  }
  
  void f121(void) {
      	uint8_t x1281 = 1U;
  	volatile int8_t x1282 = INT8_MAX;
  	volatile uint8_t x1283 = 2U;
  	uint8_t x1284 = UINT8_MAX;
  	static volatile int32_t t121 = -53589;
  
      t121 = ((x1281*x1282)%(x1283<=x1284));
  
      if (t121 != 0) { NG(); } else { ; }
  	
  }
  
  void f122(void) {
      	uint8_t x1285 = 1U;
  	uint16_t x1286 = 1U;
  	uint32_t x1287 = UINT32_MAX;
  
      t122 = ((x1285*x1286)%(x1287<=x1288));
  
      if (t122 != 0) { NG(); } else { ; }
  	
  }
  
  void f123(void) {
      	uint32_t x1293 = 1U;
  	static volatile int8_t x1294 = 0;
  	static uint8_t x1296 = 19U;
  
      t123 = ((x1293*x1294)%(x1295<=x1296));
  
      if (t123 != 0U) { NG(); } else { ; }
  	
  }
  
  void f124(void) {
      	int16_t x1297 = INT16_MIN;
  	uint32_t x1298 = UINT32_MAX;
  	int16_t x1299 = INT16_MIN;
  	int32_t x1300 = INT32_MAX;
  	uint32_t t124 = 353U;
  
      t124 = ((x1297*x1298)%(x1299<=x1300));
  
      if (t124 != 0U) { NG(); } else { ; }
  	
  }
  
  void f125(void) {
      	uint32_t x1309 = 12461U;
  	uint16_t x1310 = UINT16_MAX;
  	int64_t x1311 = INT64_MIN;
  	static uint64_t x1312 = UINT64_MAX;
  	volatile uint32_t t125 = 6697U;
  
      t125 = ((x1309*x1310)%(x1311<=x1312));
  
      if (t125 != 0U) { NG(); } else { ; }
  	
  }
  
  void f126(void) {
      	int32_t x1313 = -1;
  	volatile int32_t x1314 = 1;
  	int8_t x1316 = INT8_MIN;
  
      t126 = ((x1313*x1314)%(x1315<=x1316));
  
      if (t126 != 0) { NG(); } else { ; }
  	
  }
  
  void f127(void) {
      	static int8_t x1326 = INT8_MIN;
  	int8_t x1327 = INT8_MIN;
  	static volatile int8_t x1328 = INT8_MAX;
  
      t127 = ((x1325*x1326)%(x1327<=x1328));
  
      if (t127 != 0) { NG(); } else { ; }
  	
  }
  
  void f128(void) {
      	int16_t x1337 = INT16_MAX;
  	static uint8_t x1338 = 127U;
  	int16_t x1340 = INT16_MIN;
  	volatile int32_t t128 = 49;
  
      t128 = ((x1337*x1338)%(x1339<=x1340));
  
      if (t128 != 0) { NG(); } else { ; }
  	
  }
  
  void f129(void) {
      	uint16_t x1345 = 1U;
  	int8_t x1348 = -1;
  	int32_t t129 = 320393499;
  
      t129 = ((x1345*x1346)%(x1347<=x1348));
  
      if (t129 != 0) { NG(); } else { ; }
  	
  }
  
  void f130(void) {
      	static int32_t x1357 = -497;
  	volatile uint32_t x1358 = 309U;
  	volatile int16_t x1359 = -14;
  	uint16_t x1360 = UINT16_MAX;
  	volatile uint32_t t130 = 119U;
  
      t130 = ((x1357*x1358)%(x1359<=x1360));
  
      if (t130 != 0U) { NG(); } else { ; }
  	
  }
  
  void f131(void) {
      	uint16_t x1377 = 172U;
  	int8_t x1378 = INT8_MAX;
  	static uint32_t x1379 = 6217U;
  
      t131 = ((x1377*x1378)%(x1379<=x1380));
  
      if (t131 != 0) { NG(); } else { ; }
  	
  }
  
  void f132(void) {
      	static uint32_t x1405 = 718253U;
  	static int8_t x1408 = INT8_MAX;
  	uint32_t t132 = 121U;
  
      t132 = ((x1405*x1406)%(x1407<=x1408));
  
      if (t132 != 0U) { NG(); } else { ; }
  	
  }
  
  void f133(void) {
      	volatile uint16_t x1409 = 4U;
  	volatile int8_t x1410 = INT8_MAX;
  	int32_t x1411 = INT32_MIN;
  
      t133 = ((x1409*x1410)%(x1411<=x1412));
  
      if (t133 != 0) { NG(); } else { ; }
  	
  }
  
  void f134(void) {
      	uint32_t x1413 = 1720757U;
  	int16_t x1414 = -6;
  	int16_t x1415 = -1;
  	volatile int32_t x1416 = -1;
  	volatile uint32_t t134 = 5573U;
  
      t134 = ((x1413*x1414)%(x1415<=x1416));
  
      if (t134 != 0U) { NG(); } else { ; }
  	
  }
  
  void f135(void) {
      	int32_t x1445 = -1;
  	int64_t x1446 = -1LL;
  	volatile uint8_t x1447 = 8U;
  	uint8_t x1448 = 20U;
  	volatile int64_t t135 = -42027021119LL;
  
      t135 = ((x1445*x1446)%(x1447<=x1448));
  
      if (t135 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f136(void) {
      	int32_t x1449 = 1;
  	volatile uint64_t x1450 = UINT64_MAX;
  	uint16_t x1452 = 0U;
  	volatile uint64_t t136 = 3045054172068LLU;
  
      t136 = ((x1449*x1450)%(x1451<=x1452));
  
      if (t136 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f137(void) {
      	volatile int16_t x1453 = 12;
  	static int32_t x1454 = -7;
  	int64_t x1456 = INT64_MAX;
  
      t137 = ((x1453*x1454)%(x1455<=x1456));
  
      if (t137 != 0) { NG(); } else { ; }
  	
  }
  
  void f138(void) {
      	volatile int64_t x1465 = -8828LL;
  	uint64_t x1466 = UINT64_MAX;
  	uint32_t x1467 = 206326U;
  	int8_t x1468 = -1;
  	uint64_t t138 = 4224985LLU;
  
      t138 = ((x1465*x1466)%(x1467<=x1468));
  
      if (t138 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f139(void) {
      	uint64_t x1473 = 2019505257LLU;
  	uint16_t x1474 = 1172U;
  	static int16_t x1475 = INT16_MIN;
  	uint8_t x1476 = 0U;
  	uint64_t t139 = 932231LLU;
  
      t139 = ((x1473*x1474)%(x1475<=x1476));
  
      if (t139 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f140(void) {
      	int8_t x1493 = -1;
  	uint8_t x1494 = 0U;
  	volatile uint64_t x1495 = 12706217982409LLU;
  	static int8_t x1496 = INT8_MIN;
  	static volatile int32_t t140 = 20811;
  
      t140 = ((x1493*x1494)%(x1495<=x1496));
  
      if (t140 != 0) { NG(); } else { ; }
  	
  }
  
  void f141(void) {
      	int16_t x1501 = -1;
  	static volatile int64_t x1502 = INT64_MAX;
  	int8_t x1504 = -58;
  	static int64_t t141 = 294127884LL;
  
      t141 = ((x1501*x1502)%(x1503<=x1504));
  
      if (t141 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f142(void) {
      	int16_t x1505 = -1;
  	static uint16_t x1506 = UINT16_MAX;
  	static volatile int32_t x1507 = INT32_MIN;
  	int32_t x1508 = INT32_MIN;
  
      t142 = ((x1505*x1506)%(x1507<=x1508));
  
      if (t142 != 0) { NG(); } else { ; }
  	
  }
  
  void f143(void) {
      	static int16_t x1509 = INT16_MAX;
  	int64_t x1510 = -1LL;
  	int64_t t143 = 45219LL;
  
      t143 = ((x1509*x1510)%(x1511<=x1512));
  
      if (t143 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f144(void) {
      	uint8_t x1533 = UINT8_MAX;
  	int16_t x1534 = -1;
  	volatile int32_t t144 = 18375;
  
      t144 = ((x1533*x1534)%(x1535<=x1536));
  
      if (t144 != 0) { NG(); } else { ; }
  	
  }
  
  void f145(void) {
      	static int64_t x1541 = 0LL;
  	int16_t x1543 = -795;
  	uint8_t x1544 = UINT8_MAX;
  	int64_t t145 = -7117034969152647LL;
  
      t145 = ((x1541*x1542)%(x1543<=x1544));
  
      if (t145 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f146(void) {
      	uint16_t x1550 = 1321U;
  	int32_t x1552 = 2;
  	volatile int32_t t146 = -65025;
  
      t146 = ((x1549*x1550)%(x1551<=x1552));
  
      if (t146 != 0) { NG(); } else { ; }
  	
  }
  
  void f147(void) {
      	uint16_t x1554 = UINT16_MAX;
  	int8_t x1555 = -1;
  	volatile uint16_t x1556 = UINT16_MAX;
  	static volatile int32_t t147 = 5180;
  
      t147 = ((x1553*x1554)%(x1555<=x1556));
  
      if (t147 != 0) { NG(); } else { ; }
  	
  }
  
  void f148(void) {
      	uint8_t x1557 = 1U;
  	int16_t x1558 = -1;
  	static int32_t x1559 = INT32_MIN;
  	static volatile int16_t x1560 = INT16_MIN;
  
      t148 = ((x1557*x1558)%(x1559<=x1560));
  
      if (t148 != 0) { NG(); } else { ; }
  	
  }
  
  void f149(void) {
      	uint8_t x1585 = 0U;
  	static int16_t x1586 = -1;
  	volatile int32_t x1587 = INT32_MIN;
  	uint16_t x1588 = 108U;
  	volatile int32_t t149 = -406;
  
      t149 = ((x1585*x1586)%(x1587<=x1588));
  
      if (t149 != 0) { NG(); } else { ; }
  	
  }
  
  void f150(void) {
      	static volatile int32_t x1593 = INT32_MIN;
  	static uint32_t x1594 = UINT32_MAX;
  	uint32_t x1595 = 30848U;
  	volatile uint32_t t150 = 739943U;
  
      t150 = ((x1593*x1594)%(x1595<=x1596));
  
      if (t150 != 0U) { NG(); } else { ; }
  	
  }
  
  void f151(void) {
      	uint8_t x1609 = 0U;
  	static int8_t x1610 = 0;
  	static int16_t x1611 = -5419;
  	uint8_t x1612 = UINT8_MAX;
  	static volatile int32_t t151 = -5;
  
      t151 = ((x1609*x1610)%(x1611<=x1612));
  
      if (t151 != 0) { NG(); } else { ; }
  	
  }
  
  void f152(void) {
      	volatile uint8_t x1622 = 25U;
  	int32_t x1623 = -1869;
  
      t152 = ((x1621*x1622)%(x1623<=x1624));
  
      if (t152 != 0) { NG(); } else { ; }
  	
  }
  
  void f153(void) {
      	static uint16_t x1633 = UINT16_MAX;
  	int8_t x1635 = INT8_MAX;
  	uint8_t x1636 = UINT8_MAX;
  	int32_t t153 = 461;
  
      t153 = ((x1633*x1634)%(x1635<=x1636));
  
      if (t153 != 0) { NG(); } else { ; }
  	
  }
  
  void f154(void) {
      	volatile uint32_t x1657 = UINT32_MAX;
  	int32_t x1659 = INT32_MIN;
  	volatile uint8_t x1660 = 3U;
  	volatile uint64_t t154 = 96475876LLU;
  
      t154 = ((x1657*x1658)%(x1659<=x1660));
  
      if (t154 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f155(void) {
      	uint16_t x1689 = 2751U;
  	static volatile uint64_t x1690 = 21665212028434LLU;
  	uint64_t t155 = 4880LLU;
  
      t155 = ((x1689*x1690)%(x1691<=x1692));
  
      if (t155 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f156(void) {
      	volatile uint32_t x1701 = 1U;
  	int32_t x1704 = INT32_MAX;
  	volatile int64_t t156 = 25539045936961786LL;
  
      t156 = ((x1701*x1702)%(x1703<=x1704));
  
      if (t156 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f157(void) {
      	volatile int8_t x1717 = INT8_MAX;
  	static int64_t x1719 = -1LL;
  	int8_t x1720 = -1;
  
      t157 = ((x1717*x1718)%(x1719<=x1720));
  
      if (t157 != 0) { NG(); } else { ; }
  	
  }
  
  void f158(void) {
      	int16_t x1725 = INT16_MIN;
  	int8_t x1726 = INT8_MIN;
  	static uint64_t x1727 = 64410946063855LLU;
  	int32_t x1728 = -107;
  	static volatile int32_t t158 = -891;
  
      t158 = ((x1725*x1726)%(x1727<=x1728));
  
      if (t158 != 0) { NG(); } else { ; }
  	
  }
  
  void f159(void) {
      	uint32_t x1745 = 3278712U;
  	volatile int8_t x1747 = INT8_MAX;
  	volatile uint32_t x1748 = 189U;
  
      t159 = ((x1745*x1746)%(x1747<=x1748));
  
      if (t159 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f160(void) {
      	volatile uint16_t x1749 = 47U;
  	int64_t x1750 = 101LL;
  	int64_t x1751 = INT64_MIN;
  	int64_t t160 = -29082594357LL;
  
      t160 = ((x1749*x1750)%(x1751<=x1752));
  
      if (t160 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f161(void) {
      	volatile int32_t x1757 = -1;
  	int64_t x1759 = INT64_MIN;
  	static int8_t x1760 = -5;
  
      t161 = ((x1757*x1758)%(x1759<=x1760));
  
      if (t161 != 0) { NG(); } else { ; }
  	
  }
  
  void f162(void) {
      	uint32_t x1761 = 112U;
  	static int16_t x1762 = -1525;
  	int8_t x1763 = -2;
  	int8_t x1764 = 7;
  	volatile uint32_t t162 = 24U;
  
      t162 = ((x1761*x1762)%(x1763<=x1764));
  
      if (t162 != 0U) { NG(); } else { ; }
  	
  }
  
  void f163(void) {
      	volatile int32_t x1765 = INT32_MIN;
  	int32_t x1767 = INT32_MIN;
  	volatile uint16_t x1768 = 3U;
  	uint32_t t163 = 367U;
  
      t163 = ((x1765*x1766)%(x1767<=x1768));
  
      if (t163 != 0U) { NG(); } else { ; }
  	
  }
  
  void f164(void) {
      	int16_t x1769 = -1;
  	int8_t x1770 = INT8_MIN;
  	int64_t x1771 = -1LL;
  	static int8_t x1772 = 0;
  	int32_t t164 = -40;
  
      t164 = ((x1769*x1770)%(x1771<=x1772));
  
      if (t164 != 0) { NG(); } else { ; }
  	
  }
  
  void f165(void) {
      	uint16_t x1786 = 89U;
  	int16_t x1787 = INT16_MIN;
  	static volatile int16_t x1788 = -1;
  
      t165 = ((x1785*x1786)%(x1787<=x1788));
  
      if (t165 != 0) { NG(); } else { ; }
  	
  }
  
  void f166(void) {
      	volatile uint64_t x1793 = UINT64_MAX;
  	volatile int64_t x1794 = INT64_MIN;
  	volatile uint32_t x1795 = 398892U;
  	int64_t x1796 = 63464961795469708LL;
  	volatile uint64_t t166 = 7138LLU;
  
      t166 = ((x1793*x1794)%(x1795<=x1796));
  
      if (t166 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f167(void) {
      	int16_t x1798 = -1;
  	int32_t x1799 = -1;
  	int32_t t167 = -24528;
  
      t167 = ((x1797*x1798)%(x1799<=x1800));
  
      if (t167 != 0) { NG(); } else { ; }
  	
  }
  
  void f168(void) {
      	int64_t x1801 = 19583589LL;
  	int16_t x1802 = INT16_MIN;
  	uint64_t x1803 = 422LLU;
  	static int64_t x1804 = INT64_MIN;
  
      t168 = ((x1801*x1802)%(x1803<=x1804));
  
      if (t168 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f169(void) {
      	uint64_t x1809 = 15392991300250LLU;
  	int16_t x1810 = INT16_MAX;
  	int32_t x1811 = -1;
  	volatile int8_t x1812 = INT8_MAX;
  	volatile uint64_t t169 = 363280LLU;
  
      t169 = ((x1809*x1810)%(x1811<=x1812));
  
      if (t169 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f170(void) {
      	uint8_t x1814 = UINT8_MAX;
  	static int32_t x1815 = INT32_MIN;
  	static int8_t x1816 = INT8_MAX;
  
      t170 = ((x1813*x1814)%(x1815<=x1816));
  
      if (t170 != 0) { NG(); } else { ; }
  	
  }
  
  void f171(void) {
      	int64_t x1830 = -1LL;
  	int16_t x1831 = INT16_MIN;
  	static int64_t t171 = -423548433293LL;
  
      t171 = ((x1829*x1830)%(x1831<=x1832));
  
      if (t171 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f172(void) {
      	uint32_t x1833 = UINT32_MAX;
  	uint8_t x1834 = UINT8_MAX;
  	static uint32_t t172 = 88286U;
  
      t172 = ((x1833*x1834)%(x1835<=x1836));
  
      if (t172 != 0U) { NG(); } else { ; }
  	
  }
  
  void f173(void) {
      	int64_t x1837 = INT64_MAX;
  	uint64_t x1838 = UINT64_MAX;
  	uint64_t x1839 = 458LLU;
  	volatile int8_t x1840 = INT8_MIN;
  	uint64_t t173 = 1416958328318280LLU;
  
      t173 = ((x1837*x1838)%(x1839<=x1840));
  
      if (t173 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f174(void) {
      	static uint32_t x1841 = 14221U;
  	int32_t x1842 = INT32_MIN;
  	static int16_t x1843 = INT16_MIN;
  	int16_t x1844 = INT16_MIN;
  
      t174 = ((x1841*x1842)%(x1843<=x1844));
  
      if (t174 != 0U) { NG(); } else { ; }
  	
  }
  
  void f175(void) {
      	int16_t x1850 = -1;
  	int64_t x1851 = INT64_MIN;
  	int16_t x1852 = 1;
  	int32_t t175 = -929;
  
      t175 = ((x1849*x1850)%(x1851<=x1852));
  
      if (t175 != 0) { NG(); } else { ; }
  	
  }
  
  void f176(void) {
      	int16_t x1857 = 113;
  	static int32_t x1859 = 24332274;
  	volatile int64_t t176 = -333431626880205805LL;
  
      t176 = ((x1857*x1858)%(x1859<=x1860));
  
      if (t176 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f177(void) {
      	static int16_t x1865 = INT16_MIN;
  	volatile int64_t x1866 = 7976949310LL;
  	static int8_t x1867 = INT8_MIN;
  	volatile int64_t t177 = -599825271929030LL;
  
      t177 = ((x1865*x1866)%(x1867<=x1868));
  
      if (t177 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f178(void) {
      	int64_t x1877 = INT64_MAX;
  	volatile int64_t x1879 = INT64_MIN;
  	int64_t x1880 = INT64_MIN;
  	int64_t t178 = 537138486716LL;
  
      t178 = ((x1877*x1878)%(x1879<=x1880));
  
      if (t178 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f179(void) {
      	volatile uint64_t x1881 = UINT64_MAX;
  	volatile int64_t x1882 = INT64_MAX;
  	int8_t x1883 = -25;
  	uint8_t x1884 = UINT8_MAX;
  	volatile uint64_t t179 = 2235804LLU;
  
      t179 = ((x1881*x1882)%(x1883<=x1884));
  
      if (t179 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f180(void) {
      	static uint16_t x1897 = 12U;
  	static int64_t x1899 = INT64_MIN;
  	int16_t x1900 = INT16_MIN;
  	static int64_t t180 = 0LL;
  
      t180 = ((x1897*x1898)%(x1899<=x1900));
  
      if (t180 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f181(void) {
      	uint32_t x1901 = UINT32_MAX;
  	static int64_t x1902 = 0LL;
  	volatile uint8_t x1903 = 0U;
  	uint64_t x1904 = UINT64_MAX;
  
      t181 = ((x1901*x1902)%(x1903<=x1904));
  
      if (t181 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f182(void) {
      	int16_t x1909 = 4;
  	int16_t x1910 = INT16_MIN;
  	volatile int8_t x1911 = INT8_MIN;
  	int32_t t182 = 101771956;
  
      t182 = ((x1909*x1910)%(x1911<=x1912));
  
      if (t182 != 0) { NG(); } else { ; }
  	
  }
  
  void f183(void) {
      	int64_t x1917 = 0LL;
  	static int8_t x1918 = INT8_MIN;
  	uint64_t x1919 = 86908LLU;
  	int64_t x1920 = INT64_MIN;
  
      t183 = ((x1917*x1918)%(x1919<=x1920));
  
      if (t183 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f184(void) {
      	static volatile uint32_t x1929 = 13069498U;
  	int16_t x1930 = -15;
  	uint16_t x1931 = 6791U;
  	volatile int32_t x1932 = INT32_MAX;
  
      t184 = ((x1929*x1930)%(x1931<=x1932));
  
      if (t184 != 0U) { NG(); } else { ; }
  	
  }
  
  void f185(void) {
      	uint8_t x1937 = 0U;
  	static volatile uint64_t x1938 = 722205343785104496LLU;
  	volatile int16_t x1939 = -1;
  	uint64_t x1940 = UINT64_MAX;
  
      t185 = ((x1937*x1938)%(x1939<=x1940));
  
      if (t185 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f186(void) {
      	static uint16_t x1941 = UINT16_MAX;
  	static int8_t x1942 = INT8_MIN;
  	int32_t x1943 = INT32_MAX;
  	static volatile int32_t x1944 = INT32_MAX;
  	volatile int32_t t186 = 77879773;
  
      t186 = ((x1941*x1942)%(x1943<=x1944));
  
      if (t186 != 0) { NG(); } else { ; }
  	
  }
  
  void f187(void) {
      	volatile uint8_t x1969 = 27U;
  	volatile int32_t x1970 = -1;
  	int32_t x1971 = INT32_MIN;
  	uint16_t x1972 = UINT16_MAX;
  	int32_t t187 = 3;
  
      t187 = ((x1969*x1970)%(x1971<=x1972));
  
      if (t187 != 0) { NG(); } else { ; }
  	
  }
  
  void f188(void) {
      	uint16_t x1997 = 106U;
  	static volatile uint16_t x1998 = UINT16_MAX;
  	int64_t x1999 = INT64_MIN;
  	int32_t x2000 = -1;
  	volatile int32_t t188 = 119;
  
      t188 = ((x1997*x1998)%(x1999<=x2000));
  
      if (t188 != 0) { NG(); } else { ; }
  	
  }
  
  void f189(void) {
      	uint64_t x2033 = 927959780LLU;
  	int32_t x2034 = -1;
  	static uint8_t x2035 = 60U;
  	volatile uint64_t t189 = 180757690LLU;
  
      t189 = ((x2033*x2034)%(x2035<=x2036));
  
      if (t189 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f190(void) {
      	static uint64_t x2053 = UINT64_MAX;
  	volatile int16_t x2055 = -5;
  	uint8_t x2056 = 1U;
  	uint64_t t190 = 855LLU;
  
      t190 = ((x2053*x2054)%(x2055<=x2056));
  
      if (t190 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f191(void) {
      	volatile int16_t x2073 = -1;
  	static int8_t x2074 = INT8_MAX;
  	uint16_t x2075 = 25U;
  	int32_t t191 = -277377978;
  
      t191 = ((x2073*x2074)%(x2075<=x2076));
  
      if (t191 != 0) { NG(); } else { ; }
  	
  }
  
  void f192(void) {
      	int32_t x2086 = INT32_MIN;
  	uint16_t x2087 = UINT16_MAX;
  	static volatile uint32_t x2088 = UINT32_MAX;
  	volatile int64_t t192 = -17395955540842LL;
  
      t192 = ((x2085*x2086)%(x2087<=x2088));
  
      if (t192 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f193(void) {
      	int8_t x2097 = INT8_MIN;
  	int32_t x2098 = -1;
  	int64_t x2099 = -533753354599322166LL;
  	static int64_t x2100 = -1LL;
  	static int32_t t193 = -227008;
  
      t193 = ((x2097*x2098)%(x2099<=x2100));
  
      if (t193 != 0) { NG(); } else { ; }
  	
  }
  
  void f194(void) {
      	int64_t x2101 = -237LL;
  	int8_t x2102 = INT8_MAX;
  	static int64_t x2104 = INT64_MAX;
  	volatile int64_t t194 = 16470896767LL;
  
      t194 = ((x2101*x2102)%(x2103<=x2104));
  
      if (t194 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f195(void) {
      	int16_t x2109 = -1;
  	int64_t x2110 = INT64_MAX;
  	uint16_t x2111 = 9U;
  	static int8_t x2112 = 10;
  
      t195 = ((x2109*x2110)%(x2111<=x2112));
  
      if (t195 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f196(void) {
      	uint32_t x2117 = 790U;
  	volatile uint16_t x2118 = UINT16_MAX;
  	int32_t x2119 = -1;
  	int32_t x2120 = 861143;
  	volatile uint32_t t196 = 36766759U;
  
      t196 = ((x2117*x2118)%(x2119<=x2120));
  
      if (t196 != 0U) { NG(); } else { ; }
  	
  }
  
  void f197(void) {
      	volatile int32_t x2129 = -264996;
  	volatile int8_t x2130 = -57;
  	volatile uint32_t x2131 = 0U;
  	uint32_t x2132 = UINT32_MAX;
  	int32_t t197 = 7047;
  
      t197 = ((x2129*x2130)%(x2131<=x2132));
  
      if (t197 != 0) { NG(); } else { ; }
  	
  }
  
  void f198(void) {
      	int8_t x2145 = -1;
  	static int8_t x2146 = INT8_MIN;
  	int64_t x2147 = -1LL;
  	static uint8_t x2148 = 0U;
  	volatile int32_t t198 = 97222;
  
      t198 = ((x2145*x2146)%(x2147<=x2148));
  
      if (t198 != 0) { NG(); } else { ; }
  	
  }
  
  void f199(void) {
      	static int64_t x2157 = INT64_MIN;
  	static uint64_t x2159 = 30LLU;
  	static uint32_t x2160 = 1265U;
  	uint64_t t199 = 17509LLU;
  
      t199 = ((x2157*x2158)%(x2159<=x2160));
  
      if (t199 != 0LLU) { 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;
  }
  
  