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 uint16_t x17 = 14089U;
  volatile int64_t t0 = 6LL;
  int8_t x101 = 0;
  int16_t x123 = 3;
  int8_t x182 = 6;
  int16_t x249 = INT16_MIN;
  volatile int64_t x251 = 744259LL;
  int8_t x252 = 5;
  uint64_t t6 = 24272730853LLU;
  static volatile uint32_t t7 = 504U;
  static uint32_t x303 = 1861325U;
  uint32_t x305 = 4859850U;
  int32_t x490 = -1;
  volatile int8_t x491 = INT8_MIN;
  volatile uint64_t x568 = 1LLU;
  volatile uint32_t t14 = 27556U;
  volatile uint32_t t17 = 1U;
  int8_t x804 = 3;
  static uint8_t x864 = 30U;
  uint64_t x1259 = UINT64_MAX;
  volatile int8_t x1260 = 0;
  int16_t x1354 = INT16_MIN;
  int8_t x1611 = -9;
  int16_t x1834 = -15700;
  volatile uint32_t t33 = 13098388U;
  uint32_t x2024 = 7U;
  int32_t x2219 = 5;
  static uint16_t x2227 = 4U;
  uint8_t x2259 = 0U;
  int32_t x2323 = INT32_MAX;
  volatile uint32_t t38 = 337287U;
  int32_t x2476 = 2;
  uint64_t t41 = 10449LLU;
  uint32_t x2483 = 432U;
  uint8_t x2512 = 2U;
  uint8_t x2556 = 57U;
  volatile uint32_t x2583 = 5983U;
  uint32_t x2607 = UINT32_MAX;
  int8_t x2743 = -12;
  int32_t t47 = 3500;
  volatile int32_t x2822 = INT32_MIN;
  volatile int8_t x2823 = -1;
  int16_t x2824 = 0;
  int8_t x2875 = 1;
  static uint8_t x3004 = 16U;
  volatile uint32_t t53 = 254U;
  volatile int64_t t54 = -63547825581LL;
  volatile uint64_t t55 = 39400887880234LLU;
  uint16_t x3382 = 4268U;
  uint16_t x3384 = 0U;
  volatile int8_t x3430 = INT8_MIN;
  uint64_t t60 = 14965950LLU;
  static int32_t x3585 = -1;
  uint64_t x3693 = 2126543945695471622LLU;
  static volatile uint64_t t62 = 316LLU;
  uint64_t x3781 = 190LLU;
  volatile uint64_t x3811 = UINT64_MAX;
  int16_t x3812 = 1;
  static int16_t x3813 = INT16_MIN;
  static volatile uint64_t t66 = 482LLU;
  static int64_t x4218 = INT64_MIN;
  static volatile uint64_t x4219 = UINT64_MAX;
  static volatile uint64_t t70 = 6853280580598711324LLU;
  static uint32_t x4377 = 28120U;
  static volatile uint16_t x4400 = 1U;
  int64_t x4419 = -3550511207549LL;
  uint8_t x4420 = 0U;
  uint8_t x4507 = UINT8_MAX;
  volatile uint64_t t77 = 124355976325806792LLU;
  uint32_t t80 = 122240U;
  uint16_t x4950 = 1U;
  uint64_t x4951 = 118722526721LLU;
  static volatile uint8_t x4952 = 6U;
  int32_t t82 = -5870305;
  uint16_t x4968 = 1U;
  uint16_t x5205 = 1689U;
  int64_t x5273 = -14LL;
  uint32_t x5278 = UINT32_MAX;
  volatile int64_t x5290 = -2762826487614592LL;
  volatile int64_t t87 = 9219488844539344LL;
  uint32_t x5382 = 47042848U;
  uint16_t x5433 = 3U;
  static uint8_t x5436 = 9U;
  volatile int16_t x5459 = -80;
  int8_t x5460 = 5;
  static int64_t x5489 = -1LL;
  volatile int8_t x5492 = 2;
  volatile int64_t t91 = 0LL;
  uint16_t x5707 = 150U;
  uint32_t x5863 = 0U;
  volatile int64_t t96 = 444LL;
  uint8_t x5900 = 6U;
  volatile uint64_t t99 = 43007416603572LLU;
  static volatile uint32_t x6219 = UINT32_MAX;
  uint64_t x6220 = 21LLU;
  int8_t x6257 = 2;
  uint32_t t101 = 23814U;
  volatile uint32_t t102 = 2545U;
  uint64_t t104 = 98338213045717850LLU;
  uint64_t t106 = 8LLU;
  uint8_t x7126 = 22U;
  static int32_t t108 = 367314;
  volatile uint32_t x7132 = 16U;
  int32_t x7227 = INT32_MIN;
  static int16_t x7355 = 13797;
  uint16_t x7356 = 29U;
  uint64_t t112 = 963148LLU;
  static uint16_t x7368 = 4U;
  uint64_t t115 = 12LLU;
  int64_t x7553 = -701951498627396LL;
  static uint64_t x7562 = 4068260461295216198LLU;
  uint64_t t119 = 2302035234406398460LLU;
  uint64_t x7594 = 33227625LLU;
  int64_t x7629 = -1637725817702LL;
  static volatile int16_t x7630 = INT16_MIN;
  static int16_t x7780 = 3;
  int32_t x7929 = 5727;
  int32_t x8233 = INT32_MIN;
  static volatile int64_t t128 = 177114692LL;
  int32_t x8261 = INT32_MIN;
  volatile int64_t x8263 = -1424LL;
  int32_t x8291 = -1;
  static volatile int32_t t131 = -15874;
  uint64_t x8314 = UINT64_MAX;
  uint8_t x8316 = 12U;
  uint64_t x8386 = 102199LLU;
  uint8_t x8387 = 30U;
  uint32_t x8388 = 1U;
  volatile uint64_t t135 = 10243019638989LLU;
  volatile uint8_t x8405 = 61U;
  int16_t x8407 = 386;
  int32_t x8408 = 11;
  uint16_t x8481 = UINT16_MAX;
  uint16_t x8483 = UINT16_MAX;
  uint8_t x8512 = 49U;
  volatile uint64_t t139 = 50979337495933066LLU;
  volatile uint64_t t140 = 1482334056LLU;
  uint64_t x8558 = UINT64_MAX;
  uint64_t x8559 = 18LLU;
  static volatile int8_t x8582 = INT8_MIN;
  int16_t x8583 = INT16_MAX;
  uint8_t x8608 = 4U;
  int8_t x8786 = INT8_MAX;
  static volatile int32_t x8953 = -5;
  static int16_t x8956 = 6;
  volatile uint32_t t148 = 54U;
  int8_t x9151 = INT8_MIN;
  uint32_t t150 = 243585U;
  uint16_t x9155 = UINT16_MAX;
  uint64_t t152 = 361426LLU;
  static int64_t x9231 = -3563988498155LL;
  int8_t x9238 = 32;
  uint16_t x9309 = UINT16_MAX;
  uint32_t x9371 = 57176404U;
  int8_t x9538 = INT8_MAX;
  uint16_t x9625 = 3U;
  uint64_t t163 = 435255646861260664LLU;
  static volatile int16_t x9709 = 110;
  volatile int16_t x9724 = 2;
  uint8_t x9744 = 45U;
  static volatile uint64_t t166 = 2286178872280390LLU;
  int16_t x9769 = 29;
  int8_t x9772 = 1;
  volatile int32_t t168 = 109292;
  uint8_t x9925 = UINT8_MAX;
  uint16_t x9953 = 26629U;
  static int8_t x9955 = 1;
  volatile int8_t x9956 = 0;
  uint32_t x10053 = 108813U;
  uint64_t x10056 = 5LLU;
  uint64_t x10074 = 56364621425026290LLU;
  static int8_t x10076 = 1;
  volatile uint64_t t172 = 1967LLU;
  uint32_t x10363 = 28U;
  int32_t x10419 = 1301325;
  volatile uint16_t x10435 = 124U;
  static uint8_t x10482 = 95U;
  uint32_t t179 = 72U;
  static uint64_t x11007 = 21458741460004LLU;
  uint64_t t182 = 3562573LLU;
  uint64_t x11043 = UINT64_MAX;
  volatile uint64_t t184 = 549302LLU;
  uint64_t t185 = 7LLU;
  int32_t t190 = -65529;
  uint16_t x11499 = 0U;
  int8_t x11631 = -1;
  int16_t x11702 = INT16_MIN;
  uint32_t x11704 = 2U;
  int32_t x11934 = INT32_MIN;
  uint64_t x12159 = 8LLU;
  uint64_t t197 = 7745364LLU;
  volatile uint32_t x12225 = 22731U;
  uint32_t t198 = 3U;
  int16_t x12373 = -1;
  int32_t x12374 = -1;
  
  
  void f0(void) {
      	uint16_t x18 = 1791U;
  	volatile int64_t x19 = 4958881633LL;
  	volatile uint8_t x20 = 0U;
  
      t0 = (((x17+x18)*x19)<<x20);
  
      if (t0 != 78747040332040LL) { NG(); } else { ; }
  	
  }
  
  void f1(void) {
      	int16_t x102 = INT16_MIN;
  	int8_t x103 = INT8_MIN;
  	uint16_t x104 = 3U;
  	volatile int32_t t1 = 2723224;
  
      t1 = (((x101+x102)*x103)<<x104);
  
      if (t1 != 33554432) { NG(); } else { ; }
  	
  }
  
  void f2(void) {
      	int32_t x105 = 1006485;
  	int32_t x106 = -1;
  	volatile uint8_t x107 = UINT8_MAX;
  	volatile int16_t x108 = 1;
  	int32_t t2 = 29;
  
      t2 = (((x105+x106)*x107)<<x108);
  
      if (t2 != 513306840) { NG(); } else { ; }
  	
  }
  
  void f3(void) {
      	int16_t x121 = INT16_MIN;
  	static uint64_t x122 = 7868709LLU;
  	uint8_t x124 = 0U;
  	uint64_t t3 = 1705LLU;
  
      t3 = (((x121+x122)*x123)<<x124);
  
      if (t3 != 23507823LLU) { NG(); } else { ; }
  	
  }
  
  void f4(void) {
      	static uint32_t x181 = 1846033822U;
  	volatile uint64_t x183 = UINT64_MAX;
  	uint32_t x184 = 21U;
  	volatile uint64_t t4 = 32513021939010842LLU;
  
      t4 = (((x181+x182)*x183)<<x184);
  
      if (t4 != 18442872660175093760LLU) { NG(); } else { ; }
  	
  }
  
  void f5(void) {
      	int32_t x229 = INT32_MIN;
  	volatile int32_t x230 = INT32_MAX;
  	volatile int16_t x231 = INT16_MIN;
  	volatile int32_t x232 = 3;
  	int32_t t5 = 1350262;
  
      t5 = (((x229+x230)*x231)<<x232);
  
      if (t5 != 262144) { NG(); } else { ; }
  	
  }
  
  void f6(void) {
      	uint64_t x250 = 1116LLU;
  
      t6 = (((x249+x250)*x251)<<x252);
  
      if (t6 != 18446743319876403840LLU) { NG(); } else { ; }
  	
  }
  
  void f7(void) {
      	static uint32_t x261 = UINT32_MAX;
  	int32_t x262 = 406409;
  	int16_t x263 = 379;
  	int32_t x264 = 27;
  
      t7 = (((x261+x262)*x263)<<x264);
  
      if (t7 != 3221225472U) { NG(); } else { ; }
  	
  }
  
  void f8(void) {
      	static volatile int8_t x289 = INT8_MIN;
  	int64_t x290 = -433188486LL;
  	int8_t x291 = -1;
  	static uint16_t x292 = 25U;
  	static int64_t t8 = -373099394LL;
  
      t8 = (((x289+x290)*x291)<<x292);
  
      if (t8 != 14535397891637248LL) { NG(); } else { ; }
  	
  }
  
  void f9(void) {
      	int32_t x301 = INT32_MAX;
  	volatile uint32_t x302 = 241843301U;
  	uint8_t x304 = 24U;
  	static volatile uint32_t t9 = 196415U;
  
      t9 = (((x301+x302)*x303)<<x304);
  
      if (t9 != 335544320U) { NG(); } else { ; }
  	
  }
  
  void f10(void) {
      	uint32_t x306 = 2281818U;
  	static int8_t x307 = INT8_MIN;
  	uint8_t x308 = 0U;
  	uint32_t t10 = 145U;
  
      t10 = (((x305+x306)*x307)<<x308);
  
      if (t10 != 3380833792U) { NG(); } else { ; }
  	
  }
  
  void f11(void) {
      	uint32_t x489 = UINT32_MAX;
  	uint32_t x492 = 21U;
  	uint32_t t11 = 53809U;
  
      t11 = (((x489+x490)*x491)<<x492);
  
      if (t11 != 536870912U) { NG(); } else { ; }
  	
  }
  
  void f12(void) {
      	int16_t x509 = -45;
  	int64_t x510 = 963845181242LL;
  	uint32_t x511 = 68U;
  	int8_t x512 = 0;
  	static volatile int64_t t12 = 446735LL;
  
      t12 = (((x509+x510)*x511)<<x512);
  
      if (t12 != 65541472321396LL) { NG(); } else { ; }
  	
  }
  
  void f13(void) {
      	int32_t x565 = INT32_MIN;
  	uint64_t x566 = 253422839LLU;
  	static int8_t x567 = INT8_MIN;
  	static uint64_t t13 = 9729LLU;
  
      t13 = (((x565+x566)*x567)<<x568);
  
      if (t13 != 484879567104LLU) { NG(); } else { ; }
  	
  }
  
  void f14(void) {
      	volatile int32_t x637 = 0;
  	uint32_t x638 = UINT32_MAX;
  	volatile uint32_t x639 = 3U;
  	int32_t x640 = 29;
  
      t14 = (((x637+x638)*x639)<<x640);
  
      if (t14 != 2684354560U) { NG(); } else { ; }
  	
  }
  
  void f15(void) {
      	uint32_t x685 = 12525252U;
  	int16_t x686 = INT16_MAX;
  	int8_t x687 = -1;
  	uint64_t x688 = 5LLU;
  	uint32_t t15 = 819U;
  
      t15 = (((x685+x686)*x687)<<x688);
  
      if (t15 != 3893110688U) { NG(); } else { ; }
  	
  }
  
  void f16(void) {
      	uint32_t x729 = 92431U;
  	uint32_t x730 = 32966772U;
  	uint8_t x731 = 4U;
  	int16_t x732 = 6;
  	uint32_t t16 = 1006358159U;
  
      t16 = (((x729+x730)*x731)<<x732);
  
      if (t16 != 4168188672U) { NG(); } else { ; }
  	
  }
  
  void f17(void) {
      	uint32_t x789 = 1U;
  	uint32_t x790 = UINT32_MAX;
  	volatile int32_t x791 = INT32_MIN;
  	volatile uint16_t x792 = 19U;
  
      t17 = (((x789+x790)*x791)<<x792);
  
      if (t17 != 0U) { NG(); } else { ; }
  	
  }
  
  void f18(void) {
      	int64_t x793 = INT64_MIN;
  	volatile int16_t x794 = INT16_MAX;
  	static uint64_t x795 = UINT64_MAX;
  	int16_t x796 = 0;
  	volatile uint64_t t18 = 19274246005760225LLU;
  
      t18 = (((x793+x794)*x795)<<x796);
  
      if (t18 != 9223372036854743041LLU) { NG(); } else { ; }
  	
  }
  
  void f19(void) {
      	uint64_t x801 = 1691450LLU;
  	int32_t x802 = 5513352;
  	int8_t x803 = INT8_MIN;
  	static volatile uint64_t t19 = 4986708268874LLU;
  
      t19 = (((x801+x802)*x803)<<x804);
  
      if (t19 != 18446744066331834368LLU) { NG(); } else { ; }
  	
  }
  
  void f20(void) {
      	int64_t x861 = -1LL;
  	int8_t x862 = INT8_MIN;
  	int16_t x863 = INT16_MIN;
  	volatile int64_t t20 = 14308186728930321LL;
  
      t20 = (((x861+x862)*x863)<<x864);
  
      if (t20 != 4538783999459328LL) { NG(); } else { ; }
  	
  }
  
  void f21(void) {
      	int8_t x1073 = INT8_MAX;
  	volatile uint64_t x1074 = UINT64_MAX;
  	int8_t x1075 = -17;
  	uint8_t x1076 = 3U;
  	uint64_t t21 = 3027131773469534LLU;
  
      t21 = (((x1073+x1074)*x1075)<<x1076);
  
      if (t21 != 18446744073709534480LLU) { NG(); } else { ; }
  	
  }
  
  void f22(void) {
      	uint64_t x1117 = 2LLU;
  	static int64_t x1118 = INT64_MIN;
  	int64_t x1119 = -1LL;
  	int16_t x1120 = 45;
  	uint64_t t22 = 25828610418569088LLU;
  
      t22 = (((x1117+x1118)*x1119)<<x1120);
  
      if (t22 != 18446673704965373952LLU) { NG(); } else { ; }
  	
  }
  
  void f23(void) {
      	uint16_t x1169 = 15854U;
  	volatile int16_t x1170 = INT16_MAX;
  	volatile uint16_t x1171 = 17U;
  	uint8_t x1172 = 1U;
  	static int32_t t23 = 507533924;
  
      t23 = (((x1169+x1170)*x1171)<<x1172);
  
      if (t23 != 1653114) { NG(); } else { ; }
  	
  }
  
  void f24(void) {
      	int16_t x1257 = -1;
  	int32_t x1258 = 6614032;
  	volatile uint64_t t24 = 35404LLU;
  
      t24 = (((x1257+x1258)*x1259)<<x1260);
  
      if (t24 != 18446744073702937585LLU) { NG(); } else { ; }
  	
  }
  
  void f25(void) {
      	volatile int32_t x1345 = 546316207;
  	uint64_t x1346 = 13647LLU;
  	uint64_t x1347 = UINT64_MAX;
  	volatile uint8_t x1348 = 31U;
  	uint64_t t25 = 310563018907336600LLU;
  
      t25 = (((x1345+x1346)*x1347)<<x1348);
  
      if (t25 != 17273509645830324224LLU) { NG(); } else { ; }
  	
  }
  
  void f26(void) {
      	int16_t x1353 = INT16_MIN;
  	int8_t x1355 = INT8_MIN;
  	uint8_t x1356 = 0U;
  	static volatile int32_t t26 = 2;
  
      t26 = (((x1353+x1354)*x1355)<<x1356);
  
      if (t26 != 8388608) { NG(); } else { ; }
  	
  }
  
  void f27(void) {
      	int16_t x1409 = -1;
  	int8_t x1410 = 34;
  	volatile int8_t x1411 = INT8_MAX;
  	uint8_t x1412 = 18U;
  	volatile int32_t t27 = -19;
  
      t27 = (((x1409+x1410)*x1411)<<x1412);
  
      if (t27 != 1098645504) { NG(); } else { ; }
  	
  }
  
  void f28(void) {
      	int8_t x1493 = INT8_MAX;
  	static uint64_t x1494 = UINT64_MAX;
  	static int16_t x1495 = 3;
  	uint8_t x1496 = 5U;
  	volatile uint64_t t28 = 0LLU;
  
      t28 = (((x1493+x1494)*x1495)<<x1496);
  
      if (t28 != 12096LLU) { NG(); } else { ; }
  	
  }
  
  void f29(void) {
      	static uint8_t x1565 = UINT8_MAX;
  	int8_t x1566 = -1;
  	static uint8_t x1567 = UINT8_MAX;
  	uint16_t x1568 = 9U;
  	int32_t t29 = 0;
  
      t29 = (((x1565+x1566)*x1567)<<x1568);
  
      if (t29 != 33162240) { NG(); } else { ; }
  	
  }
  
  void f30(void) {
      	int8_t x1609 = -1;
  	int8_t x1610 = 1;
  	uint8_t x1612 = 11U;
  	int32_t t30 = 6;
  
      t30 = (((x1609+x1610)*x1611)<<x1612);
  
      if (t30 != 0) { NG(); } else { ; }
  	
  }
  
  void f31(void) {
      	int64_t x1761 = -1LL;
  	volatile int16_t x1762 = INT16_MIN;
  	volatile int16_t x1763 = INT16_MIN;
  	static int8_t x1764 = 1;
  	int64_t t31 = 0LL;
  
      t31 = (((x1761+x1762)*x1763)<<x1764);
  
      if (t31 != 2147549184LL) { NG(); } else { ; }
  	
  }
  
  void f32(void) {
      	static int64_t x1833 = -839885934604LL;
  	int64_t x1835 = -1LL;
  	volatile int8_t x1836 = 8;
  	volatile int64_t t32 = -1LL;
  
      t32 = (((x1833+x1834)*x1835)<<x1836);
  
      if (t32 != 215010803277824LL) { NG(); } else { ; }
  	
  }
  
  void f33(void) {
      	uint32_t x1981 = 2459768U;
  	uint32_t x1982 = 62U;
  	static uint8_t x1983 = 25U;
  	static uint16_t x1984 = 6U;
  
      t33 = (((x1981+x1982)*x1983)<<x1984);
  
      if (t33 != 3935728000U) { NG(); } else { ; }
  	
  }
  
  void f34(void) {
      	uint8_t x2021 = 8U;
  	int32_t x2022 = -1;
  	static volatile uint16_t x2023 = 22U;
  	volatile int32_t t34 = -25758704;
  
      t34 = (((x2021+x2022)*x2023)<<x2024);
  
      if (t34 != 19712) { NG(); } else { ; }
  	
  }
  
  void f35(void) {
      	static int8_t x2217 = INT8_MAX;
  	int16_t x2218 = -1;
  	uint32_t x2220 = 4U;
  	int32_t t35 = -5581394;
  
      t35 = (((x2217+x2218)*x2219)<<x2220);
  
      if (t35 != 10080) { NG(); } else { ; }
  	
  }
  
  void f36(void) {
      	int16_t x2225 = -1;
  	static volatile uint64_t x2226 = UINT64_MAX;
  	uint8_t x2228 = 0U;
  	volatile uint64_t t36 = 1242LLU;
  
      t36 = (((x2225+x2226)*x2227)<<x2228);
  
      if (t36 != 18446744073709551608LLU) { NG(); } else { ; }
  	
  }
  
  void f37(void) {
      	volatile int16_t x2257 = -1;
  	int8_t x2258 = INT8_MIN;
  	volatile uint8_t x2260 = 0U;
  	static int32_t t37 = -1;
  
      t37 = (((x2257+x2258)*x2259)<<x2260);
  
      if (t37 != 0) { NG(); } else { ; }
  	
  }
  
  void f38(void) {
      	int16_t x2321 = -1;
  	uint32_t x2322 = UINT32_MAX;
  	static volatile uint8_t x2324 = 10U;
  
      t38 = (((x2321+x2322)*x2323)<<x2324);
  
      if (t38 != 2048U) { NG(); } else { ; }
  	
  }
  
  void f39(void) {
      	int16_t x2441 = INT16_MIN;
  	uint8_t x2442 = UINT8_MAX;
  	uint64_t x2443 = 12198933582595164LLU;
  	int8_t x2444 = 1;
  	volatile uint64_t t39 = 54298067LLU;
  
      t39 = (((x2441+x2442)*x2443)<<x2444);
  
      if (t39 != 18408884101387136840LLU) { NG(); } else { ; }
  	
  }
  
  void f40(void) {
      	static volatile uint8_t x2449 = 1U;
  	int32_t x2450 = -1;
  	static int16_t x2451 = -12;
  	volatile uint8_t x2452 = 25U;
  	int32_t t40 = 234;
  
      t40 = (((x2449+x2450)*x2451)<<x2452);
  
      if (t40 != 0) { NG(); } else { ; }
  	
  }
  
  void f41(void) {
      	int8_t x2473 = -1;
  	int32_t x2474 = INT32_MAX;
  	uint64_t x2475 = 30LLU;
  
      t41 = (((x2473+x2474)*x2475)<<x2476);
  
      if (t41 != 257698037520LLU) { NG(); } else { ; }
  	
  }
  
  void f42(void) {
      	int16_t x2481 = -1;
  	volatile uint32_t x2482 = 28220U;
  	int16_t x2484 = 1;
  	volatile uint32_t t42 = 610395U;
  
      t42 = (((x2481+x2482)*x2483)<<x2484);
  
      if (t42 != 24381216U) { NG(); } else { ; }
  	
  }
  
  void f43(void) {
      	static int8_t x2509 = INT8_MIN;
  	int8_t x2510 = -44;
  	int32_t x2511 = -1;
  	int32_t t43 = -13866859;
  
      t43 = (((x2509+x2510)*x2511)<<x2512);
  
      if (t43 != 688) { NG(); } else { ; }
  	
  }
  
  void f44(void) {
      	static uint64_t x2553 = 5245LLU;
  	uint8_t x2554 = 56U;
  	int32_t x2555 = INT32_MAX;
  	uint64_t t44 = 38177825946304529LLU;
  
      t44 = (((x2553+x2554)*x2555)<<x2556);
  
      if (t44 != 10808639105689190400LLU) { NG(); } else { ; }
  	
  }
  
  void f45(void) {
      	int16_t x2581 = 0;
  	int32_t x2582 = INT32_MAX;
  	volatile int32_t x2584 = 8;
  	uint32_t t45 = 25153U;
  
      t45 = (((x2581+x2582)*x2583)<<x2584);
  
      if (t45 != 4293435648U) { NG(); } else { ; }
  	
  }
  
  void f46(void) {
      	int32_t x2605 = INT32_MIN;
  	int32_t x2606 = 8102281;
  	uint32_t x2608 = 7U;
  	volatile uint32_t t46 = 62466U;
  
      t46 = (((x2605+x2606)*x2607)<<x2608);
  
      if (t46 != 3257875328U) { NG(); } else { ; }
  	
  }
  
  void f47(void) {
      	int32_t x2741 = -1;
  	int8_t x2742 = INT8_MIN;
  	static int16_t x2744 = 0;
  
      t47 = (((x2741+x2742)*x2743)<<x2744);
  
      if (t47 != 1548) { NG(); } else { ; }
  	
  }
  
  void f48(void) {
      	int8_t x2809 = INT8_MIN;
  	static uint8_t x2810 = 12U;
  	int8_t x2811 = INT8_MIN;
  	int8_t x2812 = 3;
  	int32_t t48 = -612015;
  
      t48 = (((x2809+x2810)*x2811)<<x2812);
  
      if (t48 != 118784) { NG(); } else { ; }
  	
  }
  
  void f49(void) {
      	int8_t x2821 = INT8_MAX;
  	volatile int32_t t49 = 116;
  
      t49 = (((x2821+x2822)*x2823)<<x2824);
  
      if (t49 != 2147483521) { NG(); } else { ; }
  	
  }
  
  void f50(void) {
      	int8_t x2873 = -1;
  	int64_t x2874 = 213664635214817LL;
  	uint8_t x2876 = 3U;
  	int64_t t50 = -310906094797LL;
  
      t50 = (((x2873+x2874)*x2875)<<x2876);
  
      if (t50 != 1709317081718528LL) { NG(); } else { ; }
  	
  }
  
  void f51(void) {
      	uint32_t x3001 = UINT32_MAX;
  	int16_t x3002 = INT16_MAX;
  	int32_t x3003 = 370;
  	volatile uint32_t t51 = 922811U;
  
      t51 = (((x3001+x3002)*x3003)<<x3004);
  
      if (t51 != 4246470656U) { NG(); } else { ; }
  	
  }
  
  void f52(void) {
      	volatile int8_t x3009 = INT8_MIN;
  	int64_t x3010 = 106692100447538LL;
  	uint64_t x3011 = 7942542013LLU;
  	uint8_t x3012 = 2U;
  	uint64_t t52 = 164894439LLU;
  
      t52 = (((x3009+x3010)*x3011)<<x3012);
  
      if (t52 != 18290746876269153704LLU) { NG(); } else { ; }
  	
  }
  
  void f53(void) {
      	volatile int16_t x3021 = -1;
  	int32_t x3022 = INT32_MAX;
  	uint32_t x3023 = UINT32_MAX;
  	uint8_t x3024 = 0U;
  
      t53 = (((x3021+x3022)*x3023)<<x3024);
  
      if (t53 != 2147483650U) { NG(); } else { ; }
  	
  }
  
  void f54(void) {
      	uint8_t x3265 = 4U;
  	uint8_t x3266 = 3U;
  	volatile int64_t x3267 = 59740LL;
  	volatile int8_t x3268 = 1;
  
      t54 = (((x3265+x3266)*x3267)<<x3268);
  
      if (t54 != 836360LL) { NG(); } else { ; }
  	
  }
  
  void f55(void) {
      	int64_t x3329 = INT64_MIN;
  	uint8_t x3330 = UINT8_MAX;
  	uint64_t x3331 = UINT64_MAX;
  	static uint16_t x3332 = 0U;
  
      t55 = (((x3329+x3330)*x3331)<<x3332);
  
      if (t55 != 9223372036854775553LLU) { NG(); } else { ; }
  	
  }
  
  void f56(void) {
      	static uint64_t x3341 = 751830LLU;
  	uint32_t x3342 = 4518U;
  	uint32_t x3343 = UINT32_MAX;
  	uint8_t x3344 = 11U;
  	uint64_t t56 = 2126327260647813706LLU;
  
      t56 = (((x3341+x3342)*x3343)<<x3344);
  
      if (t56 != 6652907363611975680LLU) { NG(); } else { ; }
  	
  }
  
  void f57(void) {
      	int32_t x3369 = 0;
  	int64_t x3370 = -22698297580LL;
  	static int16_t x3371 = -1;
  	static int32_t x3372 = 8;
  	static int64_t t57 = 3LL;
  
      t57 = (((x3369+x3370)*x3371)<<x3372);
  
      if (t57 != 5810764180480LL) { NG(); } else { ; }
  	
  }
  
  void f58(void) {
      	volatile int32_t x3381 = INT32_MIN;
  	volatile uint32_t x3383 = 116U;
  	uint32_t t58 = 353710326U;
  
      t58 = (((x3381+x3382)*x3383)<<x3384);
  
      if (t58 != 495088U) { NG(); } else { ; }
  	
  }
  
  void f59(void) {
      	static uint16_t x3429 = 1801U;
  	static uint32_t x3431 = 1U;
  	int16_t x3432 = 1;
  	uint32_t t59 = 5712495U;
  
      t59 = (((x3429+x3430)*x3431)<<x3432);
  
      if (t59 != 3346U) { NG(); } else { ; }
  	
  }
  
  void f60(void) {
      	uint64_t x3465 = 23015483937122757LLU;
  	volatile int8_t x3466 = INT8_MIN;
  	int8_t x3467 = -1;
  	int8_t x3468 = 26;
  
      t60 = (((x3465+x3466)*x3467)<<x3468);
  
      if (t60 != 2899861153695924224LLU) { NG(); } else { ; }
  	
  }
  
  void f61(void) {
      	uint8_t x3586 = 67U;
  	volatile int64_t x3587 = 11426907535LL;
  	static uint8_t x3588 = 12U;
  	int64_t t61 = -1032500383905238743LL;
  
      t61 = (((x3585+x3586)*x3587)<<x3588);
  
      if (t61 != 3089104475381760LL) { NG(); } else { ; }
  	
  }
  
  void f62(void) {
      	volatile int8_t x3694 = -1;
  	int16_t x3695 = INT16_MIN;
  	int8_t x3696 = 17;
  
      t62 = (((x3693+x3694)*x3695)<<x3696);
  
      if (t62 != 6741985377722040320LLU) { NG(); } else { ; }
  	
  }
  
  void f63(void) {
      	int32_t x3773 = -1;
  	static int16_t x3774 = INT16_MIN;
  	volatile int16_t x3775 = -1;
  	uint8_t x3776 = 0U;
  	int32_t t63 = 187943;
  
      t63 = (((x3773+x3774)*x3775)<<x3776);
  
      if (t63 != 32769) { NG(); } else { ; }
  	
  }
  
  void f64(void) {
      	volatile uint16_t x3782 = 202U;
  	static int8_t x3783 = INT8_MIN;
  	volatile uint32_t x3784 = 3U;
  	volatile uint64_t t64 = 5913LLU;
  
      t64 = (((x3781+x3782)*x3783)<<x3784);
  
      if (t64 != 18446744073709150208LLU) { NG(); } else { ; }
  	
  }
  
  void f65(void) {
      	static uint64_t x3809 = 88679839212LLU;
  	volatile int64_t x3810 = INT64_MAX;
  	volatile uint64_t t65 = 242LLU;
  
      t65 = (((x3809+x3810)*x3811)<<x3812);
  
      if (t65 != 18446743896349873194LLU) { NG(); } else { ; }
  	
  }
  
  void f66(void) {
      	static int16_t x3814 = INT16_MIN;
  	uint64_t x3815 = UINT64_MAX;
  	static int8_t x3816 = 1;
  
      t66 = (((x3813+x3814)*x3815)<<x3816);
  
      if (t66 != 131072LLU) { NG(); } else { ; }
  	
  }
  
  void f67(void) {
      	uint32_t x4149 = UINT32_MAX;
  	volatile uint32_t x4150 = 379U;
  	static int8_t x4151 = INT8_MIN;
  	volatile uint16_t x4152 = 19U;
  	static volatile uint32_t t67 = 127577358U;
  
      t67 = (((x4149+x4150)*x4151)<<x4152);
  
      if (t67 != 402653184U) { NG(); } else { ; }
  	
  }
  
  void f68(void) {
      	uint8_t x4217 = UINT8_MAX;
  	int16_t x4220 = 9;
  	static uint64_t t68 = 1814LLU;
  
      t68 = (((x4217+x4218)*x4219)<<x4220);
  
      if (t68 != 18446744073709421056LLU) { NG(); } else { ; }
  	
  }
  
  void f69(void) {
      	uint16_t x4249 = 1033U;
  	static int8_t x4250 = INT8_MAX;
  	uint16_t x4251 = 205U;
  	int32_t x4252 = 1;
  	volatile int32_t t69 = 170192965;
  
      t69 = (((x4249+x4250)*x4251)<<x4252);
  
      if (t69 != 475600) { NG(); } else { ; }
  	
  }
  
  void f70(void) {
      	int64_t x4261 = INT64_MIN;
  	volatile uint64_t x4262 = 175202638LLU;
  	volatile int32_t x4263 = 79655;
  	static uint8_t x4264 = 2U;
  
      t70 = (((x4261+x4262)*x4263)<<x4264);
  
      if (t70 != 55823064519560LLU) { NG(); } else { ; }
  	
  }
  
  void f71(void) {
      	volatile int32_t x4321 = INT32_MAX;
  	uint64_t x4322 = UINT64_MAX;
  	int64_t x4323 = -1LL;
  	volatile uint8_t x4324 = 2U;
  	volatile uint64_t t71 = 108746470109LLU;
  
      t71 = (((x4321+x4322)*x4323)<<x4324);
  
      if (t71 != 18446744065119617032LLU) { NG(); } else { ; }
  	
  }
  
  void f72(void) {
      	int8_t x4345 = INT8_MIN;
  	static int16_t x4346 = -1;
  	int8_t x4347 = -5;
  	uint16_t x4348 = 1U;
  	volatile int32_t t72 = 432182;
  
      t72 = (((x4345+x4346)*x4347)<<x4348);
  
      if (t72 != 1290) { NG(); } else { ; }
  	
  }
  
  void f73(void) {
      	static uint32_t x4373 = UINT32_MAX;
  	volatile int8_t x4374 = -1;
  	uint32_t x4375 = 1U;
  	uint8_t x4376 = 8U;
  	uint32_t t73 = 2U;
  
      t73 = (((x4373+x4374)*x4375)<<x4376);
  
      if (t73 != 4294966784U) { NG(); } else { ; }
  	
  }
  
  void f74(void) {
      	uint32_t x4378 = 43057U;
  	int8_t x4379 = INT8_MIN;
  	uint8_t x4380 = 2U;
  	volatile uint32_t t74 = 27322927U;
  
      t74 = (((x4377+x4378)*x4379)<<x4380);
  
      if (t74 != 4258524672U) { NG(); } else { ; }
  	
  }
  
  void f75(void) {
      	int32_t x4397 = 346102389;
  	int16_t x4398 = INT16_MAX;
  	uint32_t x4399 = UINT32_MAX;
  	volatile uint32_t t75 = 957646601U;
  
      t75 = (((x4397+x4398)*x4399)<<x4400);
  
      if (t75 != 3602696984U) { NG(); } else { ; }
  	
  }
  
  void f76(void) {
      	int16_t x4417 = INT16_MIN;
  	volatile int16_t x4418 = -972;
  	int64_t t76 = -4286104243572138LL;
  
      t76 = (((x4417+x4418)*x4419)<<x4420);
  
      if (t76 != 119794248142703260LL) { NG(); } else { ; }
  	
  }
  
  void f77(void) {
      	uint64_t x4505 = 63908095304LLU;
  	int32_t x4506 = INT32_MIN;
  	int8_t x4508 = 2;
  
      t77 = (((x4505+x4506)*x4507)<<x4508);
  
      if (t77 != 62995823889120LLU) { NG(); } else { ; }
  	
  }
  
  void f78(void) {
      	int32_t x4525 = 53809;
  	uint32_t x4526 = 8953U;
  	volatile int32_t x4527 = INT32_MAX;
  	uint8_t x4528 = 10U;
  	uint32_t t78 = 51714U;
  
      t78 = (((x4525+x4526)*x4527)<<x4528);
  
      if (t78 != 4230699008U) { NG(); } else { ; }
  	
  }
  
  void f79(void) {
      	int64_t x4585 = INT64_MAX;
  	int16_t x4586 = -1;
  	uint64_t x4587 = 6892152955773295402LLU;
  	static uint8_t x4588 = 7U;
  	static volatile uint64_t t79 = 3351716480LLU;
  
      t79 = (((x4585+x4586)*x4587)<<x4588);
  
      if (t79 != 6496274398153332224LLU) { NG(); } else { ; }
  	
  }
  
  void f80(void) {
      	int8_t x4845 = INT8_MAX;
  	uint32_t x4846 = UINT32_MAX;
  	uint8_t x4847 = UINT8_MAX;
  	uint16_t x4848 = 0U;
  
      t80 = (((x4845+x4846)*x4847)<<x4848);
  
      if (t80 != 32130U) { NG(); } else { ; }
  	
  }
  
  void f81(void) {
      	volatile int32_t x4949 = INT32_MIN;
  	static uint64_t t81 = 13420306724986LLU;
  
      t81 = (((x4949+x4950)*x4951)<<x4952);
  
      if (t81 != 8268686745399164992LLU) { NG(); } else { ; }
  	
  }
  
  void f82(void) {
      	int16_t x4957 = -1;
  	int8_t x4958 = 40;
  	uint8_t x4959 = UINT8_MAX;
  	uint16_t x4960 = 1U;
  
      t82 = (((x4957+x4958)*x4959)<<x4960);
  
      if (t82 != 19890) { NG(); } else { ; }
  	
  }
  
  void f83(void) {
      	uint8_t x4965 = 25U;
  	uint64_t x4966 = 11169LLU;
  	uint8_t x4967 = 121U;
  	static volatile uint64_t t83 = 5LLU;
  
      t83 = (((x4965+x4966)*x4967)<<x4968);
  
      if (t83 != 2708948LLU) { NG(); } else { ; }
  	
  }
  
  void f84(void) {
      	static int8_t x5206 = INT8_MIN;
  	uint32_t x5207 = 1U;
  	int8_t x5208 = 1;
  	static volatile uint32_t t84 = 588U;
  
      t84 = (((x5205+x5206)*x5207)<<x5208);
  
      if (t84 != 3122U) { NG(); } else { ; }
  	
  }
  
  void f85(void) {
      	uint16_t x5274 = 28U;
  	int32_t x5275 = INT32_MAX;
  	int8_t x5276 = 1;
  	int64_t t85 = -25LL;
  
      t85 = (((x5273+x5274)*x5275)<<x5276);
  
      if (t85 != 60129542116LL) { NG(); } else { ; }
  	
  }
  
  void f86(void) {
      	int8_t x5277 = INT8_MAX;
  	int8_t x5279 = -1;
  	volatile uint8_t x5280 = 3U;
  	volatile uint32_t t86 = 105U;
  
      t86 = (((x5277+x5278)*x5279)<<x5280);
  
      if (t86 != 4294966288U) { NG(); } else { ; }
  	
  }
  
  void f87(void) {
      	int8_t x5289 = 1;
  	int32_t x5291 = 0;
  	volatile int8_t x5292 = 1;
  
      t87 = (((x5289+x5290)*x5291)<<x5292);
  
      if (t87 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f88(void) {
      	uint16_t x5381 = 1U;
  	int16_t x5383 = INT16_MAX;
  	uint16_t x5384 = 1U;
  	volatile uint32_t t88 = 9046U;
  
      t88 = (((x5381+x5382)*x5383)<<x5384);
  
      if (t88 != 3414515134U) { NG(); } else { ; }
  	
  }
  
  void f89(void) {
      	uint64_t x5434 = 467426006LLU;
  	int8_t x5435 = INT8_MIN;
  	uint64_t t89 = 43588LLU;
  
      t89 = (((x5433+x5434)*x5435)<<x5436);
  
      if (t89 != 18446713440478625792LLU) { NG(); } else { ; }
  	
  }
  
  void f90(void) {
      	int32_t x5457 = 7;
  	volatile uint32_t x5458 = UINT32_MAX;
  	uint32_t t90 = 18U;
  
      t90 = (((x5457+x5458)*x5459)<<x5460);
  
      if (t90 != 4294951936U) { NG(); } else { ; }
  	
  }
  
  void f91(void) {
      	static int32_t x5490 = INT32_MIN;
  	int32_t x5491 = -1;
  
      t91 = (((x5489+x5490)*x5491)<<x5492);
  
      if (t91 != 8589934596LL) { NG(); } else { ; }
  	
  }
  
  void f92(void) {
      	volatile int8_t x5497 = INT8_MIN;
  	uint16_t x5498 = 309U;
  	static int8_t x5499 = INT8_MAX;
  	static uint16_t x5500 = 1U;
  	volatile int32_t t92 = 3559;
  
      t92 = (((x5497+x5498)*x5499)<<x5500);
  
      if (t92 != 45974) { NG(); } else { ; }
  	
  }
  
  void f93(void) {
      	uint8_t x5529 = 34U;
  	int16_t x5530 = INT16_MAX;
  	volatile uint32_t x5531 = 332856466U;
  	uint32_t x5532 = 1U;
  	volatile uint32_t t93 = 236U;
  
      t93 = (((x5529+x5530)*x5531)<<x5532);
  
      if (t93 != 436149668U) { NG(); } else { ; }
  	
  }
  
  void f94(void) {
      	int16_t x5705 = INT16_MIN;
  	static volatile uint32_t x5706 = 235U;
  	int16_t x5708 = 13;
  	uint32_t t94 = 6U;
  
      t94 = (((x5705+x5706)*x5707)<<x5708);
  
      if (t94 != 2973122560U) { NG(); } else { ; }
  	
  }
  
  void f95(void) {
      	static volatile uint32_t x5861 = 127U;
  	int64_t x5862 = 275386598LL;
  	static uint16_t x5864 = 1U;
  	int64_t t95 = 868LL;
  
      t95 = (((x5861+x5862)*x5863)<<x5864);
  
      if (t95 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f96(void) {
      	uint8_t x5877 = UINT8_MAX;
  	int64_t x5878 = -1LL;
  	static volatile int16_t x5879 = 0;
  	uint8_t x5880 = 31U;
  
      t96 = (((x5877+x5878)*x5879)<<x5880);
  
      if (t96 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f97(void) {
      	uint64_t x5897 = UINT64_MAX;
  	volatile int8_t x5898 = INT8_MAX;
  	int16_t x5899 = INT16_MIN;
  	uint64_t t97 = 2905LLU;
  
      t97 = (((x5897+x5898)*x5899)<<x5900);
  
      if (t97 != 18446744073445310464LLU) { NG(); } else { ; }
  	
  }
  
  void f98(void) {
      	volatile uint64_t x5905 = 12261359929299LLU;
  	int16_t x5906 = -30;
  	int8_t x5907 = INT8_MIN;
  	volatile uint8_t x5908 = 1U;
  	volatile uint64_t t98 = 70LLU;
  
      t98 = (((x5905+x5906)*x5907)<<x5908);
  
      if (t98 != 18443605165567658752LLU) { NG(); } else { ; }
  	
  }
  
  void f99(void) {
      	int16_t x6181 = INT16_MIN;
  	volatile uint64_t x6182 = UINT64_MAX;
  	volatile int64_t x6183 = 545537182535614295LL;
  	int8_t x6184 = 1;
  
      t99 = (((x6181+x6182)*x6183)<<x6184);
  
      if (t99 != 14820889903730917714LLU) { NG(); } else { ; }
  	
  }
  
  void f100(void) {
      	int16_t x6217 = INT16_MIN;
  	int8_t x6218 = -1;
  	volatile uint32_t t100 = 912U;
  
      t100 = (((x6217+x6218)*x6219)<<x6220);
  
      if (t100 != 2097152U) { NG(); } else { ; }
  	
  }
  
  void f101(void) {
      	uint32_t x6258 = 3031665U;
  	uint8_t x6259 = 0U;
  	uint32_t x6260 = 0U;
  
      t101 = (((x6257+x6258)*x6259)<<x6260);
  
      if (t101 != 0U) { NG(); } else { ; }
  	
  }
  
  void f102(void) {
      	int8_t x6333 = -22;
  	uint32_t x6334 = UINT32_MAX;
  	int32_t x6335 = -504524;
  	static int16_t x6336 = 24;
  
      t102 = (((x6333+x6334)*x6335)<<x6336);
  
      if (t102 != 1409286144U) { NG(); } else { ; }
  	
  }
  
  void f103(void) {
      	int16_t x6577 = 0;
  	int16_t x6578 = INT16_MAX;
  	uint64_t x6579 = 216LLU;
  	int8_t x6580 = 2;
  	volatile uint64_t t103 = 956190115558607656LLU;
  
      t103 = (((x6577+x6578)*x6579)<<x6580);
  
      if (t103 != 28310688LLU) { NG(); } else { ; }
  	
  }
  
  void f104(void) {
      	static int16_t x6669 = INT16_MIN;
  	int8_t x6670 = INT8_MAX;
  	uint64_t x6671 = UINT64_MAX;
  	uint8_t x6672 = 1U;
  
      t104 = (((x6669+x6670)*x6671)<<x6672);
  
      if (t104 != 65282LLU) { NG(); } else { ; }
  	
  }
  
  void f105(void) {
      	uint32_t x6697 = 436907U;
  	static volatile uint16_t x6698 = UINT16_MAX;
  	int32_t x6699 = 518018;
  	volatile uint8_t x6700 = 4U;
  	volatile uint32_t t105 = 4693U;
  
      t105 = (((x6697+x6698)*x6699)<<x6700);
  
      if (t105 != 2560689472U) { NG(); } else { ; }
  	
  }
  
  void f106(void) {
      	uint64_t x6761 = 6227LLU;
  	uint32_t x6762 = UINT32_MAX;
  	int32_t x6763 = 24366978;
  	static uint16_t x6764 = 3U;
  
      t106 = (((x6761+x6762)*x6763)<<x6764);
  
      if (t106 != 837244202569252128LLU) { NG(); } else { ; }
  	
  }
  
  void f107(void) {
      	int16_t x6805 = -1;
  	uint64_t x6806 = 487188450892058LLU;
  	int64_t x6807 = INT64_MIN;
  	uint8_t x6808 = 2U;
  	volatile uint64_t t107 = 111255016922LLU;
  
      t107 = (((x6805+x6806)*x6807)<<x6808);
  
      if (t107 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f108(void) {
      	static int8_t x7125 = INT8_MIN;
  	int16_t x7127 = INT16_MIN;
  	int8_t x7128 = 1;
  
      t108 = (((x7125+x7126)*x7127)<<x7128);
  
      if (t108 != 6946816) { NG(); } else { ; }
  	
  }
  
  void f109(void) {
      	volatile uint64_t x7129 = 110LLU;
  	static volatile int32_t x7130 = 107799;
  	int64_t x7131 = INT64_MIN;
  	uint64_t t109 = 0LLU;
  
      t109 = (((x7129+x7130)*x7131)<<x7132);
  
      if (t109 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f110(void) {
      	static int8_t x7189 = INT8_MIN;
  	volatile int32_t x7190 = -13406486;
  	uint64_t x7191 = 548LLU;
  	static uint8_t x7192 = 7U;
  	uint64_t t110 = 60863642478277LLU;
  
      t110 = (((x7189+x7190)*x7191)<<x7192);
  
      if (t110 != 18446743133316019200LLU) { NG(); } else { ; }
  	
  }
  
  void f111(void) {
      	uint64_t x7225 = 256744941068LLU;
  	int64_t x7226 = INT64_MAX;
  	int32_t x7228 = 30;
  	uint64_t t111 = 4LLU;
  
      t111 = (((x7225+x7226)*x7227)<<x7228);
  
      if (t111 != 11529215046068469760LLU) { NG(); } else { ; }
  	
  }
  
  void f112(void) {
      	uint16_t x7353 = UINT16_MAX;
  	uint64_t x7354 = UINT64_MAX;
  
      t112 = (((x7353+x7354)*x7355)<<x7356);
  
      if (t112 != 485423967293669376LLU) { NG(); } else { ; }
  	
  }
  
  void f113(void) {
      	uint32_t x7357 = 175U;
  	volatile int8_t x7358 = 15;
  	static uint32_t x7359 = 13928U;
  	volatile uint8_t x7360 = 4U;
  	volatile uint32_t t113 = 1036370U;
  
      t113 = (((x7357+x7358)*x7359)<<x7360);
  
      if (t113 != 42341120U) { NG(); } else { ; }
  	
  }
  
  void f114(void) {
      	int32_t x7365 = -2495552;
  	static volatile uint64_t x7366 = UINT64_MAX;
  	static uint64_t x7367 = UINT64_MAX;
  	uint64_t t114 = 94064559158LLU;
  
      t114 = (((x7365+x7366)*x7367)<<x7368);
  
      if (t114 != 39928848LLU) { NG(); } else { ; }
  	
  }
  
  void f115(void) {
      	int64_t x7413 = INT64_MAX;
  	int8_t x7414 = -1;
  	uint64_t x7415 = 246162227976LLU;
  	int16_t x7416 = 1;
  
      t115 = (((x7413+x7414)*x7415)<<x7416);
  
      if (t115 != 18446743089060639712LLU) { NG(); } else { ; }
  	
  }
  
  void f116(void) {
      	uint64_t x7501 = UINT64_MAX;
  	int8_t x7502 = INT8_MIN;
  	uint16_t x7503 = 0U;
  	uint8_t x7504 = 1U;
  	static volatile uint64_t t116 = 4478299LLU;
  
      t116 = (((x7501+x7502)*x7503)<<x7504);
  
      if (t116 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f117(void) {
      	volatile int32_t x7545 = INT32_MAX;
  	int64_t x7546 = -3007285609767LL;
  	uint64_t x7547 = 8LLU;
  	uint32_t x7548 = 5U;
  	uint64_t t117 = 26822LLU;
  
      t117 = (((x7545+x7546)*x7547)<<x7548);
  
      if (t117 != 18445974758349264896LLU) { NG(); } else { ; }
  	
  }
  
  void f118(void) {
      	static uint64_t x7554 = 24709178532LLU;
  	int64_t x7555 = INT64_MIN;
  	static uint16_t x7556 = 16U;
  	uint64_t t118 = 75356LLU;
  
      t118 = (((x7553+x7554)*x7555)<<x7556);
  
      if (t118 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f119(void) {
      	int16_t x7561 = INT16_MAX;
  	int8_t x7563 = 1;
  	static uint8_t x7564 = 57U;
  
      t119 = (((x7561+x7562)*x7563)<<x7564);
  
      if (t119 != 9943947977234055168LLU) { NG(); } else { ; }
  	
  }
  
  void f120(void) {
      	uint64_t x7593 = UINT64_MAX;
  	int64_t x7595 = INT64_MIN;
  	static uint8_t x7596 = 41U;
  	volatile uint64_t t120 = 570LLU;
  
      t120 = (((x7593+x7594)*x7595)<<x7596);
  
      if (t120 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f121(void) {
      	uint16_t x7631 = 0U;
  	int8_t x7632 = 1;
  	volatile int64_t t121 = 23478873878LL;
  
      t121 = (((x7629+x7630)*x7631)<<x7632);
  
      if (t121 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f122(void) {
      	volatile int8_t x7777 = 3;
  	int32_t x7778 = INT32_MIN;
  	int64_t x7779 = -1LL;
  	static int64_t t122 = -586210982201627959LL;
  
      t122 = (((x7777+x7778)*x7779)<<x7780);
  
      if (t122 != 17179869160LL) { NG(); } else { ; }
  	
  }
  
  void f123(void) {
      	volatile uint32_t x7821 = UINT32_MAX;
  	volatile uint64_t x7822 = 332LLU;
  	volatile uint16_t x7823 = UINT16_MAX;
  	int16_t x7824 = 0;
  	static uint64_t t123 = 1292897781196758LLU;
  
      t123 = (((x7821+x7822)*x7823)<<x7824);
  
      if (t123 != 281470703435445LLU) { NG(); } else { ; }
  	
  }
  
  void f124(void) {
      	uint32_t x7930 = 2U;
  	int8_t x7931 = 7;
  	volatile uint8_t x7932 = 6U;
  	static volatile uint32_t t124 = 3U;
  
      t124 = (((x7929+x7930)*x7931)<<x7932);
  
      if (t124 != 2566592U) { NG(); } else { ; }
  	
  }
  
  void f125(void) {
      	static volatile int8_t x7941 = INT8_MIN;
  	volatile uint64_t x7942 = UINT64_MAX;
  	volatile int64_t x7943 = INT64_MAX;
  	int32_t x7944 = 0;
  	uint64_t t125 = 264289511261449LLU;
  
      t125 = (((x7941+x7942)*x7943)<<x7944);
  
      if (t125 != 9223372036854775937LLU) { NG(); } else { ; }
  	
  }
  
  void f126(void) {
      	volatile int64_t x7985 = -1LL;
  	uint16_t x7986 = UINT16_MAX;
  	volatile uint32_t x7987 = UINT32_MAX;
  	uint16_t x7988 = 14U;
  	volatile int64_t t126 = -13708LL;
  
      t126 = (((x7985+x7986)*x7987)<<x7988);
  
      if (t126 != 4611545279865323520LL) { NG(); } else { ; }
  	
  }
  
  void f127(void) {
      	int8_t x8101 = INT8_MIN;
  	uint32_t x8102 = 15396833U;
  	uint16_t x8103 = 424U;
  	volatile uint8_t x8104 = 1U;
  	volatile uint32_t t127 = 2668969U;
  
      t127 = (((x8101+x8102)*x8103)<<x8104);
  
      if (t127 != 171503952U) { NG(); } else { ; }
  	
  }
  
  void f128(void) {
      	volatile int64_t x8234 = -374948129486929197LL;
  	int8_t x8235 = -1;
  	int16_t x8236 = 1;
  
      t128 = (((x8233+x8234)*x8235)<<x8236);
  
      if (t128 != 749896263268825690LL) { NG(); } else { ; }
  	
  }
  
  void f129(void) {
      	int16_t x8262 = INT16_MAX;
  	int8_t x8264 = 14;
  	volatile int64_t t129 = -255894LL;
  
      t129 = (((x8261+x8262)*x8263)<<x8264);
  
      if (t129 != 50101781373648896LL) { NG(); } else { ; }
  	
  }
  
  void f130(void) {
      	uint64_t x8277 = 18561476383021LLU;
  	int64_t x8278 = 7754813LL;
  	uint8_t x8279 = 62U;
  	volatile uint8_t x8280 = 3U;
  	volatile uint64_t t130 = 5813744717502929414LLU;
  
      t130 = (((x8277+x8278)*x8279)<<x8280);
  
      if (t130 != 9206496132365664LLU) { NG(); } else { ; }
  	
  }
  
  void f131(void) {
      	volatile uint16_t x8289 = 22169U;
  	volatile int16_t x8290 = INT16_MIN;
  	uint16_t x8292 = 13U;
  
      t131 = (((x8289+x8290)*x8291)<<x8292);
  
      if (t131 != 86827008) { NG(); } else { ; }
  	
  }
  
  void f132(void) {
      	static uint64_t x8313 = 3LLU;
  	int8_t x8315 = -1;
  	static volatile uint64_t t132 = 133794940262209065LLU;
  
      t132 = (((x8313+x8314)*x8315)<<x8316);
  
      if (t132 != 18446744073709543424LLU) { NG(); } else { ; }
  	
  }
  
  void f133(void) {
      	volatile int16_t x8333 = INT16_MAX;
  	static volatile uint32_t x8334 = 213U;
  	int32_t x8335 = -316;
  	int16_t x8336 = 1;
  	uint32_t t133 = 250754608U;
  
      t133 = (((x8333+x8334)*x8335)<<x8336);
  
      if (t133 != 4274123936U) { NG(); } else { ; }
  	
  }
  
  void f134(void) {
      	static volatile int64_t x8385 = INT64_MAX;
  	static uint64_t t134 = 106153063717171LLU;
  
      t134 = (((x8385+x8386)*x8387)<<x8388);
  
      if (t134 != 6131880LLU) { NG(); } else { ; }
  	
  }
  
  void f135(void) {
      	int16_t x8401 = INT16_MIN;
  	int32_t x8402 = -1;
  	volatile uint64_t x8403 = 259974LLU;
  	int16_t x8404 = 0;
  
      t135 = (((x8401+x8402)*x8403)<<x8404);
  
      if (t135 != 18446744065190463610LLU) { NG(); } else { ; }
  	
  }
  
  void f136(void) {
      	int16_t x8406 = -2;
  	int32_t t136 = -1;
  
      t136 = (((x8405+x8406)*x8407)<<x8408);
  
      if (t136 != 46641152) { NG(); } else { ; }
  	
  }
  
  void f137(void) {
      	uint16_t x8465 = 1U;
  	volatile int8_t x8466 = -1;
  	int16_t x8467 = INT16_MIN;
  	uint32_t x8468 = 8U;
  	volatile int32_t t137 = 24148742;
  
      t137 = (((x8465+x8466)*x8467)<<x8468);
  
      if (t137 != 0) { NG(); } else { ; }
  	
  }
  
  void f138(void) {
      	volatile int16_t x8482 = INT16_MIN;
  	int64_t x8484 = 0LL;
  	int32_t t138 = 1;
  
      t138 = (((x8481+x8482)*x8483)<<x8484);
  
      if (t138 != 2147385345) { NG(); } else { ; }
  	
  }
  
  void f139(void) {
      	int16_t x8509 = -5841;
  	volatile uint64_t x8510 = 26766674219692LLU;
  	int32_t x8511 = INT32_MIN;
  
      t139 = (((x8509+x8510)*x8511)<<x8512);
  
      if (t139 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f140(void) {
      	volatile int64_t x8521 = INT64_MAX;
  	int8_t x8522 = INT8_MIN;
  	volatile uint64_t x8523 = 26200665876LLU;
  	uint8_t x8524 = 1U;
  
      t140 = (((x8521+x8522)*x8523)<<x8524);
  
      if (t140 != 18446737313937755608LLU) { NG(); } else { ; }
  	
  }
  
  void f141(void) {
      	volatile uint16_t x8557 = 0U;
  	volatile uint64_t x8560 = 2LLU;
  	volatile uint64_t t141 = 18LLU;
  
      t141 = (((x8557+x8558)*x8559)<<x8560);
  
      if (t141 != 18446744073709551544LLU) { NG(); } else { ; }
  	
  }
  
  void f142(void) {
      	uint32_t x8581 = 14439025U;
  	uint8_t x8584 = 2U;
  	uint32_t t142 = 12952U;
  
      t142 = (((x8581+x8582)*x8583)<<x8584);
  
      if (t142 != 2691741756U) { NG(); } else { ; }
  	
  }
  
  void f143(void) {
      	static uint32_t x8605 = 1U;
  	int32_t x8606 = 10094104;
  	static int16_t x8607 = INT16_MAX;
  	uint32_t t143 = 409709U;
  
      t143 = (((x8605+x8606)*x8607)<<x8608);
  
      if (t143 != 656907888U) { NG(); } else { ; }
  	
  }
  
  void f144(void) {
      	uint32_t x8665 = 13U;
  	uint16_t x8666 = UINT16_MAX;
  	uint32_t x8667 = 790073U;
  	uint8_t x8668 = 2U;
  	volatile uint32_t t144 = 103347629U;
  
      t144 = (((x8665+x8666)*x8667)<<x8668);
  
      if (t144 != 992389808U) { NG(); } else { ; }
  	
  }
  
  void f145(void) {
      	uint64_t x8717 = 110365766325067LLU;
  	int8_t x8718 = INT8_MIN;
  	uint64_t x8719 = UINT64_MAX;
  	uint32_t x8720 = 1U;
  	static volatile uint64_t t145 = 6795272016324773402LLU;
  
      t145 = (((x8717+x8718)*x8719)<<x8720);
  
      if (t145 != 18446523342176901738LLU) { NG(); } else { ; }
  	
  }
  
  void f146(void) {
      	volatile int8_t x8757 = INT8_MIN;
  	int8_t x8758 = INT8_MIN;
  	volatile uint64_t x8759 = 204992LLU;
  	static uint16_t x8760 = 0U;
  	volatile uint64_t t146 = 1188788016558LLU;
  
      t146 = (((x8757+x8758)*x8759)<<x8760);
  
      if (t146 != 18446744073657073664LLU) { NG(); } else { ; }
  	
  }
  
  void f147(void) {
      	uint64_t x8785 = 6937933203891LLU;
  	int32_t x8787 = -1;
  	uint16_t x8788 = 10U;
  	uint64_t t147 = 2241562797565LLU;
  
      t147 = (((x8785+x8786)*x8787)<<x8788);
  
      if (t147 != 18439639630108637184LLU) { NG(); } else { ; }
  	
  }
  
  void f148(void) {
      	uint32_t x8954 = UINT32_MAX;
  	int16_t x8955 = INT16_MAX;
  
      t148 = (((x8953+x8954)*x8955)<<x8956);
  
      if (t148 != 4282384768U) { NG(); } else { ; }
  	
  }
  
  void f149(void) {
      	int8_t x8977 = 5;
  	uint64_t x8978 = UINT64_MAX;
  	volatile int8_t x8979 = -1;
  	uint16_t x8980 = 28U;
  	uint64_t t149 = 680486LLU;
  
      t149 = (((x8977+x8978)*x8979)<<x8980);
  
      if (t149 != 18446744072635809792LLU) { NG(); } else { ; }
  	
  }
  
  void f150(void) {
      	uint32_t x9149 = 128146045U;
  	uint8_t x9150 = UINT8_MAX;
  	static int8_t x9152 = 3;
  
      t150 = (((x9149+x9150)*x9151)<<x9152);
  
      if (t150 != 1922174976U) { NG(); } else { ; }
  	
  }
  
  void f151(void) {
      	uint16_t x9153 = 0U;
  	uint16_t x9154 = 0U;
  	int8_t x9156 = 12;
  	int32_t t151 = -52830;
  
      t151 = (((x9153+x9154)*x9155)<<x9156);
  
      if (t151 != 0) { NG(); } else { ; }
  	
  }
  
  void f152(void) {
      	volatile uint64_t x9189 = 8656243827820LLU;
  	int64_t x9190 = -1LL;
  	volatile int8_t x9191 = 0;
  	static uint8_t x9192 = 18U;
  
      t152 = (((x9189+x9190)*x9191)<<x9192);
  
      if (t152 != 0LLU) { NG(); } else { ; }
  	
  }
  
  void f153(void) {
      	int16_t x9229 = -88;
  	uint64_t x9230 = UINT64_MAX;
  	uint8_t x9232 = 0U;
  	uint64_t t153 = 2LLU;
  
      t153 = (((x9229+x9230)*x9231)<<x9232);
  
      if (t153 != 317194976335795LLU) { NG(); } else { ; }
  	
  }
  
  void f154(void) {
      	uint64_t x9237 = 113LLU;
  	int32_t x9239 = INT32_MAX;
  	uint32_t x9240 = 40U;
  	uint64_t t154 = 86LLU;
  
      t154 = (((x9237+x9238)*x9239)<<x9240);
  
      if (t154 != 18446584644523524096LLU) { NG(); } else { ; }
  	
  }
  
  void f155(void) {
      	int32_t x9265 = 180799;
  	uint64_t x9266 = 472LLU;
  	int16_t x9267 = -1;
  	int8_t x9268 = 51;
  	volatile uint64_t t155 = 2LLU;
  
      t155 = (((x9265+x9266)*x9267)<<x9268);
  
      if (t155 != 16089109668781096960LLU) { NG(); } else { ; }
  	
  }
  
  void f156(void) {
      	int64_t x9310 = -1LL;
  	uint16_t x9311 = 1U;
  	int16_t x9312 = 1;
  	int64_t t156 = 0LL;
  
      t156 = (((x9309+x9310)*x9311)<<x9312);
  
      if (t156 != 131068LL) { NG(); } else { ; }
  	
  }
  
  void f157(void) {
      	static int16_t x9369 = INT16_MAX;
  	static uint8_t x9370 = UINT8_MAX;
  	uint16_t x9372 = 9U;
  	uint32_t t157 = 2006191253U;
  
      t157 = (((x9369+x9370)*x9371)<<x9372);
  
      if (t157 != 2497884160U) { NG(); } else { ; }
  	
  }
  
  void f158(void) {
      	int32_t x9497 = 7917;
  	static volatile uint8_t x9498 = UINT8_MAX;
  	uint64_t x9499 = UINT64_MAX;
  	static volatile uint16_t x9500 = 1U;
  	static uint64_t t158 = 28659323460LLU;
  
      t158 = (((x9497+x9498)*x9499)<<x9500);
  
      if (t158 != 18446744073709535272LLU) { NG(); } else { ; }
  	
  }
  
  void f159(void) {
      	int8_t x9537 = INT8_MIN;
  	uint64_t x9539 = 27140176583LLU;
  	int16_t x9540 = 2;
  	volatile uint64_t t159 = 113899927690692LLU;
  
      t159 = (((x9537+x9538)*x9539)<<x9540);
  
      if (t159 != 18446743965148845284LLU) { NG(); } else { ; }
  	
  }
  
  void f160(void) {
      	uint32_t x9609 = UINT32_MAX;
  	int16_t x9610 = -647;
  	int32_t x9611 = -1;
  	uint8_t x9612 = 21U;
  	static volatile uint32_t t160 = 739039937U;
  
      t160 = (((x9609+x9610)*x9611)<<x9612);
  
      if (t160 != 1358954496U) { NG(); } else { ; }
  	
  }
  
  void f161(void) {
      	int16_t x9626 = INT16_MIN;
  	int64_t x9627 = -1LL;
  	int8_t x9628 = 1;
  	volatile int64_t t161 = 6675LL;
  
      t161 = (((x9625+x9626)*x9627)<<x9628);
  
      if (t161 != 65530LL) { NG(); } else { ; }
  	
  }
  
  void f162(void) {
      	volatile int8_t x9633 = INT8_MIN;
  	volatile int16_t x9634 = -1582;
  	uint32_t x9635 = 4U;
  	int8_t x9636 = 19;
  	uint32_t t162 = 339247U;
  
      t162 = (((x9633+x9634)*x9635)<<x9636);
  
      if (t162 != 708837376U) { NG(); } else { ; }
  	
  }
  
  void f163(void) {
      	int8_t x9669 = -1;
  	volatile uint64_t x9670 = UINT64_MAX;
  	volatile int32_t x9671 = 6;
  	int8_t x9672 = 2;
  
      t163 = (((x9669+x9670)*x9671)<<x9672);
  
      if (t163 != 18446744073709551568LLU) { NG(); } else { ; }
  	
  }
  
  void f164(void) {
      	static volatile uint32_t x9710 = 413U;
  	int64_t x9711 = 2197179LL;
  	volatile uint8_t x9712 = 10U;
  	int64_t t164 = -2393001LL;
  
      t164 = (((x9709+x9710)*x9711)<<x9712);
  
      if (t164 != 1176703607808LL) { NG(); } else { ; }
  	
  }
  
  void f165(void) {
      	int8_t x9721 = INT8_MAX;
  	uint64_t x9722 = UINT64_MAX;
  	int32_t x9723 = -1;
  	uint64_t t165 = 136720393087LLU;
  
      t165 = (((x9721+x9722)*x9723)<<x9724);
  
      if (t165 != 18446744073709551112LLU) { NG(); } else { ; }
  	
  }
  
  void f166(void) {
      	int64_t x9741 = 4196LL;
  	volatile uint64_t x9742 = 40695853201156LLU;
  	int32_t x9743 = 2;
  
      t166 = (((x9741+x9742)*x9743)<<x9744);
  
      if (t166 != 17427241708063555584LLU) { NG(); } else { ; }
  	
  }
  
  void f167(void) {
      	volatile uint64_t x9753 = 2290621192LLU;
  	volatile uint8_t x9754 = 67U;
  	int16_t x9755 = -6070;
  	uint8_t x9756 = 3U;
  	uint64_t t167 = 24LLU;
  
      t167 = (((x9753+x9754)*x9755)<<x9756);
  
      if (t167 != 18446632841141214576LLU) { NG(); } else { ; }
  	
  }
  
  void f168(void) {
      	volatile uint8_t x9770 = 20U;
  	static uint16_t x9771 = 9831U;
  
      t168 = (((x9769+x9770)*x9771)<<x9772);
  
      if (t168 != 963438) { NG(); } else { ; }
  	
  }
  
  void f169(void) {
      	int64_t x9926 = -1LL;
  	uint8_t x9927 = 17U;
  	uint16_t x9928 = 0U;
  	volatile int64_t t169 = 435395644929949LL;
  
      t169 = (((x9925+x9926)*x9927)<<x9928);
  
      if (t169 != 4318LL) { NG(); } else { ; }
  	
  }
  
  void f170(void) {
      	uint16_t x9954 = UINT16_MAX;
  	int32_t t170 = -3588;
  
      t170 = (((x9953+x9954)*x9955)<<x9956);
  
      if (t170 != 92164) { NG(); } else { ; }
  	
  }
  
  void f171(void) {
      	int8_t x10054 = INT8_MIN;
  	int8_t x10055 = INT8_MIN;
  	uint32_t t171 = 7704224U;
  
      t171 = (((x10053+x10054)*x10055)<<x10056);
  
      if (t171 != 3849793536U) { NG(); } else { ; }
  	
  }
  
  void f172(void) {
      	int16_t x10073 = INT16_MIN;
  	int8_t x10075 = INT8_MAX;
  
      t172 = (((x10073+x10074)*x10075)<<x10076);
  
      if (t172 != 14316613841948354588LLU) { NG(); } else { ; }
  	
  }
  
  void f173(void) {
      	uint64_t x10145 = 335060LLU;
  	volatile uint64_t x10146 = 242236LLU;
  	volatile uint8_t x10147 = 18U;
  	static uint16_t x10148 = 2U;
  	volatile uint64_t t173 = 37182176LLU;
  
      t173 = (((x10145+x10146)*x10147)<<x10148);
  
      if (t173 != 41565312LLU) { NG(); } else { ; }
  	
  }
  
  void f174(void) {
      	int16_t x10229 = INT16_MAX;
  	uint64_t x10230 = 27445304591236LLU;
  	int16_t x10231 = INT16_MIN;
  	uint8_t x10232 = 0U;
  	volatile uint64_t t174 = 6945936777871559336LLU;
  
      t174 = (((x10229+x10230)*x10231)<<x10232);
  
      if (t174 != 17547416331790221312LLU) { NG(); } else { ; }
  	
  }
  
  void f175(void) {
      	static int16_t x10361 = 1;
  	volatile int16_t x10362 = INT16_MAX;
  	uint8_t x10364 = 3U;
  	static uint32_t t175 = 36U;
  
      t175 = (((x10361+x10362)*x10363)<<x10364);
  
      if (t175 != 7340032U) { NG(); } else { ; }
  	
  }
  
  void f176(void) {
      	uint8_t x10417 = 0U;
  	uint32_t x10418 = UINT32_MAX;
  	static uint32_t x10420 = 0U;
  	uint32_t t176 = 1196U;
  
      t176 = (((x10417+x10418)*x10419)<<x10420);
  
      if (t176 != 4293665971U) { NG(); } else { ; }
  	
  }
  
  void f177(void) {
      	uint8_t x10433 = UINT8_MAX;
  	volatile uint16_t x10434 = UINT16_MAX;
  	uint64_t x10436 = 1LLU;
  	volatile int32_t t177 = -10756;
  
      t177 = (((x10433+x10434)*x10435)<<x10436);
  
      if (t177 != 16315920) { NG(); } else { ; }
  	
  }
  
  void f178(void) {
      	uint16_t x10481 = 718U;
  	int32_t x10483 = 0;
  	int16_t x10484 = 0;
  	static int32_t t178 = 52;
  
      t178 = (((x10481+x10482)*x10483)<<x10484);
  
      if (t178 != 0) { NG(); } else { ; }
  	
  }
  
  void f179(void) {
      	uint32_t x10701 = 1884U;
  	int32_t x10702 = -14;
  	int32_t x10703 = 1;
  	int8_t x10704 = 1;
  
      t179 = (((x10701+x10702)*x10703)<<x10704);
  
      if (t179 != 3740U) { NG(); } else { ; }
  	
  }
  
  void f180(void) {
      	uint32_t x10809 = UINT32_MAX;
  	uint16_t x10810 = UINT16_MAX;
  	static uint16_t x10811 = UINT16_MAX;
  	static int8_t x10812 = 7;
  	static uint32_t t180 = 12165554U;
  
      t180 = (((x10809+x10810)*x10811)<<x10812);
  
      if (t180 != 4269801728U) { NG(); } else { ; }
  	
  }
  
  void f181(void) {
      	uint64_t x10989 = 831586475676838LLU;
  	int32_t x10990 = -327;
  	uint32_t x10991 = UINT32_MAX;
  	int16_t x10992 = 43;
  	uint64_t t181 = 1241413224LLU;
  
      t181 = (((x10989+x10990)*x10991)<<x10992);
  
      if (t181 != 2550453560068276224LLU) { NG(); } else { ; }
  	
  }
  
  void f182(void) {
      	volatile int8_t x11005 = INT8_MIN;
  	int32_t x11006 = 1;
  	uint32_t x11008 = 18U;
  
      t182 = (((x11005+x11006)*x11007)<<x11008);
  
      if (t182 != 5012418070678863872LLU) { NG(); } else { ; }
  	
  }
  
  void f183(void) {
      	int16_t x11021 = INT16_MIN;
  	volatile uint32_t x11022 = UINT32_MAX;
  	uint8_t x11023 = 0U;
  	int8_t x11024 = 1;
  	uint32_t t183 = 150059U;
  
      t183 = (((x11021+x11022)*x11023)<<x11024);
  
      if (t183 != 0U) { NG(); } else { ; }
  	
  }
  
  void f184(void) {
      	uint64_t x11041 = 46503060836779LLU;
  	uint8_t x11042 = 2U;
  	uint32_t x11044 = 49U;
  
      t184 = (((x11041+x11042)*x11043)<<x11044);
  
      if (t184 != 15899395534478114816LLU) { NG(); } else { ; }
  	
  }
  
  void f185(void) {
      	uint16_t x11053 = UINT16_MAX;
  	volatile int16_t x11054 = -2;
  	uint64_t x11055 = 1952071042904773585LLU;
  	static uint32_t x11056 = 1U;
  
      t185 = (((x11053+x11054)*x11055)<<x11056);
  
      if (t185 != 12249751079283329306LLU) { NG(); } else { ; }
  	
  }
  
  void f186(void) {
      	uint8_t x11093 = 2U;
  	int16_t x11094 = INT16_MAX;
  	uint64_t x11095 = 9634403157375LLU;
  	static int16_t x11096 = 0;
  	volatile uint64_t t186 = 2953114419008036710LLU;
  
      t186 = (((x11093+x11094)*x11095)<<x11096);
  
      if (t186 != 315709757064021375LLU) { NG(); } else { ; }
  	
  }
  
  void f187(void) {
      	int32_t x11101 = INT32_MAX;
  	static int64_t x11102 = -333084LL;
  	int64_t x11103 = 59LL;
  	int16_t x11104 = 0;
  	int64_t t187 = -205LL;
  
      t187 = (((x11101+x11102)*x11103)<<x11104);
  
      if (t187 != 126681883217LL) { NG(); } else { ; }
  	
  }
  
  void f188(void) {
      	int32_t x11249 = -11324;
  	int8_t x11250 = 39;
  	static uint64_t x11251 = 1043618501267169LLU;
  	int16_t x11252 = 0;
  	uint64_t t188 = 260251490LLU;
  
      t188 = (((x11249+x11250)*x11251)<<x11252);
  
      if (t188 != 6669509286909549451LLU) { NG(); } else { ; }
  	
  }
  
  void f189(void) {
      	static int8_t x11437 = 8;
  	int8_t x11438 = 1;
  	uint16_t x11439 = 12U;
  	int32_t x11440 = 24;
  	volatile int32_t t189 = -318350748;
  
      t189 = (((x11437+x11438)*x11439)<<x11440);
  
      if (t189 != 1811939328) { NG(); } else { ; }
  	
  }
  
  void f190(void) {
      	int32_t x11489 = -1;
  	volatile int8_t x11490 = 1;
  	int16_t x11491 = 85;
  	int16_t x11492 = 0;
  
      t190 = (((x11489+x11490)*x11491)<<x11492);
  
      if (t190 != 0) { NG(); } else { ; }
  	
  }
  
  void f191(void) {
      	volatile int8_t x11497 = -1;
  	uint32_t x11498 = UINT32_MAX;
  	uint32_t x11500 = 5U;
  	static volatile uint32_t t191 = 44999157U;
  
      t191 = (((x11497+x11498)*x11499)<<x11500);
  
      if (t191 != 0U) { NG(); } else { ; }
  	
  }
  
  void f192(void) {
      	uint64_t x11597 = 2572661LLU;
  	int32_t x11598 = INT32_MIN;
  	int32_t x11599 = 4;
  	volatile uint8_t x11600 = 24U;
  	uint64_t t192 = 503658056LLU;
  
      t192 = (((x11597+x11598)*x11599)<<x11600);
  
      if (t192 != 18302801533990862848LLU) { NG(); } else { ; }
  	
  }
  
  void f193(void) {
      	int32_t x11629 = -87413160;
  	static uint8_t x11630 = 11U;
  	uint8_t x11632 = 3U;
  	volatile int32_t t193 = -13;
  
      t193 = (((x11629+x11630)*x11631)<<x11632);
  
      if (t193 != 699305192) { NG(); } else { ; }
  	
  }
  
  void f194(void) {
      	uint32_t x11701 = 36U;
  	volatile int32_t x11703 = -13;
  	volatile uint32_t t194 = 1U;
  
      t194 = (((x11701+x11702)*x11703)<<x11704);
  
      if (t194 != 1702064U) { NG(); } else { ; }
  	
  }
  
  void f195(void) {
      	volatile int8_t x11853 = INT8_MIN;
  	int32_t x11854 = -666718;
  	int32_t x11855 = -1;
  	uint8_t x11856 = 1U;
  	int32_t t195 = -6;
  
      t195 = (((x11853+x11854)*x11855)<<x11856);
  
      if (t195 != 1333692) { NG(); } else { ; }
  	
  }
  
  void f196(void) {
      	static uint16_t x11933 = 24U;
  	uint64_t x11935 = 26LLU;
  	volatile uint32_t x11936 = 18U;
  	volatile uint64_t t196 = 3230629944055LLU;
  
      t196 = (((x11933+x11934)*x11935)<<x11936);
  
      if (t196 != 18432107375084175360LLU) { NG(); } else { ; }
  	
  }
  
  void f197(void) {
      	static uint8_t x12157 = UINT8_MAX;
  	int32_t x12158 = INT32_MIN;
  	static uint8_t x12160 = 2U;
  
      t197 = (((x12157+x12158)*x12159)<<x12160);
  
      if (t197 != 18446744004990083040LLU) { NG(); } else { ; }
  	
  }
  
  void f198(void) {
      	int32_t x12226 = -441;
  	static uint32_t x12227 = UINT32_MAX;
  	uint8_t x12228 = 1U;
  
      t198 = (((x12225+x12226)*x12227)<<x12228);
  
      if (t198 != 4294922716U) { NG(); } else { ; }
  	
  }
  
  void f199(void) {
      	int16_t x12375 = -1;
  	volatile int8_t x12376 = 24;
  	volatile int32_t t199 = 1;
  
      t199 = (((x12373+x12374)*x12375)<<x12376);
  
      if (t199 != 33554432) { 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;
  }
  
  