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"
  
  volatile int64_t x5 = INT64_MIN;
  uint8_t x6 = UINT8_MAX;
  uint16_t x20 = 0U;
  uint64_t x25 = 999563385960167LLU;
  volatile uint64_t t2 = 1747374776855929729LLU;
  int16_t x51 = -1;
  uint64_t x98 = 3LLU;
  static volatile int64_t x100 = 0LL;
  uint32_t x220 = 7U;
  volatile int32_t t5 = 1458996;
  uint8_t x617 = UINT8_MAX;
  int64_t x823 = 319031LL;
  int16_t x825 = INT16_MAX;
  uint32_t x828 = 14U;
  int64_t x966 = INT64_MIN;
  static int16_t x967 = 0;
  static int8_t x1087 = INT8_MIN;
  volatile int16_t x1238 = -26;
  int32_t x1273 = -1;
  volatile uint8_t x1276 = 5U;
  int8_t x1284 = 14;
  volatile int8_t x1306 = INT8_MAX;
  static volatile uint8_t x1308 = 21U;
  uint32_t x1562 = 39U;
  uint16_t x1581 = 1246U;
  int8_t x1583 = -37;
  int32_t t23 = -8592594;
  static uint64_t t24 = 2567113606150LLU;
  uint32_t x1820 = 18U;
  static volatile uint32_t t26 = 30396593U;
  int8_t x1988 = 10;
  uint32_t t28 = 144253083U;
  uint64_t x2191 = UINT64_MAX;
  volatile uint16_t x2243 = UINT16_MAX;
  static uint64_t t31 = 95320947LLU;
  volatile uint64_t t32 = 67922117LLU;
  uint64_t x2349 = 2243086819608583LLU;
  uint32_t x2421 = 23050U;
  static int16_t x2423 = INT16_MAX;
  uint8_t x2424 = 0U;
  uint32_t x2466 = 943812865U;
  int8_t x2579 = INT8_MAX;
  static volatile uint64_t t38 = 1063886642508554LLU;
  int16_t x2653 = 0;
  int32_t x2655 = -581158;
  static uint16_t x2656 = 7U;
  volatile int64_t t40 = -29541LL;
  volatile uint64_t t42 = 223105131LLU;
  uint16_t x2888 = 2U;
  static uint64_t x3189 = UINT64_MAX;
  uint64_t x3190 = UINT64_MAX;
  uint16_t x3191 = 7747U;
  volatile int16_t x3211 = -111;
  uint64_t t49 = 6347691988LLU;
  uint32_t x3603 = 0U;
  static volatile int16_t x3711 = -1;
  static uint8_t x3736 = 14U;
  uint32_t t55 = 66U;
  static int64_t x3971 = 776718LL;
  volatile uint32_t x4016 = 8U;
  volatile uint32_t t62 = 4640766U;
  static int32_t x4231 = -1;
  int64_t t66 = 4LL;
  static volatile uint64_t t67 = 51165305406114LLU;
  uint16_t x4439 = 62U;
  int8_t x4471 = INT8_MIN;
  static int16_t x4484 = 1;
  static int32_t t72 = 226;
  uint8_t x4521 = UINT8_MAX;
  volatile uint64_t x4523 = 9763483409586190LLU;
  volatile uint64_t t73 = 80581817940514689LLU;
  uint32_t x4527 = 1U;
  int64_t x4528 = 6LL;
  static int16_t x5120 = 1;
  uint64_t x5175 = UINT64_MAX;
  static uint64_t t81 = 501006531LLU;
  int64_t x5201 = INT64_MAX;
  static volatile int16_t x5203 = INT16_MAX;
  volatile uint64_t x5276 = 32LLU;
  int64_t t83 = -5LL;
  int64_t x5450 = -1LL;
  int64_t x5483 = -1LL;
  int32_t x5553 = -1;
  volatile int64_t x5594 = 58080987925LL;
  volatile int64_t t87 = -534657001345127LL;
  int16_t x5617 = 104;
  uint8_t x5620 = 11U;
  volatile int32_t t88 = -134378053;
  uint32_t x5753 = 295749U;
  uint8_t x5754 = 1U;
  int16_t x5921 = INT16_MAX;
  uint64_t t92 = 79334935955LLU;
  volatile uint64_t t93 = 98035752321780640LLU;
  uint32_t x6080 = 1U;
  volatile int32_t t96 = -43;
  static volatile int16_t x6085 = -14;
  int8_t x6086 = 19;
  volatile uint16_t x6088 = 3U;
  volatile uint64_t t98 = 22617648667772LLU;
  uint8_t x6209 = 0U;
  uint16_t x6223 = UINT16_MAX;
  int8_t x6295 = 55;
  volatile uint8_t x6442 = UINT8_MAX;
  int64_t t104 = -5LL;
  uint8_t x6622 = UINT8_MAX;
  volatile uint32_t t107 = 310353682U;
  uint64_t x6761 = 177972903169286LLU;
  volatile int32_t x6762 = INT32_MAX;
  static int32_t x6763 = 1;
  int8_t x6849 = INT8_MAX;
  static int16_t x6936 = 14;
  static int8_t x6953 = INT8_MIN;
  static int8_t x6956 = 3;
  volatile uint64_t t111 = 5962964730LLU;
  int8_t x7034 = -1;
  uint64_t x7054 = 198794591194106LLU;
  uint64_t x7061 = UINT64_MAX;
  static volatile int64_t t115 = 2008048LL;
  int32_t x7212 = 0;
  static int32_t x7317 = -1;
  int8_t x7454 = 1;
  uint8_t x7456 = 7U;
  volatile uint64_t t120 = 19484LLU;
  static int16_t x7478 = INT16_MIN;
  int64_t x7479 = -1LL;
  uint8_t x7489 = UINT8_MAX;
  static int8_t x7491 = -1;
  uint64_t x7492 = 7LLU;
  static int16_t x7538 = -1;
  uint8_t x7624 = 1U;
  int16_t x7662 = INT16_MAX;
  int32_t x7664 = 0;
  static volatile uint64_t x7673 = 8570548883662LLU;
  uint32_t x7674 = 5693843U;
  uint64_t t127 = 799157420963563120LLU;
  static volatile uint8_t x7688 = 5U;
  int16_t x7765 = INT16_MAX;
  int16_t x7767 = INT16_MAX;
  static uint8_t x7768 = 2U;
  int64_t x7999 = 16862125030LL;
  int64_t x8034 = -1LL;
  static volatile int32_t x8036 = 0;
  int64_t x8060 = 11LL;
  volatile int8_t x8144 = 7;
  static int64_t x8154 = -1LL;
  volatile uint8_t x8156 = 11U;
  volatile uint64_t x8162 = UINT64_MAX;
  volatile int8_t x8164 = 1;
  static volatile uint64_t t138 = 1075996402LLU;
  int64_t x8409 = 946440LL;
  static uint16_t x8453 = 5U;
  static uint64_t x8591 = 617972097LLU;
  int16_t x8697 = INT16_MIN;
  volatile int16_t x8699 = INT16_MAX;
  static int64_t x8704 = 25LL;
  int32_t x8803 = INT32_MIN;
  uint32_t x8905 = 7U;
  int64_t x9021 = -1LL;
  int8_t x9037 = INT8_MIN;
  uint64_t t152 = 557667LLU;
  int64_t x9209 = 34LL;
  int32_t x9211 = INT32_MIN;
  static int8_t x9321 = 9;
  uint32_t x9342 = 14205U;
  static int32_t x9343 = INT32_MAX;
  int16_t x9399 = -1;
  uint16_t x9471 = 62U;
  volatile int32_t t158 = -211588828;
  uint16_t x9505 = UINT16_MAX;
  volatile uint16_t x9549 = UINT16_MAX;
  static uint8_t x9550 = 21U;
  static volatile int32_t t161 = 46511;
  volatile uint64_t x9815 = UINT64_MAX;
  int16_t x9832 = 46;
  int16_t x10041 = -30;
  volatile uint8_t x10206 = 10U;
  uint64_t x10207 = 682446756901LLU;
  static int16_t x10251 = -1;
  uint8_t x10392 = 44U;
  uint64_t x10685 = 14771245LLU;
  int32_t x10829 = -1;
  uint32_t t177 = 8688234U;
  uint8_t x10864 = 0U;
  uint64_t t178 = 27790684LLU;
  uint8_t x10927 = UINT8_MAX;
  int32_t x11057 = -1;
  int16_t x11127 = 295;
  uint64_t x11164 = 0LLU;
  int32_t x11187 = -490;
  volatile uint16_t x11313 = UINT16_MAX;
  uint16_t x11314 = 102U;
  static volatile int16_t x11370 = INT16_MIN;
  uint32_t x11444 = 16U;
  uint32_t x11482 = UINT32_MAX;
  uint16_t x11484 = 0U;
  volatile uint32_t t192 = 2948U;
  volatile uint64_t t193 = 34983785564LLU;
  uint64_t x11540 = 11LLU;
  uint16_t x11635 = 104U;
  int32_t t195 = 49735404;
  int16_t x11666 = INT16_MIN;
  static int64_t x11667 = -1LL;
  uint64_t x11895 = UINT64_MAX;
  int32_t x11896 = 0;
  static int32_t x11922 = 0;
  static int32_t x11923 = INT32_MAX;
  static volatile int32_t x11924 = 2;
  int64_t x11941 = INT64_MIN;
  uint64_t x11942 = UINT64_MAX;
  static volatile int64_t x11943 = INT64_MIN;
  volatile uint64_t t199 = 14258LLU;
  
  
  void f0(void) {
      	static uint64_t x7 = 131744456524918LLU;
  	static volatile uint16_t x8 = 25U;
  	volatile uint64_t t0 = 1LLU;
  
      t0 = ((x5+(x6*x7))<<x8);
  
      if (t0 != 12017143547640676352LLU) { NG(); } else { ; }
  	
  }
  
  void f1(void) {
      	volatile int32_t x17 = -47946317;
  	int64_t x18 = 81709605647519LL;
  	int8_t x19 = 1;
  	volatile int64_t t1 = 223LL;
  
      t1 = ((x17+(x18*x19))<<x20);
  
      if (t1 != 81709557701202LL) { NG(); } else { ; }
  	
  }
  
  void f2(void) {
      	int16_t x26 = -6;
  	int8_t x27 = 1;
  	static volatile uint16_t x28 = 1U;
  
      t2 = ((x25+(x26*x27))<<x28);
  
      if (t2 != 1999126771920322LLU) { NG(); } else { ; }
  	
  }
  
  void f3(void) {
      	volatile int32_t x49 = INT32_MAX;
  	uint64_t x50 = 319878948042LLU;
  	uint16_t x52 = 0U;
  	volatile uint64_t t3 = 911542281806999LLU;
  
      t3 = ((x49+(x50*x51))<<x52);
  
      if (t3 != 18446743755978087221LLU) { NG(); } else { ; }
  	
  }
  
  void f4(void) {
      	static int32_t x97 = INT32_MAX;
  	uint16_t x99 = UINT16_MAX;
  	static volatile uint64_t t4 = 34929723429839345LLU;
  
      t4 = ((x97+(x98*x99))<<x100);
  
      if (t4 != 2147680252LLU) { NG(); } else { ; }
  	
  }
  
  void f5(void) {
      	volatile int16_t x217 = INT16_MIN;
  	volatile int8_t x218 = -2;
  	int16_t x219 = INT16_MIN;
  
      t5 = ((x217+(x218*x219))<<x220);
  
      if (t5 != 4194304) { NG(); } else { ; }
  	
  }
  
  void f6(void) {
      	int32_t x285 = -1;
  	int16_t x286 = INT16_MIN;
  	uint64_t x287 = UINT64_MAX;
  	int16_t x288 = 1;
  	uint64_t t6 = 5LLU;
  
      t6 = ((x285+(x286*x287))<<x288);
  
      if (t6 != 65534LLU) { NG(); } else { ; }
  	
  }
  
  void f7(void) {
      	static int16_t x365 = INT16_MAX;
  	int16_t x366 = -1;
  	int8_t x367 = INT8_MIN;
  	static int16_t x368 = 10;
  	int32_t t7 = -1830321;
  
      t7 = ((x365+(x366*x367))<<x368);
  
      if (t7 != 33684480) { NG(); } else { ; }
  	
  }
  
  void f8(void) {
      	uint64_t x618 = UINT64_MAX;
  	int32_t x619 = INT32_MIN;
  	uint16_t x620 = 5U;
  	uint64_t t8 = 1889779LLU;
  
      t8 = ((x617+(x618*x619))<<x620);
  
      if (t8 != 68719484896LLU) { NG(); } else { ; }
  	
  }
  
  void f9(void) {
      	static uint8_t x721 = UINT8_MAX;
  	volatile int8_t x722 = 1;
  	static volatile int64_t x723 = -1LL;
  	static uint32_t x724 = 5U;
  	volatile int64_t t9 = 192409168791812LL;
  
      t9 = ((x721+(x722*x723))<<x724);
  
      if (t9 != 8128LL) { NG(); } else { ; }
  	
  }
  
  void f10(void) {
      	uint64_t x821 = 10LLU;
  	volatile int16_t x822 = -1;
  	int8_t x824 = 0;
  	static uint64_t t10 = 227042970868LLU;
  
      t10 = ((x821+(x822*x823))<<x824);
  
      if (t10 != 18446744073709232595LLU) { NG(); } else { ; }
  	
  }
  
  void f11(void) {
      	uint32_t x826 = 248698770U;
  	uint64_t x827 = 5189350169103628LLU;
  	uint64_t t11 = 684479279241085243LLU;
  
      t11 = ((x825+(x826*x827))<<x828);
  
      if (t11 != 8843203234839773184LLU) { NG(); } else { ; }
  	
  }
  
  void f12(void) {
      	uint32_t x845 = 13U;
  	uint32_t x846 = 5U;
  	volatile uint16_t x847 = UINT16_MAX;
  	volatile int8_t x848 = 8;
  	volatile uint32_t t12 = 712U;
  
      t12 = ((x845+(x846*x847))<<x848);
  
      if (t12 != 83888128U) { NG(); } else { ; }
  	
  }
  
  void f13(void) {
      	int8_t x965 = 1;
  	static int32_t x968 = 1;
  	int64_t t13 = 64553LL;
  
      t13 = ((x965+(x966*x967))<<x968);
  
      if (t13 != 2LL) { NG(); } else { ; }
  	
  }
  
  void f14(void) {
      	volatile int8_t x1085 = INT8_MIN;
  	int8_t x1086 = INT8_MIN;
  	volatile int16_t x1088 = 1;
  	static int32_t t14 = -404;
  
      t14 = ((x1085+(x1086*x1087))<<x1088);
  
      if (t14 != 32512) { NG(); } else { ; }
  	
  }
  
  void f15(void) {
      	static uint16_t x1093 = UINT16_MAX;
  	uint32_t x1094 = 2740U;
  	static int32_t x1095 = 1;
  	static uint16_t x1096 = 3U;
  	volatile uint32_t t15 = 1U;
  
      t15 = ((x1093+(x1094*x1095))<<x1096);
  
      if (t15 != 546200U) { NG(); } else { ; }
  	
  }
  
  void f16(void) {
      	int64_t x1237 = 13891091989270LL;
  	volatile int32_t x1239 = 535287;
  	int8_t x1240 = 1;
  	volatile int64_t t16 = 5589LL;
  
      t16 = ((x1237+(x1238*x1239))<<x1240);
  
      if (t16 != 27782156143616LL) { NG(); } else { ; }
  	
  }
  
  void f17(void) {
      	uint32_t x1274 = 7178656U;
  	static int16_t x1275 = 0;
  	volatile uint32_t t17 = 65308U;
  
      t17 = ((x1273+(x1274*x1275))<<x1276);
  
      if (t17 != 4294967264U) { NG(); } else { ; }
  	
  }
  
  void f18(void) {
      	int64_t x1281 = -2943961695LL;
  	int16_t x1282 = 12;
  	static uint64_t x1283 = UINT64_MAX;
  	volatile uint64_t t18 = 39396704LLU;
  
      t18 = ((x1281+(x1282*x1283))<<x1284);
  
      if (t18 != 18446695839840944128LLU) { NG(); } else { ; }
  	
  }
  
  void f19(void) {
      	int16_t x1305 = INT16_MIN;
  	uint32_t x1307 = 389U;
  	volatile uint32_t t19 = 914379874U;
  
      t19 = ((x1305+(x1306*x1307))<<x1308);
  
      if (t19 != 526385152U) { NG(); } else { ; }
  	
  }
  
  void f20(void) {
      	int8_t x1405 = INT8_MIN;
  	int16_t x1406 = INT16_MIN;
  	uint32_t x1407 = 375033U;
  	static int8_t x1408 = 9;
  	volatile uint32_t t20 = 208002619U;
  
      t20 = ((x1405+(x1406*x1407))<<x1408);
  
      if (t20 != 117374976U) { NG(); } else { ; }
  	
  }
  
  void f21(void) {
      	int8_t x1553 = INT8_MIN;
  	uint32_t x1554 = UINT32_MAX;
  	volatile uint16_t x1555 = UINT16_MAX;
  	uint16_t x1556 = 2U;
  	uint32_t t21 = 379676819U;
  
      t21 = ((x1553+(x1554*x1555))<<x1556);
  
      if (t21 != 4294704644U) { NG(); } else { ; }
  	
  }
  
  void f22(void) {
      	volatile int8_t x1561 = -63;
  	int8_t x1563 = INT8_MIN;
  	int16_t x1564 = 3;
  	volatile uint32_t t22 = 863U;
  
      t22 = ((x1561+(x1562*x1563))<<x1564);
  
      if (t22 != 4294926856U) { NG(); } else { ; }
  	
  }
  
  void f23(void) {
      	uint16_t x1582 = 31U;
  	int8_t x1584 = 1;
  
      t23 = ((x1581+(x1582*x1583))<<x1584);
  
      if (t23 != 198) { NG(); } else { ; }
  	
  }
  
  void f24(void) {
      	uint16_t x1685 = 9371U;
  	uint64_t x1686 = UINT64_MAX;
  	static int8_t x1687 = -5;
  	volatile int8_t x1688 = 0;
  
      t24 = ((x1685+(x1686*x1687))<<x1688);
  
      if (t24 != 9376LLU) { NG(); } else { ; }
  	
  }
  
  void f25(void) {
      	uint64_t x1817 = 12877507804082432LLU;
  	uint8_t x1818 = 28U;
  	int8_t x1819 = 5;
  	uint64_t t25 = 6705902LLU;
  
      t25 = ((x1817+(x1818*x1819))<<x1820);
  
      if (t25 != 7240304573808640LLU) { NG(); } else { ; }
  	
  }
  
  void f26(void) {
      	int16_t x1897 = -1;
  	uint32_t x1898 = UINT32_MAX;
  	int8_t x1899 = -1;
  	uint8_t x1900 = 14U;
  
      t26 = ((x1897+(x1898*x1899))<<x1900);
  
      if (t26 != 0U) { NG(); } else { ; }
  	
  }
  
  void f27(void) {
      	volatile int16_t x1981 = INT16_MIN;
  	volatile int16_t x1982 = INT16_MIN;
  	static volatile uint64_t x1983 = 65LLU;
  	int8_t x1984 = 0;
  	uint64_t t27 = 55840446791414317LLU;
  
      t27 = ((x1981+(x1982*x1983))<<x1984);
  
      if (t27 != 18446744073707388928LLU) { NG(); } else { ; }
  	
  }
  
  void f28(void) {
      	int32_t x1985 = INT32_MAX;
  	uint32_t x1986 = UINT32_MAX;
  	static int16_t x1987 = -1;
  
      t28 = ((x1985+(x1986*x1987))<<x1988);
  
      if (t28 != 0U) { NG(); } else { ; }
  	
  }
  
  void f29(void) {
      	int32_t x2129 = INT32_MAX;
  	uint64_t x2130 = UINT64_MAX;
  	volatile uint8_t x2131 = 10U;
  	static volatile uint8_t x2132 = 15U;
  	uint64_t t29 = 2002828LLU;
  
      t29 = ((x2129+(x2130*x2131))<<x2132);
  
      if (t29 != 70368743817216LLU) { NG(); } else { ; }
  	
  }
  
  void f30(void) {
      	static int32_t x2189 = INT32_MAX;
  	int32_t x2190 = -105565812;
  	uint16_t x2192 = 6U;
  	uint64_t t30 = 3365941633459019877LLU;
  
      t30 = ((x2189+(x2190*x2191))<<x2192);
  
      if (t30 != 144195165376LLU) { NG(); } else { ; }
  	
  }
  
  void f31(void) {
      	static int16_t x2241 = -1;
  	volatile uint64_t x2242 = 26969249686766LLU;
  	volatile uint32_t x2244 = 4U;
  
      t31 = ((x2241+(x2242*x2243))<<x2244);
  
      if (t31 != 9832132377845805328LLU) { NG(); } else { ; }
  	
  }
  
  void f32(void) {
      	int16_t x2245 = -1;
  	volatile uint64_t x2246 = 37717014788093970LLU;
  	int8_t x2247 = 1;
  	static int32_t x2248 = 16;
  
      t32 = ((x2245+(x2246*x2247))<<x2248);
  
      if (t32 != 18405319349155987456LLU) { NG(); } else { ; }
  	
  }
  
  void f33(void) {
      	uint8_t x2253 = UINT8_MAX;
  	int8_t x2254 = INT8_MIN;
  	uint64_t x2255 = UINT64_MAX;
  	uint8_t x2256 = 0U;
  	volatile uint64_t t33 = 3720LLU;
  
      t33 = ((x2253+(x2254*x2255))<<x2256);
  
      if (t33 != 383LLU) { NG(); } else { ; }
  	
  }
  
  void f34(void) {
      	static uint8_t x2350 = 29U;
  	static uint64_t x2351 = 6845807215LLU;
  	uint8_t x2352 = 32U;
  	uint64_t t34 = 53711LLU;
  
      t34 = ((x2349+(x2350*x2351))<<x2352);
  
      if (t34 != 10541913639378485248LLU) { NG(); } else { ; }
  	
  }
  
  void f35(void) {
      	int64_t x2422 = 785898780LL;
  	int64_t t35 = 0LL;
  
      t35 = ((x2421+(x2422*x2423))<<x2424);
  
      if (t35 != 25751545347310LL) { NG(); } else { ; }
  	
  }
  
  void f36(void) {
      	int64_t x2465 = 1282710368462LL;
  	volatile uint16_t x2467 = 2U;
  	uint8_t x2468 = 3U;
  	volatile int64_t t36 = -5102205457LL;
  
      t36 = ((x2465+(x2466*x2467))<<x2468);
  
      if (t36 != 10276783953536LL) { NG(); } else { ; }
  	
  }
  
  void f37(void) {
      	int8_t x2517 = INT8_MIN;
  	int16_t x2518 = INT16_MAX;
  	int8_t x2519 = INT8_MAX;
  	static uint32_t x2520 = 5U;
  	static volatile int32_t t37 = 15599756;
  
      t37 = ((x2517+(x2518*x2519))<<x2520);
  
      if (t37 != 133160992) { NG(); } else { ; }
  	
  }
  
  void f38(void) {
      	uint64_t x2577 = UINT64_MAX;
  	int8_t x2578 = 1;
  	volatile uint16_t x2580 = 1U;
  
      t38 = ((x2577+(x2578*x2579))<<x2580);
  
      if (t38 != 252LLU) { NG(); } else { ; }
  	
  }
  
  void f39(void) {
      	static int16_t x2654 = -2;
  	int32_t t39 = -1788;
  
      t39 = ((x2653+(x2654*x2655))<<x2656);
  
      if (t39 != 148776448) { NG(); } else { ; }
  	
  }
  
  void f40(void) {
      	uint8_t x2673 = 3U;
  	uint8_t x2674 = 1U;
  	int64_t x2675 = 13771741LL;
  	static int16_t x2676 = 3;
  
      t40 = ((x2673+(x2674*x2675))<<x2676);
  
      if (t40 != 110173952LL) { NG(); } else { ; }
  	
  }
  
  void f41(void) {
      	static volatile int16_t x2729 = -20;
  	static uint16_t x2730 = 8760U;
  	uint64_t x2731 = UINT64_MAX;
  	uint8_t x2732 = 1U;
  	uint64_t t41 = 1265LLU;
  
      t41 = ((x2729+(x2730*x2731))<<x2732);
  
      if (t41 != 18446744073709534056LLU) { NG(); } else { ; }
  	
  }
  
  void f42(void) {
      	volatile int16_t x2737 = INT16_MIN;
  	uint64_t x2738 = 6520LLU;
  	volatile uint64_t x2739 = 615041443502722LLU;
  	static volatile int32_t x2740 = 1;
  
      t42 = ((x2737+(x2738*x2739))<<x2740);
  
      if (t42 != 8020140423275429344LLU) { NG(); } else { ; }
  	
  }
  
  void f43(void) {
      	uint8_t x2785 = 15U;
  	int32_t x2786 = -708;
  	int16_t x2787 = INT16_MIN;
  	uint8_t x2788 = 0U;
  	int32_t t43 = 1207932;
  
      t43 = ((x2785+(x2786*x2787))<<x2788);
  
      if (t43 != 23199759) { NG(); } else { ; }
  	
  }
  
  void f44(void) {
      	static int8_t x2861 = INT8_MAX;
  	uint16_t x2862 = 868U;
  	int8_t x2863 = 25;
  	static int32_t x2864 = 1;
  	int32_t t44 = 103;
  
      t44 = ((x2861+(x2862*x2863))<<x2864);
  
      if (t44 != 43654) { NG(); } else { ; }
  	
  }
  
  void f45(void) {
      	int64_t x2885 = -1LL;
  	uint16_t x2886 = 45U;
  	uint64_t x2887 = 15188184LLU;
  	uint64_t t45 = 1227563667260LLU;
  
      t45 = ((x2885+(x2886*x2887))<<x2888);
  
      if (t45 != 2733873116LLU) { NG(); } else { ; }
  	
  }
  
  void f46(void) {
      	int8_t x2989 = INT8_MAX;
  	uint32_t x2990 = 4770U;
  	static int16_t x2991 = -12;
  	static int8_t x2992 = 0;
  	volatile uint32_t t46 = 209U;
  
      t46 = ((x2989+(x2990*x2991))<<x2992);
  
      if (t46 != 4294910183U) { NG(); } else { ; }
  	
  }
  
  void f47(void) {
      	static volatile int64_t x3173 = 68776206793075153LL;
  	volatile int8_t x3174 = INT8_MIN;
  	int64_t x3175 = 440193LL;
  	int16_t x3176 = 1;
  	volatile int64_t t47 = 1467053276LL;
  
      t47 = ((x3173+(x3174*x3175))<<x3176);
  
      if (t47 != 137552413473460898LL) { NG(); } else { ; }
  	
  }
  
  void f48(void) {
      	volatile uint16_t x3192 = 3U;
  	static volatile uint64_t t48 = 436LLU;
  
      t48 = ((x3189+(x3190*x3191))<<x3192);
  
      if (t48 != 18446744073709489632LLU) { NG(); } else { ; }
  	
  }
  
  void f49(void) {
      	volatile uint64_t x3209 = 11984LLU;
  	int16_t x3210 = -1;
  	uint16_t x3212 = 0U;
  
      t49 = ((x3209+(x3210*x3211))<<x3212);
  
      if (t49 != 12095LLU) { NG(); } else { ; }
  	
  }
  
  void f50(void) {
      	volatile int16_t x3601 = INT16_MIN;
  	uint8_t x3602 = 1U;
  	int8_t x3604 = 22;
  	uint32_t t50 = 406835378U;
  
      t50 = ((x3601+(x3602*x3603))<<x3604);
  
      if (t50 != 0U) { NG(); } else { ; }
  	
  }
  
  void f51(void) {
      	int16_t x3649 = 8534;
  	static int32_t x3650 = -1;
  	volatile int32_t x3651 = -1;
  	int8_t x3652 = 1;
  	int32_t t51 = -5173539;
  
      t51 = ((x3649+(x3650*x3651))<<x3652);
  
      if (t51 != 17070) { NG(); } else { ; }
  	
  }
  
  void f52(void) {
      	static uint64_t x3709 = UINT64_MAX;
  	volatile int64_t x3710 = 28377100LL;
  	static volatile int8_t x3712 = 1;
  	volatile uint64_t t52 = 10298218929098170LLU;
  
      t52 = ((x3709+(x3710*x3711))<<x3712);
  
      if (t52 != 18446744073652797414LLU) { NG(); } else { ; }
  	
  }
  
  void f53(void) {
      	uint32_t x3733 = 8U;
  	int8_t x3734 = 1;
  	static uint16_t x3735 = 7485U;
  	uint32_t t53 = 465102644U;
  
      t53 = ((x3733+(x3734*x3735))<<x3736);
  
      if (t53 != 122765312U) { NG(); } else { ; }
  	
  }
  
  void f54(void) {
      	uint64_t x3825 = 900733728LLU;
  	int8_t x3826 = -1;
  	int32_t x3827 = -1;
  	volatile uint8_t x3828 = 44U;
  	uint64_t t54 = 6326312LLU;
  
      t54 = ((x3825+(x3826*x3827))<<x3828);
  
      if (t54 != 122177732078469120LLU) { NG(); } else { ; }
  	
  }
  
  void f55(void) {
      	uint32_t x3933 = UINT32_MAX;
  	int16_t x3934 = INT16_MIN;
  	int16_t x3935 = INT16_MAX;
  	int8_t x3936 = 0;
  
      t55 = ((x3933+(x3934*x3935))<<x3936);
  
      if (t55 != 3221258239U) { NG(); } else { ; }
  	
  }
  
  void f56(void) {
      	int8_t x3953 = INT8_MIN;
  	uint64_t x3954 = UINT64_MAX;
  	static volatile int32_t x3955 = INT32_MAX;
  	int8_t x3956 = 58;
  	uint64_t t56 = 1969564452559373739LLU;
  
      t56 = ((x3953+(x3954*x3955))<<x3956);
  
      if (t56 != 288230376151711744LLU) { NG(); } else { ; }
  	
  }
  
  void f57(void) {
      	int32_t x3969 = INT32_MAX;
  	int8_t x3970 = 8;
  	int8_t x3972 = 1;
  	int64_t t57 = 601LL;
  
      t57 = ((x3969+(x3970*x3971))<<x3972);
  
      if (t57 != 4307394782LL) { NG(); } else { ; }
  	
  }
  
  void f58(void) {
      	static uint32_t x4001 = 92U;
  	volatile int16_t x4002 = INT16_MIN;
  	volatile uint8_t x4003 = UINT8_MAX;
  	static int16_t x4004 = 1;
  	uint32_t t58 = 2U;
  
      t58 = ((x4001+(x4002*x4003))<<x4004);
  
      if (t58 != 4278255800U) { NG(); } else { ; }
  	
  }
  
  void f59(void) {
      	volatile uint32_t x4013 = 700U;
  	int8_t x4014 = INT8_MAX;
  	static volatile int16_t x4015 = INT16_MIN;
  	volatile uint32_t t59 = 3454901U;
  
      t59 = ((x4013+(x4014*x4015))<<x4016);
  
      if (t59 != 3229793280U) { NG(); } else { ; }
  	
  }
  
  void f60(void) {
      	int8_t x4037 = -52;
  	static int16_t x4038 = INT16_MIN;
  	int8_t x4039 = -1;
  	uint64_t x4040 = 2LLU;
  	int32_t t60 = 12;
  
      t60 = ((x4037+(x4038*x4039))<<x4040);
  
      if (t60 != 130864) { NG(); } else { ; }
  	
  }
  
  void f61(void) {
      	uint32_t x4189 = UINT32_MAX;
  	static uint16_t x4190 = 1U;
  	static int64_t x4191 = -1LL;
  	int8_t x4192 = 6;
  	int64_t t61 = -11214981LL;
  
      t61 = ((x4189+(x4190*x4191))<<x4192);
  
      if (t61 != 274877906816LL) { NG(); } else { ; }
  	
  }
  
  void f62(void) {
      	static int8_t x4205 = 47;
  	uint32_t x4206 = 7U;
  	int8_t x4207 = INT8_MIN;
  	uint16_t x4208 = 25U;
  
      t62 = ((x4205+(x4206*x4207))<<x4208);
  
      if (t62 != 1577058304U) { NG(); } else { ; }
  	
  }
  
  void f63(void) {
      	static int32_t x4229 = INT32_MAX;
  	static int32_t x4230 = INT32_MAX;
  	uint16_t x4232 = 1U;
  	static volatile int32_t t63 = 3;
  
      t63 = ((x4229+(x4230*x4231))<<x4232);
  
      if (t63 != 0) { NG(); } else { ; }
  	
  }
  
  void f64(void) {
      	uint64_t x4241 = UINT64_MAX;
  	uint8_t x4242 = 11U;
  	uint32_t x4243 = UINT32_MAX;
  	int32_t x4244 = 3;
  	volatile uint64_t t64 = 2823385122366092446LLU;
  
      t64 = ((x4241+(x4242*x4243))<<x4244);
  
      if (t64 != 34359738272LLU) { NG(); } else { ; }
  	
  }
  
  void f65(void) {
      	int16_t x4273 = INT16_MAX;
  	volatile int32_t x4274 = -1;
  	int16_t x4275 = INT16_MAX;
  	static uint8_t x4276 = 0U;
  	volatile int32_t t65 = -1;
  
      t65 = ((x4273+(x4274*x4275))<<x4276);
  
      if (t65 != 0) { NG(); } else { ; }
  	
  }
  
  void f66(void) {
      	int64_t x4345 = 242001314LL;
  	uint16_t x4346 = 3832U;
  	uint16_t x4347 = UINT16_MAX;
  	uint8_t x4348 = 0U;
  
      t66 = ((x4345+(x4346*x4347))<<x4348);
  
      if (t66 != 493131434LL) { NG(); } else { ; }
  	
  }
  
  void f67(void) {
      	int32_t x4357 = -1;
  	volatile uint64_t x4358 = UINT64_MAX;
  	int8_t x4359 = -1;
  	static volatile uint16_t x4360 = 27U;
  
      t67 = ((x4357+(x4358*x4359))<<x4360);
  
      if (t67 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f68(void) {
      	uint8_t x4385 = 38U;
  	int64_t x4386 = -1LL;
  	int16_t x4387 = 1;
  	static volatile uint32_t x4388 = 0U;
  	int64_t t68 = -202LL;
  
      t68 = ((x4385+(x4386*x4387))<<x4388);
  
      if (t68 != 37LL) { NG(); } else { ; }
  	
  }
  
  void f69(void) {
      	uint64_t x4437 = 289029385LLU;
  	int8_t x4438 = INT8_MIN;
  	uint16_t x4440 = 32U;
  	uint64_t t69 = 4744LLU;
  
      t69 = ((x4437+(x4438*x4439))<<x4440);
  
      if (t69 != 1241337671297531904LLU) { NG(); } else { ; }
  	
  }
  
  void f70(void) {
      	int16_t x4449 = INT16_MAX;
  	static int8_t x4450 = INT8_MIN;
  	static volatile int8_t x4451 = -1;
  	static volatile int16_t x4452 = 0;
  	static volatile int32_t t70 = 0;
  
      t70 = ((x4449+(x4450*x4451))<<x4452);
  
      if (t70 != 32895) { NG(); } else { ; }
  	
  }
  
  void f71(void) {
      	uint64_t x4469 = 720960LLU;
  	volatile uint8_t x4470 = 25U;
  	uint64_t x4472 = 7LLU;
  	volatile uint64_t t71 = 1189619079234497LLU;
  
      t71 = ((x4469+(x4470*x4471))<<x4472);
  
      if (t71 != 91873280LLU) { NG(); } else { ; }
  	
  }
  
  void f72(void) {
      	static int16_t x4481 = -296;
  	static int16_t x4482 = INT16_MAX;
  	static int16_t x4483 = INT16_MAX;
  
      t72 = ((x4481+(x4482*x4483))<<x4484);
  
      if (t72 != 2147351986) { NG(); } else { ; }
  	
  }
  
  void f73(void) {
      	int32_t x4522 = INT32_MIN;
  	int8_t x4524 = 3;
  
      t73 = ((x4521+(x4522*x4523))<<x4524);
  
      if (t73 != 9108424452722395128LLU) { NG(); } else { ; }
  	
  }
  
  void f74(void) {
      	static volatile int8_t x4525 = INT8_MIN;
  	int8_t x4526 = INT8_MIN;
  	uint32_t t74 = 45747U;
  
      t74 = ((x4525+(x4526*x4527))<<x4528);
  
      if (t74 != 4294950912U) { NG(); } else { ; }
  	
  }
  
  void f75(void) {
      	volatile int32_t x4545 = -1;
  	int32_t x4546 = INT32_MIN;
  	static volatile uint64_t x4547 = 126182856LLU;
  	volatile int8_t x4548 = 0;
  	volatile uint64_t t75 = 47337033LLU;
  
      t75 = ((x4545+(x4546*x4547))<<x4548);
  
      if (t75 != 18175768453791612927LLU) { NG(); } else { ; }
  	
  }
  
  void f76(void) {
      	volatile uint32_t x4913 = 1348961560U;
  	int16_t x4914 = 77;
  	uint64_t x4915 = UINT64_MAX;
  	uint8_t x4916 = 57U;
  	volatile uint64_t t76 = 74592LLU;
  
      t76 = ((x4913+(x4914*x4915))<<x4916);
  
      if (t76 != 10808639105689190400LLU) { NG(); } else { ; }
  	
  }
  
  void f77(void) {
      	uint64_t x4985 = 436128LLU;
  	volatile uint64_t x4986 = UINT64_MAX;
  	int64_t x4987 = -1LL;
  	uint8_t x4988 = 51U;
  	volatile uint64_t t77 = 113LLU;
  
      t77 = ((x4985+(x4986*x4987))<<x4988);
  
      if (t77 != 4397765036127289344LLU) { NG(); } else { ; }
  	
  }
  
  void f78(void) {
      	int64_t x5049 = -1LL;
  	volatile uint8_t x5050 = 57U;
  	int8_t x5051 = INT8_MAX;
  	int16_t x5052 = 1;
  	int64_t t78 = 12LL;
  
      t78 = ((x5049+(x5050*x5051))<<x5052);
  
      if (t78 != 14476LL) { NG(); } else { ; }
  	
  }
  
  void f79(void) {
      	uint64_t x5117 = 8LLU;
  	static int32_t x5118 = -31339090;
  	volatile uint16_t x5119 = 0U;
  	uint64_t t79 = 99098799518977LLU;
  
      t79 = ((x5117+(x5118*x5119))<<x5120);
  
      if (t79 != 16LLU) { NG(); } else { ; }
  	
  }
  
  void f80(void) {
      	uint64_t x5153 = UINT64_MAX;
  	volatile int16_t x5154 = 9;
  	int64_t x5155 = -1LL;
  	volatile uint16_t x5156 = 2U;
  	volatile uint64_t t80 = 61LLU;
  
      t80 = ((x5153+(x5154*x5155))<<x5156);
  
      if (t80 != 18446744073709551576LLU) { NG(); } else { ; }
  	
  }
  
  void f81(void) {
      	int32_t x5173 = 887063;
  	static volatile int16_t x5174 = INT16_MIN;
  	static uint8_t x5176 = 3U;
  
      t81 = ((x5173+(x5174*x5175))<<x5176);
  
      if (t81 != 7358648LLU) { NG(); } else { ; }
  	
  }
  
  void f82(void) {
      	uint64_t x5202 = 1502196080163397LLU;
  	uint8_t x5204 = 0U;
  	uint64_t t82 = 3814916068022249671LLU;
  
      t82 = ((x5201+(x5202*x5203))<<x5204);
  
      if (t82 != 3105598774440150458LLU) { NG(); } else { ; }
  	
  }
  
  void f83(void) {
      	static volatile uint8_t x5273 = UINT8_MAX;
  	int64_t x5274 = -1LL;
  	static int32_t x5275 = -1;
  
      t83 = ((x5273+(x5274*x5275))<<x5276);
  
      if (t83 != 1099511627776LL) { NG(); } else { ; }
  	
  }
  
  void f84(void) {
      	volatile int16_t x5449 = INT16_MIN;
  	int32_t x5451 = INT32_MIN;
  	uint8_t x5452 = 4U;
  	int64_t t84 = 0LL;
  
      t84 = ((x5449+(x5450*x5451))<<x5452);
  
      if (t84 != 34359214080LL) { NG(); } else { ; }
  	
  }
  
  void f85(void) {
      	static uint16_t x5481 = 24187U;
  	volatile uint64_t x5482 = 1032LLU;
  	int32_t x5484 = 11;
  	uint64_t t85 = 337892807030LLU;
  
      t85 = ((x5481+(x5482*x5483))<<x5484);
  
      if (t85 != 47421440LLU) { NG(); } else { ; }
  	
  }
  
  void f86(void) {
      	int64_t x5554 = 790922157LL;
  	uint32_t x5555 = 2960U;
  	int8_t x5556 = 5;
  	volatile int64_t t86 = 9083587LL;
  
      t86 = ((x5553+(x5554*x5555))<<x5556);
  
      if (t86 != 74916146711008LL) { NG(); } else { ; }
  	
  }
  
  void f87(void) {
      	static uint16_t x5593 = 4U;
  	volatile uint16_t x5595 = 1U;
  	int8_t x5596 = 0;
  
      t87 = ((x5593+(x5594*x5595))<<x5596);
  
      if (t87 != 58080987929LL) { NG(); } else { ; }
  	
  }
  
  void f88(void) {
      	int8_t x5618 = -6;
  	static int16_t x5619 = INT16_MIN;
  
      t88 = ((x5617+(x5618*x5619))<<x5620);
  
      if (t88 != 402866176) { NG(); } else { ; }
  	
  }
  
  void f89(void) {
      	volatile uint16_t x5755 = UINT16_MAX;
  	int8_t x5756 = 0;
  	static volatile uint32_t t89 = 1U;
  
      t89 = ((x5753+(x5754*x5755))<<x5756);
  
      if (t89 != 361284U) { NG(); } else { ; }
  	
  }
  
  void f90(void) {
      	int16_t x5785 = INT16_MAX;
  	uint32_t x5786 = 7U;
  	uint32_t x5787 = 127U;
  	int64_t x5788 = 28LL;
  	uint32_t t90 = 65748U;
  
      t90 = ((x5785+(x5786*x5787))<<x5788);
  
      if (t90 != 2147483648U) { NG(); } else { ; }
  	
  }
  
  void f91(void) {
      	uint32_t x5825 = 118U;
  	volatile int16_t x5826 = INT16_MIN;
  	static uint16_t x5827 = UINT16_MAX;
  	static int32_t x5828 = 0;
  	static volatile uint32_t t91 = 783818459U;
  
      t91 = ((x5825+(x5826*x5827))<<x5828);
  
      if (t91 != 2147516534U) { NG(); } else { ; }
  	
  }
  
  void f92(void) {
      	volatile uint64_t x5922 = 82967618LLU;
  	volatile uint8_t x5923 = 22U;
  	int64_t x5924 = 6LL;
  
      t92 = ((x5921+(x5922*x5923))<<x5924);
  
      if (t92 != 116820503232LLU) { NG(); } else { ; }
  	
  }
  
  void f93(void) {
      	static int8_t x5977 = 16;
  	static uint64_t x5978 = 394607LLU;
  	int64_t x5979 = INT64_MAX;
  	uint8_t x5980 = 4U;
  
      t93 = ((x5977+(x5978*x5979))<<x5980);
  
      if (t93 != 18446744073703238160LLU) { NG(); } else { ; }
  	
  }
  
  void f94(void) {
      	volatile uint32_t x5985 = 85U;
  	uint64_t x5986 = UINT64_MAX;
  	volatile int8_t x5987 = INT8_MAX;
  	uint8_t x5988 = 13U;
  	static uint64_t t94 = 2184788294173285836LLU;
  
      t94 = ((x5985+(x5986*x5987))<<x5988);
  
      if (t94 != 18446744073709207552LLU) { NG(); } else { ; }
  	
  }
  
  void f95(void) {
      	uint32_t x6033 = UINT32_MAX;
  	int16_t x6034 = INT16_MIN;
  	uint64_t x6035 = 5329040516539LLU;
  	int16_t x6036 = 0;
  	static volatile uint64_t t95 = 250430054071LLU;
  
      t95 = ((x6033+(x6034*x6035))<<x6036);
  
      if (t95 != 18272122078358568959LLU) { NG(); } else { ; }
  	
  }
  
  void f96(void) {
      	uint8_t x6077 = 58U;
  	int8_t x6078 = INT8_MIN;
  	int16_t x6079 = 0;
  
      t96 = ((x6077+(x6078*x6079))<<x6080);
  
      if (t96 != 116) { NG(); } else { ; }
  	
  }
  
  void f97(void) {
      	int64_t x6087 = 94097480LL;
  	volatile int64_t t97 = -120LL;
  
      t97 = ((x6085+(x6086*x6087))<<x6088);
  
      if (t97 != 14302816848LL) { NG(); } else { ; }
  	
  }
  
  void f98(void) {
      	static int32_t x6129 = 892169537;
  	static uint64_t x6130 = 23223873241122613LLU;
  	volatile int8_t x6131 = INT8_MIN;
  	static uint32_t x6132 = 28U;
  
      t98 = ((x6129+(x6130*x6131))<<x6132);
  
      if (t98 != 3210676396934299648LLU) { NG(); } else { ; }
  	
  }
  
  void f99(void) {
      	static int8_t x6210 = -12;
  	int64_t x6211 = -1LL;
  	volatile int8_t x6212 = 0;
  	volatile int64_t t99 = -20989158LL;
  
      t99 = ((x6209+(x6210*x6211))<<x6212);
  
      if (t99 != 12LL) { NG(); } else { ; }
  	
  }
  
  void f100(void) {
      	volatile uint64_t x6221 = 6632952LLU;
  	int8_t x6222 = INT8_MIN;
  	volatile uint8_t x6224 = 1U;
  	uint64_t t100 = 0LLU;
  
      t100 = ((x6221+(x6222*x6223))<<x6224);
  
      if (t100 != 18446744073706040560LLU) { NG(); } else { ; }
  	
  }
  
  void f101(void) {
      	int8_t x6285 = -6;
  	uint64_t x6286 = UINT64_MAX;
  	uint8_t x6287 = UINT8_MAX;
  	static int16_t x6288 = 2;
  	uint64_t t101 = 1056133641477LLU;
  
      t101 = ((x6285+(x6286*x6287))<<x6288);
  
      if (t101 != 18446744073709550572LLU) { NG(); } else { ; }
  	
  }
  
  void f102(void) {
      	uint16_t x6293 = 595U;
  	volatile int64_t x6294 = 23342159LL;
  	static uint8_t x6296 = 6U;
  	int64_t t102 = 34117976986LL;
  
      t102 = ((x6293+(x6294*x6295))<<x6296);
  
      if (t102 != 82164437760LL) { NG(); } else { ; }
  	
  }
  
  void f103(void) {
      	uint8_t x6317 = UINT8_MAX;
  	int16_t x6318 = INT16_MAX;
  	int64_t x6319 = 680441933LL;
  	int8_t x6320 = 4;
  	volatile int64_t t103 = -505224381LL;
  
      t103 = ((x6317+(x6318*x6319))<<x6320);
  
      if (t103 != 356736653101856LL) { NG(); } else { ; }
  	
  }
  
  void f104(void) {
      	uint16_t x6441 = UINT16_MAX;
  	int64_t x6443 = -1LL;
  	static uint16_t x6444 = 0U;
  
      t104 = ((x6441+(x6442*x6443))<<x6444);
  
      if (t104 != 65280LL) { NG(); } else { ; }
  	
  }
  
  void f105(void) {
      	int32_t x6461 = -3;
  	static volatile int8_t x6462 = 0;
  	static volatile uint32_t x6463 = 24140384U;
  	uint8_t x6464 = 8U;
  	uint32_t t105 = 11575587U;
  
      t105 = ((x6461+(x6462*x6463))<<x6464);
  
      if (t105 != 4294966528U) { NG(); } else { ; }
  	
  }
  
  void f106(void) {
      	volatile int8_t x6469 = 23;
  	static uint32_t x6470 = 0U;
  	uint8_t x6471 = UINT8_MAX;
  	volatile int16_t x6472 = 3;
  	static volatile uint32_t t106 = 2048U;
  
      t106 = ((x6469+(x6470*x6471))<<x6472);
  
      if (t106 != 184U) { NG(); } else { ; }
  	
  }
  
  void f107(void) {
      	uint32_t x6621 = UINT32_MAX;
  	uint16_t x6623 = 3028U;
  	uint64_t x6624 = 0LLU;
  
      t107 = ((x6621+(x6622*x6623))<<x6624);
  
      if (t107 != 772139U) { NG(); } else { ; }
  	
  }
  
  void f108(void) {
      	static uint64_t x6764 = 9LLU;
  	volatile uint64_t t108 = 4745152319346LLU;
  
      t108 = ((x6761+(x6762*x6763))<<x6764);
  
      if (t108 != 91123225934301696LLU) { NG(); } else { ; }
  	
  }
  
  void f109(void) {
      	uint32_t x6850 = 125027592U;
  	static uint64_t x6851 = 60LLU;
  	uint16_t x6852 = 0U;
  	uint64_t t109 = 7998905914026045LLU;
  
      t109 = ((x6849+(x6850*x6851))<<x6852);
  
      if (t109 != 7501655647LLU) { NG(); } else { ; }
  	
  }
  
  void f110(void) {
      	uint64_t x6933 = 16878LLU;
  	volatile int16_t x6934 = INT16_MIN;
  	static volatile int32_t x6935 = 14;
  	uint64_t t110 = 519LLU;
  
      t110 = ((x6933+(x6934*x6935))<<x6936);
  
      if (t110 != 18446744066469888000LLU) { NG(); } else { ; }
  	
  }
  
  void f111(void) {
      	uint32_t x6954 = 67167504U;
  	static uint64_t x6955 = 849079052531259LLU;
  
      t111 = ((x6953+(x6954*x6955))<<x6956);
  
      if (t111 != 844082618051940736LLU) { NG(); } else { ; }
  	
  }
  
  void f112(void) {
      	static int64_t x7033 = INT64_MAX;
  	uint8_t x7035 = UINT8_MAX;
  	uint8_t x7036 = 0U;
  	volatile int64_t t112 = -3048246920950484711LL;
  
      t112 = ((x7033+(x7034*x7035))<<x7036);
  
      if (t112 != 9223372036854775552LL) { NG(); } else { ; }
  	
  }
  
  void f113(void) {
      	static uint16_t x7053 = 0U;
  	int8_t x7055 = INT8_MAX;
  	uint16_t x7056 = 2U;
  	uint64_t t113 = 15548896LLU;
  
      t113 = ((x7053+(x7054*x7055))<<x7056);
  
      if (t113 != 100987652326605848LLU) { NG(); } else { ; }
  	
  }
  
  void f114(void) {
      	int16_t x7062 = -3;
  	int32_t x7063 = 213872585;
  	volatile int16_t x7064 = 39;
  	volatile uint64_t t114 = 7905768742027468440LLU;
  
      t114 = ((x7061+(x7062*x7063))<<x7064);
  
      if (t114 != 16201789819418836992LLU) { NG(); } else { ; }
  	
  }
  
  void f115(void) {
      	int16_t x7129 = INT16_MIN;
  	static int64_t x7130 = 921025LL;
  	int16_t x7131 = INT16_MAX;
  	volatile uint32_t x7132 = 7U;
  
      t115 = ((x7129+(x7130*x7131))<<x7132);
  
      if (t115 != 3862936756096LL) { NG(); } else { ; }
  	
  }
  
  void f116(void) {
      	static uint16_t x7209 = UINT16_MAX;
  	int8_t x7210 = -35;
  	int32_t x7211 = -1;
  	static int32_t t116 = 206439;
  
      t116 = ((x7209+(x7210*x7211))<<x7212);
  
      if (t116 != 65570) { NG(); } else { ; }
  	
  }
  
  void f117(void) {
      	uint32_t x7273 = UINT32_MAX;
  	int64_t x7274 = -1LL;
  	static int16_t x7275 = INT16_MIN;
  	uint16_t x7276 = 0U;
  	int64_t t117 = -50773231LL;
  
      t117 = ((x7273+(x7274*x7275))<<x7276);
  
      if (t117 != 4295000063LL) { NG(); } else { ; }
  	
  }
  
  void f118(void) {
      	static uint8_t x7318 = 1U;
  	volatile uint32_t x7319 = 42070345U;
  	int8_t x7320 = 3;
  	volatile uint32_t t118 = 24U;
  
      t118 = ((x7317+(x7318*x7319))<<x7320);
  
      if (t118 != 336562752U) { NG(); } else { ; }
  	
  }
  
  void f119(void) {
      	int16_t x7401 = 5552;
  	int16_t x7402 = INT16_MIN;
  	uint64_t x7403 = 2685241LLU;
  	int8_t x7404 = 0;
  	uint64_t t119 = 95LLU;
  
      t119 = ((x7401+(x7402*x7403))<<x7404);
  
      if (t119 != 18446743985719580080LLU) { NG(); } else { ; }
  	
  }
  
  void f120(void) {
      	uint64_t x7453 = 67954672LLU;
  	int64_t x7455 = -199LL;
  
      t120 = ((x7453+(x7454*x7455))<<x7456);
  
      if (t120 != 8698172544LLU) { NG(); } else { ; }
  	
  }
  
  void f121(void) {
      	int8_t x7477 = INT8_MAX;
  	static uint8_t x7480 = 2U;
  	int64_t t121 = -244LL;
  
      t121 = ((x7477+(x7478*x7479))<<x7480);
  
      if (t121 != 131580LL) { NG(); } else { ; }
  	
  }
  
  void f122(void) {
      	volatile uint64_t x7490 = 3837248LLU;
  	static volatile uint64_t t122 = 248LLU;
  
      t122 = ((x7489+(x7490*x7491))<<x7492);
  
      if (t122 != 18446744073218416512LLU) { NG(); } else { ; }
  	
  }
  
  void f123(void) {
      	uint64_t x7505 = 6712237435029LLU;
  	int16_t x7506 = INT16_MIN;
  	volatile uint32_t x7507 = 2802U;
  	static volatile uint8_t x7508 = 8U;
  	static uint64_t t123 = 1510236LLU;
  
      t123 = ((x7505+(x7506*x7507))<<x7508);
  
      if (t123 != 1719408790115584LLU) { NG(); } else { ; }
  	
  }
  
  void f124(void) {
      	int32_t x7537 = INT32_MIN;
  	uint32_t x7539 = 71869U;
  	uint8_t x7540 = 10U;
  	static uint32_t t124 = 2481875U;
  
      t124 = ((x7537+(x7538*x7539))<<x7540);
  
      if (t124 != 4221373440U) { NG(); } else { ; }
  	
  }
  
  void f125(void) {
      	static int64_t x7621 = 1949679LL;
  	volatile uint32_t x7622 = 1243915625U;
  	int16_t x7623 = INT16_MIN;
  	int64_t t125 = 14133752102LL;
  
      t125 = ((x7621+(x7622*x7623))<<x7624);
  
      if (t125 != 5818712030LL) { NG(); } else { ; }
  	
  }
  
  void f126(void) {
      	uint32_t x7661 = 31U;
  	int8_t x7663 = 8;
  	volatile uint32_t t126 = 640U;
  
      t126 = ((x7661+(x7662*x7663))<<x7664);
  
      if (t126 != 262167U) { NG(); } else { ; }
  	
  }
  
  void f127(void) {
      	uint16_t x7675 = 7U;
  	static int16_t x7676 = 11;
  
      t127 = ((x7673+(x7674*x7675))<<x7676);
  
      if (t127 != 17552565740673024LLU) { NG(); } else { ; }
  	
  }
  
  void f128(void) {
      	volatile uint64_t x7685 = 631024024531440476LLU;
  	int8_t x7686 = INT8_MIN;
  	uint8_t x7687 = 0U;
  	static uint64_t t128 = 0LLU;
  
      t128 = ((x7685+(x7686*x7687))<<x7688);
  
      if (t128 != 1746024711296543616LLU) { NG(); } else { ; }
  	
  }
  
  void f129(void) {
      	int8_t x7766 = 63;
  	int32_t t129 = -1;
  
      t129 = ((x7765+(x7766*x7767))<<x7768);
  
      if (t129 != 8388352) { NG(); } else { ; }
  	
  }
  
  void f130(void) {
      	int8_t x7997 = 53;
  	uint16_t x7998 = UINT16_MAX;
  	volatile int8_t x8000 = 0;
  	static int64_t t130 = -293LL;
  
      t130 = ((x7997+(x7998*x7999))<<x8000);
  
      if (t130 != 1105059363841103LL) { NG(); } else { ; }
  	
  }
  
  void f131(void) {
      	uint64_t x8029 = UINT64_MAX;
  	volatile int8_t x8030 = INT8_MIN;
  	uint8_t x8031 = UINT8_MAX;
  	int16_t x8032 = 1;
  	volatile uint64_t t131 = 30LLU;
  
      t131 = ((x8029+(x8030*x8031))<<x8032);
  
      if (t131 != 18446744073709486334LLU) { NG(); } else { ; }
  	
  }
  
  void f132(void) {
      	static uint64_t x8033 = UINT64_MAX;
  	int16_t x8035 = -1;
  	static volatile uint64_t t132 = 198349037983860LLU;
  
      t132 = ((x8033+(x8034*x8035))<<x8036);
  
      if (t132 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f133(void) {
      	static int8_t x8057 = INT8_MIN;
  	uint32_t x8058 = 1898360487U;
  	uint64_t x8059 = 13219893916LLU;
  	volatile uint64_t t133 = 51001788LLU;
  
      t133 = ((x8057+(x8058*x8059))<<x8060);
  
      if (t133 != 4233479695755780096LLU) { NG(); } else { ; }
  	
  }
  
  void f134(void) {
      	int64_t x8113 = INT64_MAX;
  	static int32_t x8114 = 17690062;
  	uint64_t x8115 = UINT64_MAX;
  	static volatile int8_t x8116 = 9;
  	static uint64_t t134 = 34139079153LLU;
  
      t134 = ((x8113+(x8114*x8115))<<x8116);
  
      if (t134 != 18446744064652239360LLU) { NG(); } else { ; }
  	
  }
  
  void f135(void) {
      	int32_t x8141 = 40415;
  	int16_t x8142 = -126;
  	static int64_t x8143 = -3LL;
  	static volatile int64_t t135 = 9LL;
  
      t135 = ((x8141+(x8142*x8143))<<x8144);
  
      if (t135 != 5221504LL) { NG(); } else { ; }
  	
  }
  
  void f136(void) {
      	int16_t x8153 = INT16_MAX;
  	int8_t x8155 = INT8_MIN;
  	volatile int64_t t136 = 19LL;
  
      t136 = ((x8153+(x8154*x8155))<<x8156);
  
      if (t136 != 67368960LL) { NG(); } else { ; }
  	
  }
  
  void f137(void) {
      	int16_t x8161 = 0;
  	int64_t x8163 = -2001480502718224LL;
  	uint64_t t137 = 352LLU;
  
      t137 = ((x8161+(x8162*x8163))<<x8164);
  
      if (t137 != 4002961005436448LLU) { NG(); } else { ; }
  	
  }
  
  void f138(void) {
      	uint64_t x8213 = 44LLU;
  	int16_t x8214 = 0;
  	static volatile int8_t x8215 = INT8_MAX;
  	uint16_t x8216 = 1U;
  
      t138 = ((x8213+(x8214*x8215))<<x8216);
  
      if (t138 != 88LLU) { NG(); } else { ; }
  	
  }
  
  void f139(void) {
      	uint16_t x8410 = UINT16_MAX;
  	int8_t x8411 = -7;
  	int8_t x8412 = 3;
  	volatile int64_t t139 = 117971019431LL;
  
      t139 = ((x8409+(x8410*x8411))<<x8412);
  
      if (t139 != 3901560LL) { NG(); } else { ; }
  	
  }
  
  void f140(void) {
      	static volatile int16_t x8454 = 15;
  	uint32_t x8455 = UINT32_MAX;
  	uint8_t x8456 = 3U;
  	volatile uint32_t t140 = 48U;
  
      t140 = ((x8453+(x8454*x8455))<<x8456);
  
      if (t140 != 4294967216U) { NG(); } else { ; }
  	
  }
  
  void f141(void) {
      	int8_t x8589 = 3;
  	int16_t x8590 = INT16_MAX;
  	uint16_t x8592 = 11U;
  	static volatile uint64_t t141 = 27536165260LLU;
  
      t141 = ((x8589+(x8590*x8591))<<x8592);
  
      if (t141 != 41470139806519296LLU) { NG(); } else { ; }
  	
  }
  
  void f142(void) {
      	uint16_t x8698 = 27511U;
  	uint16_t x8700 = 0U;
  	static volatile int32_t t142 = -3003;
  
      t142 = ((x8697+(x8698*x8699))<<x8700);
  
      if (t142 != 901420169) { NG(); } else { ; }
  	
  }
  
  void f143(void) {
      	volatile int8_t x8701 = INT8_MIN;
  	uint64_t x8702 = 3477LLU;
  	volatile int8_t x8703 = INT8_MIN;
  	volatile uint64_t t143 = 6LLU;
  
      t143 = ((x8701+(x8702*x8703))<<x8704);
  
      if (t143 != 18446729135813296128LLU) { NG(); } else { ; }
  	
  }
  
  void f144(void) {
      	int32_t x8789 = INT32_MAX;
  	volatile int8_t x8790 = -1;
  	uint64_t x8791 = UINT64_MAX;
  	uint16_t x8792 = 2U;
  	static uint64_t t144 = 74685452982LLU;
  
      t144 = ((x8789+(x8790*x8791))<<x8792);
  
      if (t144 != 8589934592LLU) { NG(); } else { ; }
  	
  }
  
  void f145(void) {
      	int8_t x8801 = INT8_MAX;
  	uint64_t x8802 = 1563603556LLU;
  	static uint16_t x8804 = 1U;
  	uint64_t t145 = 56287747943LLU;
  
      t145 = ((x8801+(x8802*x8803))<<x8804);
  
      if (t145 != 11731117936780247294LLU) { NG(); } else { ; }
  	
  }
  
  void f146(void) {
      	int16_t x8873 = -1;
  	volatile int8_t x8874 = 1;
  	uint32_t x8875 = UINT32_MAX;
  	int8_t x8876 = 1;
  	static uint32_t t146 = 611873U;
  
      t146 = ((x8873+(x8874*x8875))<<x8876);
  
      if (t146 != 4294967292U) { NG(); } else { ; }
  	
  }
  
  void f147(void) {
      	uint64_t x8906 = 4LLU;
  	int8_t x8907 = -27;
  	static uint64_t x8908 = 1LLU;
  	volatile uint64_t t147 = 13LLU;
  
      t147 = ((x8905+(x8906*x8907))<<x8908);
  
      if (t147 != 18446744073709551414LLU) { NG(); } else { ; }
  	
  }
  
  void f148(void) {
      	static volatile uint32_t x9022 = 130601U;
  	uint8_t x9023 = 1U;
  	uint16_t x9024 = 0U;
  	int64_t t148 = -561133599531239LL;
  
      t148 = ((x9021+(x9022*x9023))<<x9024);
  
      if (t148 != 130600LL) { NG(); } else { ; }
  	
  }
  
  void f149(void) {
      	static volatile int8_t x9038 = -11;
  	uint32_t x9039 = 278U;
  	uint8_t x9040 = 12U;
  	uint32_t t149 = 1U;
  
      t149 = ((x9037+(x9038*x9039))<<x9040);
  
      if (t149 != 4281917440U) { NG(); } else { ; }
  	
  }
  
  void f150(void) {
      	uint8_t x9113 = UINT8_MAX;
  	static int8_t x9114 = INT8_MIN;
  	static int16_t x9115 = 1;
  	uint8_t x9116 = 1U;
  	static int32_t t150 = -1707363;
  
      t150 = ((x9113+(x9114*x9115))<<x9116);
  
      if (t150 != 254) { NG(); } else { ; }
  	
  }
  
  void f151(void) {
      	uint64_t x9169 = 2717369LLU;
  	uint32_t x9170 = UINT32_MAX;
  	int16_t x9171 = INT16_MIN;
  	int16_t x9172 = 0;
  	volatile uint64_t t151 = 14305511LLU;
  
      t151 = ((x9169+(x9170*x9171))<<x9172);
  
      if (t151 != 2750137LLU) { NG(); } else { ; }
  	
  }
  
  void f152(void) {
      	uint64_t x9205 = 118990520812578LLU;
  	int16_t x9206 = -1;
  	uint16_t x9207 = UINT16_MAX;
  	uint8_t x9208 = 2U;
  
      t152 = ((x9205+(x9206*x9207))<<x9208);
  
      if (t152 != 475962082988172LLU) { NG(); } else { ; }
  	
  }
  
  void f153(void) {
      	int64_t x9210 = -1LL;
  	int8_t x9212 = 15;
  	volatile int64_t t153 = 11406108LL;
  
      t153 = ((x9209+(x9210*x9211))<<x9212);
  
      if (t153 != 70368745291776LL) { NG(); } else { ; }
  	
  }
  
  void f154(void) {
      	int64_t x9322 = 13340356LL;
  	uint8_t x9323 = UINT8_MAX;
  	int8_t x9324 = 1;
  	int64_t t154 = 194935368LL;
  
      t154 = ((x9321+(x9322*x9323))<<x9324);
  
      if (t154 != 6803581578LL) { NG(); } else { ; }
  	
  }
  
  void f155(void) {
      	uint64_t x9341 = UINT64_MAX;
  	uint16_t x9344 = 34U;
  	volatile uint64_t t155 = 1343480672427LLU;
  
      t155 = ((x9341+(x9342*x9343))<<x9344);
  
      if (t155 != 18446500016487923712LLU) { NG(); } else { ; }
  	
  }
  
  void f156(void) {
      	int8_t x9397 = INT8_MIN;
  	static int8_t x9398 = INT8_MIN;
  	static volatile uint8_t x9400 = 10U;
  	int32_t t156 = 44402675;
  
      t156 = ((x9397+(x9398*x9399))<<x9400);
  
      if (t156 != 0) { NG(); } else { ; }
  	
  }
  
  void f157(void) {
      	int8_t x9417 = INT8_MIN;
  	volatile uint64_t x9418 = UINT64_MAX;
  	int32_t x9419 = 17734483;
  	int16_t x9420 = 0;
  	uint64_t t157 = 13717669625LLU;
  
      t157 = ((x9417+(x9418*x9419))<<x9420);
  
      if (t157 != 18446744073691817005LLU) { NG(); } else { ; }
  	
  }
  
  void f158(void) {
      	static int32_t x9469 = -1;
  	uint8_t x9470 = UINT8_MAX;
  	static uint8_t x9472 = 1U;
  
      t158 = ((x9469+(x9470*x9471))<<x9472);
  
      if (t158 != 31618) { NG(); } else { ; }
  	
  }
  
  void f159(void) {
      	int64_t x9506 = -2342874004050LL;
  	uint64_t x9507 = 389623601859LLU;
  	int8_t x9508 = 0;
  	volatile uint64_t t159 = 69051179808339374LLU;
  
      t159 = ((x9505+(x9506*x9507))<<x9508);
  
      if (t159 != 16569071812517805961LLU) { NG(); } else { ; }
  	
  }
  
  void f160(void) {
      	uint64_t x9525 = 16940257746LLU;
  	volatile int16_t x9526 = -1;
  	static uint32_t x9527 = 5419U;
  	uint8_t x9528 = 1U;
  	volatile uint64_t t160 = 1633LLU;
  
      t160 = ((x9525+(x9526*x9527))<<x9528);
  
      if (t160 != 42470439246LLU) { NG(); } else { ; }
  	
  }
  
  void f161(void) {
      	uint8_t x9551 = 1U;
  	static uint8_t x9552 = 0U;
  
      t161 = ((x9549+(x9550*x9551))<<x9552);
  
      if (t161 != 65556) { NG(); } else { ; }
  	
  }
  
  void f162(void) {
      	static uint8_t x9565 = 118U;
  	uint8_t x9566 = 0U;
  	int8_t x9567 = 39;
  	volatile uint8_t x9568 = 12U;
  	static int32_t t162 = -5;
  
      t162 = ((x9565+(x9566*x9567))<<x9568);
  
      if (t162 != 483328) { NG(); } else { ; }
  	
  }
  
  void f163(void) {
      	static volatile int32_t x9813 = 110788;
  	static int16_t x9814 = INT16_MIN;
  	int8_t x9816 = 13;
  	uint64_t t163 = 885122926867LLU;
  
      t163 = ((x9813+(x9814*x9815))<<x9816);
  
      if (t163 != 1176010752LLU) { NG(); } else { ; }
  	
  }
  
  void f164(void) {
      	static uint16_t x9829 = 2U;
  	int16_t x9830 = INT16_MIN;
  	static uint64_t x9831 = 98934LLU;
  	uint64_t t164 = 42969662LLU;
  
      t164 = ((x9829+(x9830*x9831))<<x9832);
  
      if (t164 != 4611826755915743232LLU) { NG(); } else { ; }
  	
  }
  
  void f165(void) {
      	int64_t x10042 = -1LL;
  	uint64_t x10043 = 8643806LLU;
  	uint8_t x10044 = 1U;
  	static uint64_t t165 = 156LLU;
  
      t165 = ((x10041+(x10042*x10043))<<x10044);
  
      if (t165 != 18446744073692263944LLU) { NG(); } else { ; }
  	
  }
  
  void f166(void) {
      	uint8_t x10193 = 99U;
  	volatile uint32_t x10194 = 238713U;
  	int8_t x10195 = 2;
  	uint8_t x10196 = 18U;
  	volatile uint32_t t166 = 25066350U;
  
      t166 = ((x10193+(x10194*x10195))<<x10196);
  
      if (t166 != 626262016U) { NG(); } else { ; }
  	
  }
  
  void f167(void) {
      	int16_t x10205 = -1;
  	static volatile uint8_t x10208 = 3U;
  	uint64_t t167 = 106049865419081929LLU;
  
      t167 = ((x10205+(x10206*x10207))<<x10208);
  
      if (t167 != 54595740552072LLU) { NG(); } else { ; }
  	
  }
  
  void f168(void) {
      	int16_t x10213 = 22;
  	int8_t x10214 = INT8_MAX;
  	uint16_t x10215 = UINT16_MAX;
  	static int32_t x10216 = 0;
  	int32_t t168 = 31759;
  
      t168 = ((x10213+(x10214*x10215))<<x10216);
  
      if (t168 != 8322967) { NG(); } else { ; }
  	
  }
  
  void f169(void) {
      	uint64_t x10249 = 7125880LLU;
  	uint8_t x10250 = UINT8_MAX;
  	int16_t x10252 = 0;
  	uint64_t t169 = 2833301891214262LLU;
  
      t169 = ((x10249+(x10250*x10251))<<x10252);
  
      if (t169 != 7125625LLU) { NG(); } else { ; }
  	
  }
  
  void f170(void) {
      	static uint8_t x10365 = UINT8_MAX;
  	int16_t x10366 = -1;
  	int16_t x10367 = INT16_MIN;
  	uint8_t x10368 = 0U;
  	volatile int32_t t170 = -336036;
  
      t170 = ((x10365+(x10366*x10367))<<x10368);
  
      if (t170 != 33023) { NG(); } else { ; }
  	
  }
  
  void f171(void) {
      	volatile uint64_t x10389 = 487LLU;
  	int16_t x10390 = -10;
  	int32_t x10391 = 22;
  	uint64_t t171 = 98670269070405648LLU;
  
      t171 = ((x10389+(x10390*x10391))<<x10392);
  
      if (t171 != 4697113673859072LLU) { NG(); } else { ; }
  	
  }
  
  void f172(void) {
      	volatile uint32_t x10481 = 1436433U;
  	volatile uint8_t x10482 = 0U;
  	int32_t x10483 = -1;
  	static int8_t x10484 = 1;
  	static volatile uint32_t t172 = 304376192U;
  
      t172 = ((x10481+(x10482*x10483))<<x10484);
  
      if (t172 != 2872866U) { NG(); } else { ; }
  	
  }
  
  void f173(void) {
      	volatile int8_t x10485 = INT8_MIN;
  	uint64_t x10486 = UINT64_MAX;
  	static uint8_t x10487 = 4U;
  	volatile uint32_t x10488 = 45U;
  	static uint64_t t173 = 166426954389LLU;
  
      t173 = ((x10485+(x10486*x10487))<<x10488);
  
      if (t173 != 18442099736593825792LLU) { NG(); } else { ; }
  	
  }
  
  void f174(void) {
      	int16_t x10585 = INT16_MIN;
  	uint64_t x10586 = 121124846403756590LLU;
  	int8_t x10587 = INT8_MAX;
  	uint8_t x10588 = 1U;
  	static volatile uint64_t t174 = 27702770655333917LLU;
  
      t174 = ((x10585+(x10586*x10587))<<x10588);
  
      if (t174 != 12318966912844556708LLU) { NG(); } else { ; }
  	
  }
  
  void f175(void) {
      	static volatile int16_t x10686 = 252;
  	static int8_t x10687 = INT8_MIN;
  	static uint16_t x10688 = 0U;
  	static uint64_t t175 = 1925435LLU;
  
      t175 = ((x10685+(x10686*x10687))<<x10688);
  
      if (t175 != 14738989LLU) { NG(); } else { ; }
  	
  }
  
  void f176(void) {
      	volatile uint32_t x10693 = 6186264U;
  	volatile uint16_t x10694 = 605U;
  	int16_t x10695 = INT16_MIN;
  	volatile uint8_t x10696 = 23U;
  	uint32_t t176 = 431714U;
  
      t176 = ((x10693+(x10694*x10695))<<x10696);
  
      if (t176 != 2348810240U) { NG(); } else { ; }
  	
  }
  
  void f177(void) {
      	uint32_t x10830 = 1U;
  	static int16_t x10831 = INT16_MIN;
  	uint8_t x10832 = 0U;
  
      t177 = ((x10829+(x10830*x10831))<<x10832);
  
      if (t177 != 4294934527U) { NG(); } else { ; }
  	
  }
  
  void f178(void) {
      	int8_t x10861 = INT8_MIN;
  	uint64_t x10862 = 286166829234LLU;
  	uint8_t x10863 = 17U;
  
      t178 = ((x10861+(x10862*x10863))<<x10864);
  
      if (t178 != 4864836096850LLU) { NG(); } else { ; }
  	
  }
  
  void f179(void) {
      	int32_t x10925 = INT32_MAX;
  	uint32_t x10926 = 118U;
  	static uint8_t x10928 = 1U;
  	uint32_t t179 = 47686U;
  
      t179 = ((x10925+(x10926*x10927))<<x10928);
  
      if (t179 != 60178U) { NG(); } else { ; }
  	
  }
  
  void f180(void) {
      	int8_t x10929 = INT8_MAX;
  	int8_t x10930 = 27;
  	uint32_t x10931 = 1503188443U;
  	int8_t x10932 = 6;
  	volatile uint32_t t180 = 6634U;
  
      t180 = ((x10929+(x10930*x10931))<<x10932);
  
      if (t180 != 3349390848U) { NG(); } else { ; }
  	
  }
  
  void f181(void) {
      	int8_t x10937 = INT8_MIN;
  	int16_t x10938 = 331;
  	volatile uint8_t x10939 = 118U;
  	static uint64_t x10940 = 1LLU;
  	static int32_t t181 = 925840657;
  
      t181 = ((x10937+(x10938*x10939))<<x10940);
  
      if (t181 != 77860) { NG(); } else { ; }
  	
  }
  
  void f182(void) {
      	uint64_t x11058 = 480824LLU;
  	int32_t x11059 = INT32_MIN;
  	int8_t x11060 = 1;
  	static volatile uint64_t t182 = 27140LLU;
  
      t182 = ((x11057+(x11058*x11059))<<x11060);
  
      if (t182 != 18444678950354419710LLU) { NG(); } else { ; }
  	
  }
  
  void f183(void) {
      	int8_t x11105 = INT8_MAX;
  	uint8_t x11106 = 2U;
  	int16_t x11107 = 41;
  	uint8_t x11108 = 7U;
  	volatile int32_t t183 = 172139;
  
      t183 = ((x11105+(x11106*x11107))<<x11108);
  
      if (t183 != 26752) { NG(); } else { ; }
  	
  }
  
  void f184(void) {
      	uint32_t x11125 = UINT32_MAX;
  	static int16_t x11126 = -1;
  	int16_t x11128 = 10;
  	volatile uint32_t t184 = 67U;
  
      t184 = ((x11125+(x11126*x11127))<<x11128);
  
      if (t184 != 4294664192U) { NG(); } else { ; }
  	
  }
  
  void f185(void) {
      	int16_t x11161 = INT16_MIN;
  	static volatile int64_t x11162 = -1LL;
  	int64_t x11163 = -40307LL;
  	static int64_t t185 = 1LL;
  
      t185 = ((x11161+(x11162*x11163))<<x11164);
  
      if (t185 != 7539LL) { NG(); } else { ; }
  	
  }
  
  void f186(void) {
      	int16_t x11185 = -2;
  	volatile uint32_t x11186 = UINT32_MAX;
  	int16_t x11188 = 0;
  	uint32_t t186 = 90U;
  
      t186 = ((x11185+(x11186*x11187))<<x11188);
  
      if (t186 != 488U) { NG(); } else { ; }
  	
  }
  
  void f187(void) {
      	int8_t x11315 = INT8_MIN;
  	static uint8_t x11316 = 10U;
  	volatile int32_t t187 = 1562;
  
      t187 = ((x11313+(x11314*x11315))<<x11316);
  
      if (t187 != 53738496) { NG(); } else { ; }
  	
  }
  
  void f188(void) {
      	uint16_t x11341 = UINT16_MAX;
  	int16_t x11342 = -1;
  	uint16_t x11343 = UINT16_MAX;
  	uint32_t x11344 = 8U;
  	int32_t t188 = -8197;
  
      t188 = ((x11341+(x11342*x11343))<<x11344);
  
      if (t188 != 0) { NG(); } else { ; }
  	
  }
  
  void f189(void) {
      	volatile uint64_t x11369 = 3000LLU;
  	uint32_t x11371 = 247681U;
  	uint16_t x11372 = 26U;
  	uint64_t t189 = 1408415281081456613LLU;
  
      t189 = ((x11369+(x11370*x11371))<<x11372);
  
      if (t189 != 31804674671640576LLU) { NG(); } else { ; }
  	
  }
  
  void f190(void) {
      	int32_t x11385 = 13965;
  	int8_t x11386 = INT8_MAX;
  	static uint32_t x11387 = 49U;
  	volatile int8_t x11388 = 11;
  	uint32_t t190 = 1617U;
  
      t190 = ((x11385+(x11386*x11387))<<x11388);
  
      if (t190 != 41345024U) { NG(); } else { ; }
  	
  }
  
  void f191(void) {
      	static int32_t x11441 = -1;
  	int8_t x11442 = -1;
  	int16_t x11443 = INT16_MIN;
  	volatile int32_t t191 = 24;
  
      t191 = ((x11441+(x11442*x11443))<<x11444);
  
      if (t191 != 2147418112) { NG(); } else { ; }
  	
  }
  
  void f192(void) {
      	int16_t x11481 = INT16_MIN;
  	volatile int8_t x11483 = 3;
  
      t192 = ((x11481+(x11482*x11483))<<x11484);
  
      if (t192 != 4294934525U) { NG(); } else { ; }
  	
  }
  
  void f193(void) {
      	int8_t x11501 = -27;
  	int64_t x11502 = INT64_MAX;
  	uint64_t x11503 = 116005LLU;
  	static int8_t x11504 = 1;
  
      t193 = ((x11501+(x11502*x11503))<<x11504);
  
      if (t193 != 18446744073709319552LLU) { NG(); } else { ; }
  	
  }
  
  void f194(void) {
      	uint8_t x11537 = 7U;
  	uint8_t x11538 = 3U;
  	uint64_t x11539 = 136599437411490903LLU;
  	static volatile uint64_t t194 = 4086501099537LLU;
  
      t194 = ((x11537+(x11538*x11539))<<x11540);
  
      if (t194 != 9163460139270299648LLU) { NG(); } else { ; }
  	
  }
  
  void f195(void) {
      	static int32_t x11633 = -1;
  	uint16_t x11634 = UINT16_MAX;
  	volatile int8_t x11636 = 2;
  
      t195 = ((x11633+(x11634*x11635))<<x11636);
  
      if (t195 != 27262556) { NG(); } else { ; }
  	
  }
  
  void f196(void) {
      	uint64_t x11665 = 16158LLU;
  	uint16_t x11668 = 8U;
  	uint64_t t196 = 262107622869204LLU;
  
      t196 = ((x11665+(x11666*x11667))<<x11668);
  
      if (t196 != 12525056LLU) { NG(); } else { ; }
  	
  }
  
  void f197(void) {
      	int16_t x11893 = INT16_MAX;
  	int32_t x11894 = 189553;
  	volatile uint64_t t197 = 2581039741261194LLU;
  
      t197 = ((x11893+(x11894*x11895))<<x11896);
  
      if (t197 != 18446744073709394830LLU) { NG(); } else { ; }
  	
  }
  
  void f198(void) {
      	uint64_t x11921 = 38153LLU;
  	static uint64_t t198 = 1828354072328504843LLU;
  
      t198 = ((x11921+(x11922*x11923))<<x11924);
  
      if (t198 != 152612LLU) { NG(); } else { ; }
  	
  }
  
  void f199(void) {
      	int16_t x11944 = 0;
  
      t199 = ((x11941+(x11942*x11943))<<x11944);
  
      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;
  }
  
  