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"
  
  int16_t x72 = 0;
  volatile int32_t t2 = -1219;
  uint32_t x235 = 8496U;
  int8_t x236 = 0;
  volatile int8_t x418 = -1;
  int32_t x419 = 410;
  static uint64_t t7 = 7528050315726614823LLU;
  static int32_t x479 = 14955957;
  static uint16_t x624 = 0U;
  uint8_t x792 = 3U;
  int16_t x823 = 1;
  int32_t x856 = 1;
  static uint64_t t13 = 75193LLU;
  volatile int32_t x894 = -15;
  int64_t x917 = -1LL;
  volatile int32_t t16 = -379;
  int64_t x1150 = 2662484583459975177LL;
  static volatile int64_t t19 = 742LL;
  uint64_t x1159 = UINT64_MAX;
  uint64_t t20 = UINT64_MAX;
  static volatile int16_t x1222 = INT16_MAX;
  int16_t x1257 = -362;
  volatile uint16_t x1459 = 280U;
  volatile uint16_t x1577 = UINT16_MAX;
  int64_t x1578 = INT64_MAX;
  int32_t t25 = -4509;
  uint64_t x1743 = 3276LLU;
  volatile uint64_t t26 = 98LLU;
  static uint16_t x1835 = 3757U;
  static volatile int64_t t27 = 0LL;
  uint64_t x1981 = 17744014LLU;
  int8_t x2005 = -1;
  int8_t x2006 = -1;
  int32_t x2061 = 441;
  volatile int16_t x2062 = -1;
  static uint64_t t32 = 1275073722469021484LLU;
  int32_t x2187 = INT32_MAX;
  static uint8_t x2266 = 1U;
  static int8_t x2268 = 2;
  uint8_t x2575 = UINT8_MAX;
  uint32_t x2726 = 4122145U;
  static uint64_t x2728 = 29LLU;
  volatile int32_t x2765 = INT32_MAX;
  uint64_t x2783 = 230246127768559976LLU;
  int32_t x2784 = 1;
  static uint8_t x2850 = 49U;
  static volatile uint64_t x2852 = 4LLU;
  static volatile int8_t x2858 = INT8_MAX;
  static int64_t x2963 = 4380894168LL;
  int64_t t44 = 823LL;
  volatile uint32_t x2981 = 32U;
  uint8_t x2982 = UINT8_MAX;
  int32_t x2983 = INT32_MAX;
  static int8_t x2984 = 0;
  static volatile int32_t x3170 = 1472;
  static uint64_t x3181 = 240842708645LLU;
  volatile uint64_t t52 = 23245527618761LLU;
  volatile int8_t x3443 = INT8_MAX;
  uint16_t x3559 = UINT16_MAX;
  static int64_t t60 = -240459387825342015LL;
  volatile uint64_t x3733 = UINT64_MAX;
  uint64_t x3736 = 14LLU;
  uint64_t x3803 = 990850LLU;
  uint16_t x3804 = 0U;
  volatile uint64_t t63 = 5051088LLU;
  uint64_t x3810 = 2LLU;
  volatile uint16_t x4139 = UINT16_MAX;
  volatile int64_t x4194 = INT64_MAX;
  uint64_t x4218 = 735784LLU;
  static volatile uint32_t x4377 = 721542797U;
  volatile uint8_t x4380 = 30U;
  volatile uint8_t x4392 = 3U;
  uint64_t x4393 = UINT64_MAX;
  int8_t x4809 = INT8_MAX;
  volatile int64_t t76 = -7483494606123LL;
  int64_t x4938 = -1LL;
  uint16_t x4939 = 206U;
  volatile int64_t t79 = 926LL;
  uint8_t x5085 = 12U;
  int32_t t80 = -51278209;
  uint8_t x5166 = 62U;
  uint32_t t81 = UINT32_MAX;
  int8_t x5306 = 2;
  int8_t x5336 = 2;
  static uint32_t x5439 = 1794606711U;
  uint8_t x5484 = 7U;
  int16_t x5557 = -1;
  static uint32_t x5560 = 28U;
  int32_t t88 = 65031;
  int64_t t89 = -667576044LL;
  volatile int8_t x5804 = 17;
  uint8_t x5808 = 37U;
  static uint64_t x5922 = 1LLU;
  static int32_t x5995 = 468;
  int16_t x5996 = 4;
  static volatile int32_t t95 = 33533;
  static uint64_t x6000 = 8LLU;
  int8_t x6057 = INT8_MAX;
  static int64_t t97 = -1LL;
  static uint8_t x6089 = 3U;
  uint64_t x6090 = UINT64_MAX;
  static int16_t x6092 = 0;
  int8_t x6134 = INT8_MIN;
  volatile uint64_t x6135 = 263011887700965LLU;
  uint16_t x6177 = UINT16_MAX;
  volatile int64_t t102 = 24LL;
  uint32_t t104 = 126U;
  int32_t x6446 = -3232647;
  uint16_t x6447 = UINT16_MAX;
  static volatile uint8_t x6448 = 1U;
  int8_t x6584 = 31;
  static int16_t x6628 = 1;
  int64_t x6690 = 37909LL;
  int16_t x6719 = 65;
  uint32_t t111 = 58U;
  int16_t x6854 = -1;
  volatile int8_t x6977 = -51;
  uint64_t t113 = 46908204968666100LLU;
  uint16_t x7039 = 343U;
  static int64_t x7106 = -1LL;
  uint64_t t115 = 82LLU;
  int32_t t117 = -386925103;
  int16_t x7256 = 0;
  static volatile int32_t t119 = 3837009;
  static int16_t x7405 = INT16_MIN;
  int64_t x7406 = -1LL;
  static uint8_t x7559 = 37U;
  volatile int64_t x7619 = INT64_MAX;
  uint8_t x7644 = 23U;
  uint8_t x7879 = 22U;
  int8_t x7936 = 0;
  volatile int64_t x8102 = INT64_MAX;
  uint32_t x8391 = UINT32_MAX;
  int32_t x8397 = 1;
  volatile uint8_t x8406 = UINT8_MAX;
  static int64_t x8489 = -56212393LL;
  int64_t x8518 = -1LL;
  static volatile int32_t t139 = 12088;
  uint16_t x8547 = 4U;
  int8_t x8741 = -1;
  uint64_t x8801 = 66930232LLU;
  int32_t t144 = 44874;
  static int8_t x8890 = INT8_MIN;
  volatile int64_t x8891 = 277942707054409168LL;
  uint64_t t148 = 29212579091LLU;
  static int8_t x9345 = -1;
  volatile int16_t x9382 = -1;
  uint64_t x9383 = 6373618667494226584LLU;
  static volatile uint64_t x9399 = UINT64_MAX;
  static int8_t x9400 = 61;
  volatile uint64_t t153 = 2224627725156336477LLU;
  uint32_t x9416 = 1U;
  volatile int64_t t155 = -200LL;
  uint32_t x9529 = 149U;
  volatile int64_t t157 = 1464312713236805092LL;
  int64_t x9569 = INT64_MAX;
  uint64_t x9571 = 3050720LLU;
  static volatile int32_t t159 = -5748826;
  static int64_t x9602 = INT64_MIN;
  int64_t x9694 = INT64_MIN;
  volatile int64_t t161 = 303809LL;
  static uint16_t x9751 = 25U;
  static uint64_t t162 = 2681201596308LLU;
  static volatile int32_t x9777 = -1;
  uint32_t x9939 = 972838717U;
  int32_t t166 = 523;
  volatile int64_t x10173 = 10645LL;
  uint16_t x10379 = UINT16_MAX;
  static int32_t x10415 = INT32_MAX;
  int16_t x10650 = INT16_MIN;
  int16_t x10862 = INT16_MIN;
  volatile uint32_t t175 = 67890322U;
  uint32_t x10947 = UINT32_MAX;
  uint8_t x10948 = 1U;
  int64_t x11173 = -1LL;
  int32_t x11175 = 0;
  static volatile uint8_t x11229 = 1U;
  static int8_t x11254 = INT8_MIN;
  int8_t x11255 = INT8_MAX;
  static uint8_t x11333 = 0U;
  static int16_t x11335 = 1;
  uint64_t x11359 = 745209053193918678LLU;
  uint64_t x11379 = UINT64_MAX;
  volatile int16_t x11449 = -1685;
  int64_t x11504 = 0LL;
  volatile int64_t t188 = 500724846959910005LL;
  volatile int16_t x11837 = 0;
  volatile uint64_t x11838 = 612097394LLU;
  uint8_t x11839 = UINT8_MAX;
  volatile int64_t x12081 = INT64_MAX;
  int16_t x12102 = 12108;
  uint32_t x12175 = 5579208U;
  uint16_t x12226 = UINT16_MAX;
  volatile uint16_t x12227 = 1U;
  static uint32_t x12408 = 0U;
  static volatile uint64_t t197 = 7929LLU;
  uint16_t x12418 = UINT16_MAX;
  int8_t x12419 = INT8_MAX;
  
  
  void f0(void) {
      	static volatile uint16_t x1 = 35U;
  	uint64_t x2 = UINT64_MAX;
  	static uint32_t x3 = UINT32_MAX;
  	volatile uint32_t x4 = 27U;
  	volatile uint64_t t0 = 4525209808LLU;
  
      t0 = ((x1/x2)|(x3<<x4));
  
      if (t0 != 4160749568LLU) { NG(); } else { ; }
  	
  }
  
  void f1(void) {
      	static volatile int64_t x69 = INT64_MIN;
  	static int16_t x70 = INT16_MIN;
  	uint32_t x71 = 660142118U;
  	int64_t t1 = -20396039731LL;
  
      t1 = ((x69/x70)|(x71<<x72));
  
      if (t1 != 281475636852774LL) { NG(); } else { ; }
  	
  }
  
  void f2(void) {
      	uint16_t x81 = 449U;
  	int32_t x82 = -35730664;
  	uint16_t x83 = 0U;
  	uint8_t x84 = 2U;
  
      t2 = ((x81/x82)|(x83<<x84));
  
      if (t2 != 0) { NG(); } else { ; }
  	
  }
  
  void f3(void) {
      	int32_t x93 = INT32_MAX;
  	int8_t x94 = INT8_MAX;
  	uint32_t x95 = 439U;
  	static int8_t x96 = 1;
  	uint32_t t3 = 928U;
  
      t3 = ((x93/x94)|(x95<<x96));
  
      if (t3 != 16910190U) { NG(); } else { ; }
  	
  }
  
  void f4(void) {
      	uint16_t x97 = 6341U;
  	uint32_t x98 = 50994U;
  	uint8_t x99 = 18U;
  	int8_t x100 = 2;
  	volatile uint32_t t4 = 49540U;
  
      t4 = ((x97/x98)|(x99<<x100));
  
      if (t4 != 72U) { NG(); } else { ; }
  	
  }
  
  void f5(void) {
      	uint64_t x101 = 26487247LLU;
  	int32_t x102 = INT32_MAX;
  	static uint8_t x103 = UINT8_MAX;
  	volatile uint16_t x104 = 4U;
  	volatile uint64_t t5 = 4LLU;
  
      t5 = ((x101/x102)|(x103<<x104));
  
      if (t5 != 4080LLU) { NG(); } else { ; }
  	
  }
  
  void f6(void) {
      	int64_t x233 = INT64_MIN;
  	volatile int64_t x234 = INT64_MIN;
  	static volatile int64_t t6 = -1132649092544899542LL;
  
      t6 = ((x233/x234)|(x235<<x236));
  
      if (t6 != 8497LL) { NG(); } else { ; }
  	
  }
  
  void f7(void) {
      	uint64_t x417 = UINT64_MAX;
  	volatile uint8_t x420 = 2U;
  
      t7 = ((x417/x418)|(x419<<x420));
  
      if (t7 != 1641LLU) { NG(); } else { ; }
  	
  }
  
  void f8(void) {
      	int32_t x477 = INT32_MIN;
  	int16_t x478 = INT16_MAX;
  	static int32_t x480 = 1;
  	int32_t t8 = -98723796;
  
      t8 = ((x477/x478)|(x479<<x480));
  
      if (t8 != -65538) { NG(); } else { ; }
  	
  }
  
  void f9(void) {
      	int16_t x529 = INT16_MAX;
  	volatile uint32_t x530 = 472U;
  	static uint64_t x531 = 22783253244LLU;
  	static uint32_t x532 = 45U;
  	uint64_t t9 = 1029076946750375LLU;
  
      t9 = ((x529/x530)|(x531<<x532));
  
      if (t9 != 11195807936154697797LLU) { NG(); } else { ; }
  	
  }
  
  void f10(void) {
      	int16_t x621 = INT16_MAX;
  	int32_t x622 = -185092932;
  	uint32_t x623 = 14921U;
  	uint32_t t10 = 6382U;
  
      t10 = ((x621/x622)|(x623<<x624));
  
      if (t10 != 14921U) { NG(); } else { ; }
  	
  }
  
  void f11(void) {
      	int64_t x789 = -554452LL;
  	static volatile int32_t x790 = INT32_MIN;
  	uint8_t x791 = 2U;
  	int64_t t11 = -6275156211274LL;
  
      t11 = ((x789/x790)|(x791<<x792));
  
      if (t11 != 16LL) { NG(); } else { ; }
  	
  }
  
  void f12(void) {
      	uint8_t x821 = 0U;
  	int16_t x822 = INT16_MAX;
  	uint32_t x824 = 0U;
  	int32_t t12 = -3;
  
      t12 = ((x821/x822)|(x823<<x824));
  
      if (t12 != 1) { NG(); } else { ; }
  	
  }
  
  void f13(void) {
      	uint32_t x853 = UINT32_MAX;
  	int64_t x854 = INT64_MIN;
  	static uint64_t x855 = UINT64_MAX;
  
      t13 = ((x853/x854)|(x855<<x856));
  
      if (t13 != 18446744073709551614LLU) { NG(); } else { ; }
  	
  }
  
  void f14(void) {
      	int8_t x893 = -6;
  	static uint16_t x895 = 37U;
  	int16_t x896 = 15;
  	volatile int32_t t14 = 4;
  
      t14 = ((x893/x894)|(x895<<x896));
  
      if (t14 != 1212416) { NG(); } else { ; }
  	
  }
  
  void f15(void) {
      	int16_t x918 = -570;
  	int16_t x919 = INT16_MAX;
  	int16_t x920 = 12;
  	volatile int64_t t15 = 16334569120LL;
  
      t15 = ((x917/x918)|(x919<<x920));
  
      if (t15 != 134213632LL) { NG(); } else { ; }
  	
  }
  
  void f16(void) {
      	uint8_t x1009 = UINT8_MAX;
  	uint8_t x1010 = UINT8_MAX;
  	static int8_t x1011 = INT8_MAX;
  	int8_t x1012 = 0;
  
      t16 = ((x1009/x1010)|(x1011<<x1012));
  
      if (t16 != 127) { NG(); } else { ; }
  	
  }
  
  void f17(void) {
      	static volatile int16_t x1081 = 0;
  	volatile uint32_t x1082 = 4748989U;
  	static volatile int16_t x1083 = INT16_MAX;
  	int16_t x1084 = 0;
  	uint32_t t17 = 0U;
  
      t17 = ((x1081/x1082)|(x1083<<x1084));
  
      if (t17 != 32767U) { NG(); } else { ; }
  	
  }
  
  void f18(void) {
      	int8_t x1125 = 53;
  	uint16_t x1126 = UINT16_MAX;
  	uint32_t x1127 = UINT32_MAX;
  	static volatile uint8_t x1128 = 15U;
  	uint32_t t18 = 183U;
  
      t18 = ((x1125/x1126)|(x1127<<x1128));
  
      if (t18 != 4294934528U) { NG(); } else { ; }
  	
  }
  
  void f19(void) {
      	volatile uint16_t x1149 = 23430U;
  	static int16_t x1151 = INT16_MAX;
  	uint16_t x1152 = 0U;
  
      t19 = ((x1149/x1150)|(x1151<<x1152));
  
      if (t19 != 32767LL) { NG(); } else { ; }
  	
  }
  
  void f20(void) {
      	uint16_t x1157 = 1U;
  	static volatile int8_t x1158 = 10;
  	int8_t x1160 = 0;
  
      t20 = ((x1157/x1158)|(x1159<<x1160));
  
      if (t20 != UINT64_MAX) { NG(); } else { ; }
  	
  }
  
  void f21(void) {
      	uint64_t x1221 = 26LLU;
  	uint32_t x1223 = 40287435U;
  	static uint8_t x1224 = 9U;
  	static uint64_t t21 = 165193650936LLU;
  
      t21 = ((x1221/x1222)|(x1223<<x1224));
  
      if (t21 != 3447297536LLU) { NG(); } else { ; }
  	
  }
  
  void f22(void) {
      	uint16_t x1258 = UINT16_MAX;
  	int16_t x1259 = 0;
  	uint8_t x1260 = 5U;
  	volatile int32_t t22 = -209350770;
  
      t22 = ((x1257/x1258)|(x1259<<x1260));
  
      if (t22 != 0) { NG(); } else { ; }
  	
  }
  
  void f23(void) {
      	volatile uint8_t x1457 = 117U;
  	static uint8_t x1458 = 4U;
  	volatile uint8_t x1460 = 0U;
  	int32_t t23 = -31545144;
  
      t23 = ((x1457/x1458)|(x1459<<x1460));
  
      if (t23 != 285) { NG(); } else { ; }
  	
  }
  
  void f24(void) {
      	uint8_t x1579 = 51U;
  	uint16_t x1580 = 23U;
  	static int64_t t24 = -2708LL;
  
      t24 = ((x1577/x1578)|(x1579<<x1580));
  
      if (t24 != 427819008LL) { NG(); } else { ; }
  	
  }
  
  void f25(void) {
      	int8_t x1725 = 0;
  	int8_t x1726 = INT8_MIN;
  	uint8_t x1727 = 0U;
  	volatile uint32_t x1728 = 1U;
  
      t25 = ((x1725/x1726)|(x1727<<x1728));
  
      if (t25 != 0) { NG(); } else { ; }
  	
  }
  
  void f26(void) {
      	uint64_t x1741 = UINT64_MAX;
  	static int16_t x1742 = 88;
  	volatile uint8_t x1744 = 1U;
  
      t26 = ((x1741/x1742)|(x1743<<x1744));
  
      if (t26 != 209622091746703802LLU) { NG(); } else { ; }
  	
  }
  
  void f27(void) {
      	int64_t x1833 = INT64_MIN;
  	volatile uint32_t x1834 = 96493U;
  	uint8_t x1836 = 12U;
  
      t27 = ((x1833/x1834)|(x1835<<x1836));
  
      if (t27 != -95585907517301LL) { NG(); } else { ; }
  	
  }
  
  void f28(void) {
      	int16_t x1845 = -1;
  	static int32_t x1846 = INT32_MIN;
  	volatile uint64_t x1847 = UINT64_MAX;
  	int16_t x1848 = 55;
  	volatile uint64_t t28 = 3584LLU;
  
      t28 = ((x1845/x1846)|(x1847<<x1848));
  
      if (t28 != 18410715276690587648LLU) { NG(); } else { ; }
  	
  }
  
  void f29(void) {
      	int8_t x1982 = -1;
  	volatile int8_t x1983 = INT8_MAX;
  	static int16_t x1984 = 14;
  	static volatile uint64_t t29 = 1975772LLU;
  
      t29 = ((x1981/x1982)|(x1983<<x1984));
  
      if (t29 != 2080768LLU) { NG(); } else { ; }
  	
  }
  
  void f30(void) {
      	volatile uint16_t x2007 = 2737U;
  	static uint8_t x2008 = 7U;
  	static int32_t t30 = -1;
  
      t30 = ((x2005/x2006)|(x2007<<x2008));
  
      if (t30 != 350337) { NG(); } else { ; }
  	
  }
  
  void f31(void) {
      	uint64_t x2063 = UINT64_MAX;
  	uint64_t x2064 = 9LLU;
  	static volatile uint64_t t31 = 17866140022528949LLU;
  
      t31 = ((x2061/x2062)|(x2063<<x2064));
  
      if (t31 != 18446744073709551175LLU) { NG(); } else { ; }
  	
  }
  
  void f32(void) {
      	volatile int16_t x2081 = 14840;
  	int16_t x2082 = -1;
  	uint64_t x2083 = 13140477LLU;
  	volatile int8_t x2084 = 53;
  
      t32 = ((x2081/x2082)|(x2083<<x2084));
  
      if (t32 != 18446744073709536776LLU) { NG(); } else { ; }
  	
  }
  
  void f33(void) {
      	uint8_t x2145 = UINT8_MAX;
  	int32_t x2146 = INT32_MIN;
  	int16_t x2147 = INT16_MAX;
  	uint16_t x2148 = 1U;
  	volatile int32_t t33 = 205620;
  
      t33 = ((x2145/x2146)|(x2147<<x2148));
  
      if (t33 != 65534) { NG(); } else { ; }
  	
  }
  
  void f34(void) {
      	int8_t x2185 = INT8_MIN;
  	uint16_t x2186 = UINT16_MAX;
  	uint16_t x2188 = 0U;
  	int32_t t34 = INT32_MAX;
  
      t34 = ((x2185/x2186)|(x2187<<x2188));
  
      if (t34 != INT32_MAX) { NG(); } else { ; }
  	
  }
  
  void f35(void) {
      	int64_t x2265 = -1LL;
  	volatile uint32_t x2267 = UINT32_MAX;
  	volatile int64_t t35 = -29454434617LL;
  
      t35 = ((x2265/x2266)|(x2267<<x2268));
  
      if (t35 != -1LL) { NG(); } else { ; }
  	
  }
  
  void f36(void) {
      	int32_t x2365 = -37;
  	static int64_t x2366 = -11LL;
  	uint32_t x2367 = 39003U;
  	int32_t x2368 = 3;
  	volatile int64_t t36 = 14178665LL;
  
      t36 = ((x2365/x2366)|(x2367<<x2368));
  
      if (t36 != 312027LL) { NG(); } else { ; }
  	
  }
  
  void f37(void) {
      	int16_t x2573 = -2;
  	volatile int32_t x2574 = INT32_MIN;
  	static uint8_t x2576 = 14U;
  	volatile int32_t t37 = 16015;
  
      t37 = ((x2573/x2574)|(x2575<<x2576));
  
      if (t37 != 4177920) { NG(); } else { ; }
  	
  }
  
  void f38(void) {
      	int8_t x2685 = 4;
  	static int8_t x2686 = INT8_MIN;
  	static int8_t x2687 = INT8_MAX;
  	static int16_t x2688 = 1;
  	volatile int32_t t38 = 8098187;
  
      t38 = ((x2685/x2686)|(x2687<<x2688));
  
      if (t38 != 254) { NG(); } else { ; }
  	
  }
  
  void f39(void) {
      	uint32_t x2725 = 39120802U;
  	uint32_t x2727 = 853621U;
  	static uint32_t t39 = 814U;
  
      t39 = ((x2725/x2726)|(x2727<<x2728));
  
      if (t39 != 2684354569U) { NG(); } else { ; }
  	
  }
  
  void f40(void) {
      	int64_t x2766 = INT64_MIN;
  	uint16_t x2767 = 65U;
  	int32_t x2768 = 1;
  	volatile int64_t t40 = -79564503022696147LL;
  
      t40 = ((x2765/x2766)|(x2767<<x2768));
  
      if (t40 != 130LL) { NG(); } else { ; }
  	
  }
  
  void f41(void) {
      	int8_t x2781 = INT8_MIN;
  	uint16_t x2782 = UINT16_MAX;
  	volatile uint64_t t41 = 36356LLU;
  
      t41 = ((x2781/x2782)|(x2783<<x2784));
  
      if (t41 != 460492255537119952LLU) { NG(); } else { ; }
  	
  }
  
  void f42(void) {
      	uint16_t x2849 = UINT16_MAX;
  	static uint64_t x2851 = UINT64_MAX;
  	uint64_t t42 = 14015761LLU;
  
      t42 = ((x2849/x2850)|(x2851<<x2852));
  
      if (t42 != 18446744073709551609LLU) { NG(); } else { ; }
  	
  }
  
  void f43(void) {
      	uint8_t x2857 = 0U;
  	int16_t x2859 = 1;
  	static uint8_t x2860 = 4U;
  	volatile int32_t t43 = 173780;
  
      t43 = ((x2857/x2858)|(x2859<<x2860));
  
      if (t43 != 16) { NG(); } else { ; }
  	
  }
  
  void f44(void) {
      	volatile int64_t x2961 = INT64_MAX;
  	uint32_t x2962 = UINT32_MAX;
  	volatile uint16_t x2964 = 8U;
  
      t44 = ((x2961/x2962)|(x2963<<x2964));
  
      if (t44 != 1123656390656LL) { NG(); } else { ; }
  	
  }
  
  void f45(void) {
      	uint32_t t45 = 24U;
  
      t45 = ((x2981/x2982)|(x2983<<x2984));
  
      if (t45 != 2147483647U) { NG(); } else { ; }
  	
  }
  
  void f46(void) {
      	volatile int64_t x3089 = -1LL;
  	uint8_t x3090 = UINT8_MAX;
  	uint64_t x3091 = 56LLU;
  	uint8_t x3092 = 20U;
  	volatile uint64_t t46 = 14259827LLU;
  
      t46 = ((x3089/x3090)|(x3091<<x3092));
  
      if (t46 != 58720256LLU) { NG(); } else { ; }
  	
  }
  
  void f47(void) {
      	uint8_t x3129 = 3U;
  	int16_t x3130 = INT16_MIN;
  	uint16_t x3131 = UINT16_MAX;
  	int16_t x3132 = 2;
  	int32_t t47 = 150;
  
      t47 = ((x3129/x3130)|(x3131<<x3132));
  
      if (t47 != 262140) { NG(); } else { ; }
  	
  }
  
  void f48(void) {
      	int8_t x3165 = 1;
  	static volatile int8_t x3166 = INT8_MIN;
  	static uint64_t x3167 = 2162400939LLU;
  	uint8_t x3168 = 23U;
  	volatile uint64_t t48 = 494070209511613060LLU;
  
      t48 = ((x3165/x3166)|(x3167<<x3168));
  
      if (t48 != 18139533816102912LLU) { NG(); } else { ; }
  	
  }
  
  void f49(void) {
      	static int32_t x3169 = 321;
  	int8_t x3171 = 0;
  	uint8_t x3172 = 3U;
  	int32_t t49 = -1476;
  
      t49 = ((x3169/x3170)|(x3171<<x3172));
  
      if (t49 != 0) { NG(); } else { ; }
  	
  }
  
  void f50(void) {
      	static volatile uint64_t x3182 = 182537607786LLU;
  	uint64_t x3183 = 115216629709281496LLU;
  	uint64_t x3184 = 3LLU;
  	volatile uint64_t t50 = 1LLU;
  
      t50 = ((x3181/x3182)|(x3183<<x3184));
  
      if (t50 != 921733037674251969LLU) { NG(); } else { ; }
  	
  }
  
  void f51(void) {
      	static int32_t x3197 = -1;
  	uint8_t x3198 = UINT8_MAX;
  	uint8_t x3199 = 0U;
  	uint8_t x3200 = 7U;
  	volatile int32_t t51 = -120077;
  
      t51 = ((x3197/x3198)|(x3199<<x3200));
  
      if (t51 != 0) { NG(); } else { ; }
  	
  }
  
  void f52(void) {
      	uint32_t x3217 = 895651U;
  	int32_t x3218 = -1;
  	static uint64_t x3219 = 911881892322661235LLU;
  	static int8_t x3220 = 1;
  
      t52 = ((x3217/x3218)|(x3219<<x3220));
  
      if (t52 != 1823763784645322470LLU) { NG(); } else { ; }
  	
  }
  
  void f53(void) {
      	volatile int64_t x3289 = INT64_MAX;
  	uint32_t x3290 = 155U;
  	volatile uint32_t x3291 = 169117555U;
  	static int64_t x3292 = 29LL;
  	volatile int64_t t53 = 42186LL;
  
      t53 = ((x3289/x3290)|(x3291<<x3292));
  
      if (t53 != 59505627117966184LL) { NG(); } else { ; }
  	
  }
  
  void f54(void) {
      	volatile int16_t x3365 = INT16_MIN;
  	uint16_t x3366 = 3U;
  	uint16_t x3367 = UINT16_MAX;
  	uint8_t x3368 = 1U;
  	int32_t t54 = -57;
  
      t54 = ((x3365/x3366)|(x3367<<x3368));
  
      if (t54 != -2) { NG(); } else { ; }
  	
  }
  
  void f55(void) {
      	int64_t x3421 = 17311853874044LL;
  	static uint64_t x3422 = UINT64_MAX;
  	volatile int64_t x3423 = 1922LL;
  	static int8_t x3424 = 12;
  	uint64_t t55 = 2073LLU;
  
      t55 = ((x3421/x3422)|(x3423<<x3424));
  
      if (t55 != 7872512LLU) { NG(); } else { ; }
  	
  }
  
  void f56(void) {
      	volatile uint64_t x3441 = 252120563579LLU;
  	int8_t x3442 = 1;
  	volatile int8_t x3444 = 1;
  	static uint64_t t56 = 805365LLU;
  
      t56 = ((x3441/x3442)|(x3443<<x3444));
  
      if (t56 != 252120563711LLU) { NG(); } else { ; }
  	
  }
  
  void f57(void) {
      	int32_t x3453 = INT32_MIN;
  	uint32_t x3454 = UINT32_MAX;
  	uint16_t x3455 = 0U;
  	int8_t x3456 = 6;
  	static uint32_t t57 = 2111452U;
  
      t57 = ((x3453/x3454)|(x3455<<x3456));
  
      if (t57 != 0U) { NG(); } else { ; }
  	
  }
  
  void f58(void) {
      	int64_t x3557 = INT64_MIN;
  	uint16_t x3558 = UINT16_MAX;
  	static volatile int16_t x3560 = 1;
  	int64_t t58 = 965790LL;
  
      t58 = ((x3557/x3558)|(x3559<<x3560));
  
      if (t58 != -140739635838978LL) { NG(); } else { ; }
  	
  }
  
  void f59(void) {
      	int16_t x3609 = 2;
  	uint32_t x3610 = UINT32_MAX;
  	static volatile int16_t x3611 = 3;
  	int64_t x3612 = 0LL;
  	volatile uint32_t t59 = 34U;
  
      t59 = ((x3609/x3610)|(x3611<<x3612));
  
      if (t59 != 3U) { NG(); } else { ; }
  	
  }
  
  void f60(void) {
      	static volatile int64_t x3677 = INT64_MAX;
  	int16_t x3678 = 91;
  	volatile uint32_t x3679 = 867U;
  	int16_t x3680 = 0;
  
      t60 = ((x3677/x3678)|(x3679<<x3680));
  
      if (t60 != 101355736668734315LL) { NG(); } else { ; }
  	
  }
  
  void f61(void) {
      	uint8_t x3713 = 41U;
  	volatile uint64_t x3714 = 163195620LLU;
  	uint16_t x3715 = 12U;
  	uint8_t x3716 = 11U;
  	volatile uint64_t t61 = 194087805264587239LLU;
  
      t61 = ((x3713/x3714)|(x3715<<x3716));
  
      if (t61 != 24576LLU) { NG(); } else { ; }
  	
  }
  
  void f62(void) {
      	uint32_t x3734 = UINT32_MAX;
  	int64_t x3735 = 189367363031LL;
  	uint64_t t62 = 11LLU;
  
      t62 = ((x3733/x3734)|(x3735<<x3736));
  
      if (t62 != 3102594875899905LLU) { NG(); } else { ; }
  	
  }
  
  void f63(void) {
      	uint8_t x3801 = 2U;
  	volatile int16_t x3802 = 2959;
  
      t63 = ((x3801/x3802)|(x3803<<x3804));
  
      if (t63 != 990850LLU) { NG(); } else { ; }
  	
  }
  
  void f64(void) {
      	static uint16_t x3809 = UINT16_MAX;
  	uint64_t x3811 = 7718829839812LLU;
  	uint32_t x3812 = 22U;
  	uint64_t t64 = 31474514236672LLU;
  
      t64 = ((x3809/x3810)|(x3811<<x3812));
  
      if (t64 != 13928374798733311999LLU) { NG(); } else { ; }
  	
  }
  
  void f65(void) {
      	int32_t x3981 = -1;
  	volatile int32_t x3982 = -22532952;
  	uint32_t x3983 = 16109U;
  	uint8_t x3984 = 2U;
  	volatile uint32_t t65 = 209744255U;
  
      t65 = ((x3981/x3982)|(x3983<<x3984));
  
      if (t65 != 64436U) { NG(); } else { ; }
  	
  }
  
  void f66(void) {
      	volatile int64_t x3985 = INT64_MIN;
  	static int16_t x3986 = INT16_MIN;
  	int64_t x3987 = 0LL;
  	uint32_t x3988 = 1U;
  	volatile int64_t t66 = -1559027968913355LL;
  
      t66 = ((x3985/x3986)|(x3987<<x3988));
  
      if (t66 != 281474976710656LL) { NG(); } else { ; }
  	
  }
  
  void f67(void) {
      	uint8_t x4137 = UINT8_MAX;
  	int32_t x4138 = INT32_MIN;
  	static uint8_t x4140 = 0U;
  	int32_t t67 = -7;
  
      t67 = ((x4137/x4138)|(x4139<<x4140));
  
      if (t67 != 65535) { NG(); } else { ; }
  	
  }
  
  void f68(void) {
      	int8_t x4193 = -1;
  	static int16_t x4195 = INT16_MAX;
  	static uint8_t x4196 = 1U;
  	int64_t t68 = -488116188LL;
  
      t68 = ((x4193/x4194)|(x4195<<x4196));
  
      if (t68 != 65534LL) { NG(); } else { ; }
  	
  }
  
  void f69(void) {
      	volatile int8_t x4217 = -1;
  	int32_t x4219 = 838884;
  	volatile uint16_t x4220 = 1U;
  	volatile uint64_t t69 = 76LLU;
  
      t69 = ((x4217/x4218)|(x4219<<x4220));
  
      if (t69 != 25070868757497LLU) { NG(); } else { ; }
  	
  }
  
  void f70(void) {
      	static volatile uint8_t x4265 = 1U;
  	volatile uint64_t x4266 = UINT64_MAX;
  	uint8_t x4267 = 7U;
  	volatile uint16_t x4268 = 1U;
  	volatile uint64_t t70 = 96LLU;
  
      t70 = ((x4265/x4266)|(x4267<<x4268));
  
      if (t70 != 14LLU) { NG(); } else { ; }
  	
  }
  
  void f71(void) {
      	int64_t x4378 = INT64_MIN;
  	static uint64_t x4379 = 51944033726000141LLU;
  	volatile uint64_t t71 = 466655350957298886LLU;
  
      t71 = ((x4377/x4378)|(x4379<<x4380));
  
      if (t71 != 12942249129928556544LLU) { NG(); } else { ; }
  	
  }
  
  void f72(void) {
      	static uint16_t x4389 = 6U;
  	static uint16_t x4390 = 480U;
  	uint64_t x4391 = UINT64_MAX;
  	volatile uint64_t t72 = 2377833319LLU;
  
      t72 = ((x4389/x4390)|(x4391<<x4392));
  
      if (t72 != 18446744073709551608LLU) { NG(); } else { ; }
  	
  }
  
  void f73(void) {
      	uint16_t x4394 = 2197U;
  	int64_t x4395 = 156520LL;
  	volatile int8_t x4396 = 6;
  	uint64_t t73 = 2034LLU;
  
      t73 = ((x4393/x4394)|(x4395<<x4396));
  
      if (t73 != 8396333215702563LLU) { NG(); } else { ; }
  	
  }
  
  void f74(void) {
      	volatile int32_t x4645 = INT32_MIN;
  	int16_t x4646 = -2740;
  	uint8_t x4647 = 28U;
  	int16_t x4648 = 2;
  	int32_t t74 = -16866;
  
      t74 = ((x4645/x4646)|(x4647<<x4648));
  
      if (t74 != 783865) { NG(); } else { ; }
  	
  }
  
  void f75(void) {
      	static int16_t x4810 = -2682;
  	uint64_t x4811 = UINT64_MAX;
  	static uint8_t x4812 = 4U;
  	uint64_t t75 = 141045LLU;
  
      t75 = ((x4809/x4810)|(x4811<<x4812));
  
      if (t75 != 18446744073709551600LLU) { NG(); } else { ; }
  	
  }
  
  void f76(void) {
      	uint8_t x4853 = UINT8_MAX;
  	int8_t x4854 = INT8_MIN;
  	int64_t x4855 = 50LL;
  	int8_t x4856 = 7;
  
      t76 = ((x4853/x4854)|(x4855<<x4856));
  
      if (t76 != -1LL) { NG(); } else { ; }
  	
  }
  
  void f77(void) {
      	static int64_t x4857 = -1LL;
  	static int16_t x4858 = INT16_MIN;
  	static volatile uint8_t x4859 = 9U;
  	volatile int16_t x4860 = 4;
  	int64_t t77 = -5LL;
  
      t77 = ((x4857/x4858)|(x4859<<x4860));
  
      if (t77 != 144LL) { NG(); } else { ; }
  	
  }
  
  void f78(void) {
      	static int16_t x4933 = -2;
  	int64_t x4934 = INT64_MIN;
  	uint32_t x4935 = 488U;
  	uint8_t x4936 = 1U;
  	int64_t t78 = 545487422LL;
  
      t78 = ((x4933/x4934)|(x4935<<x4936));
  
      if (t78 != 976LL) { NG(); } else { ; }
  	
  }
  
  void f79(void) {
      	int32_t x4937 = 236628715;
  	static int8_t x4940 = 1;
  
      t79 = ((x4937/x4938)|(x4939<<x4940));
  
      if (t79 != -236628579LL) { NG(); } else { ; }
  	
  }
  
  void f80(void) {
      	static int16_t x5086 = INT16_MAX;
  	uint16_t x5087 = UINT16_MAX;
  	int16_t x5088 = 1;
  
      t80 = ((x5085/x5086)|(x5087<<x5088));
  
      if (t80 != 131070) { NG(); } else { ; }
  	
  }
  
  void f81(void) {
      	static int16_t x5165 = -199;
  	static uint32_t x5167 = UINT32_MAX;
  	int8_t x5168 = 0;
  
      t81 = ((x5165/x5166)|(x5167<<x5168));
  
      if (t81 != UINT32_MAX) { NG(); } else { ; }
  	
  }
  
  void f82(void) {
      	static volatile uint32_t x5305 = UINT32_MAX;
  	static volatile uint8_t x5307 = 6U;
  	uint8_t x5308 = 0U;
  	volatile uint32_t t82 = 1337976654U;
  
      t82 = ((x5305/x5306)|(x5307<<x5308));
  
      if (t82 != 2147483647U) { NG(); } else { ; }
  	
  }
  
  void f83(void) {
      	int32_t x5333 = -1;
  	int8_t x5334 = INT8_MAX;
  	uint32_t x5335 = 22U;
  	uint32_t t83 = 57476259U;
  
      t83 = ((x5333/x5334)|(x5335<<x5336));
  
      if (t83 != 88U) { NG(); } else { ; }
  	
  }
  
  void f84(void) {
      	static uint64_t x5437 = UINT64_MAX;
  	int16_t x5438 = INT16_MAX;
  	static volatile uint8_t x5440 = 10U;
  	static volatile uint64_t t84 = 4116830431LLU;
  
      t84 = ((x5437/x5438)|(x5439<<x5440));
  
      if (t84 != 562970859527184LLU) { NG(); } else { ; }
  	
  }
  
  void f85(void) {
      	static int32_t x5481 = 1;
  	volatile int64_t x5482 = INT64_MIN;
  	uint16_t x5483 = 29U;
  	volatile int64_t t85 = -2011928267829LL;
  
      t85 = ((x5481/x5482)|(x5483<<x5484));
  
      if (t85 != 3712LL) { NG(); } else { ; }
  	
  }
  
  void f86(void) {
      	static int16_t x5558 = INT16_MIN;
  	static uint32_t x5559 = UINT32_MAX;
  	uint32_t t86 = 26227058U;
  
      t86 = ((x5557/x5558)|(x5559<<x5560));
  
      if (t86 != 4026531840U) { NG(); } else { ; }
  	
  }
  
  void f87(void) {
      	static int32_t x5701 = -1;
  	int32_t x5702 = 3553;
  	static uint16_t x5703 = 3347U;
  	volatile int64_t x5704 = 0LL;
  	int32_t t87 = 9294061;
  
      t87 = ((x5701/x5702)|(x5703<<x5704));
  
      if (t87 != 3347) { NG(); } else { ; }
  	
  }
  
  void f88(void) {
      	int32_t x5713 = INT32_MAX;
  	int32_t x5714 = -1;
  	volatile uint16_t x5715 = 87U;
  	uint32_t x5716 = 5U;
  
      t88 = ((x5713/x5714)|(x5715<<x5716));
  
      if (t88 != -2147480863) { NG(); } else { ; }
  	
  }
  
  void f89(void) {
      	int8_t x5781 = 40;
  	int32_t x5782 = INT32_MIN;
  	int64_t x5783 = 2055224996LL;
  	volatile uint64_t x5784 = 1LLU;
  
      t89 = ((x5781/x5782)|(x5783<<x5784));
  
      if (t89 != 4110449992LL) { NG(); } else { ; }
  	
  }
  
  void f90(void) {
      	uint32_t x5801 = UINT32_MAX;
  	uint64_t x5802 = 2040145LLU;
  	uint16_t x5803 = 381U;
  	volatile uint64_t t90 = 1009LLU;
  
      t90 = ((x5801/x5802)|(x5803<<x5804));
  
      if (t90 != 49940537LLU) { NG(); } else { ; }
  	
  }
  
  void f91(void) {
      	uint16_t x5805 = UINT16_MAX;
  	int8_t x5806 = -20;
  	volatile uint64_t x5807 = 1837865366084LLU;
  	volatile uint64_t t91 = 4457773445645530LLU;
  
      t91 = ((x5805/x5806)|(x5807<<x5808));
  
      if (t91 != 18446744073709548340LLU) { NG(); } else { ; }
  	
  }
  
  void f92(void) {
      	volatile int8_t x5809 = 18;
  	int16_t x5810 = INT16_MIN;
  	uint32_t x5811 = 338U;
  	volatile int16_t x5812 = 14;
  	static volatile uint32_t t92 = 742U;
  
      t92 = ((x5809/x5810)|(x5811<<x5812));
  
      if (t92 != 5537792U) { NG(); } else { ; }
  	
  }
  
  void f93(void) {
      	volatile int16_t x5917 = INT16_MIN;
  	static uint8_t x5918 = 127U;
  	uint32_t x5919 = UINT32_MAX;
  	volatile int32_t x5920 = 1;
  	uint32_t t93 = 378U;
  
      t93 = ((x5917/x5918)|(x5919<<x5920));
  
      if (t93 != 4294967294U) { NG(); } else { ; }
  	
  }
  
  void f94(void) {
      	int64_t x5921 = INT64_MIN;
  	uint32_t x5923 = 6140U;
  	uint8_t x5924 = 0U;
  	uint64_t t94 = 484621043096LLU;
  
      t94 = ((x5921/x5922)|(x5923<<x5924));
  
      if (t94 != 9223372036854781948LLU) { NG(); } else { ; }
  	
  }
  
  void f95(void) {
      	static int16_t x5993 = INT16_MIN;
  	static int8_t x5994 = -1;
  
      t95 = ((x5993/x5994)|(x5995<<x5996));
  
      if (t95 != 40256) { NG(); } else { ; }
  	
  }
  
  void f96(void) {
      	int32_t x5997 = -1;
  	static int32_t x5998 = 826870676;
  	uint16_t x5999 = 3635U;
  	int32_t t96 = 3697;
  
      t96 = ((x5997/x5998)|(x5999<<x6000));
  
      if (t96 != 930560) { NG(); } else { ; }
  	
  }
  
  void f97(void) {
      	int64_t x6058 = INT64_MIN;
  	static int8_t x6059 = INT8_MAX;
  	int8_t x6060 = 0;
  
      t97 = ((x6057/x6058)|(x6059<<x6060));
  
      if (t97 != 127LL) { NG(); } else { ; }
  	
  }
  
  void f98(void) {
      	static int64_t x6077 = 15387670493930478LL;
  	static int8_t x6078 = INT8_MIN;
  	uint16_t x6079 = 2U;
  	uint16_t x6080 = 2U;
  	int64_t t98 = -18851LL;
  
      t98 = ((x6077/x6078)|(x6079<<x6080));
  
      if (t98 != -120216175733831LL) { NG(); } else { ; }
  	
  }
  
  void f99(void) {
      	int16_t x6091 = 1;
  	uint64_t t99 = 16681495508LLU;
  
      t99 = ((x6089/x6090)|(x6091<<x6092));
  
      if (t99 != 1LLU) { NG(); } else { ; }
  	
  }
  
  void f100(void) {
      	int64_t x6133 = -1LL;
  	uint32_t x6136 = 11U;
  	uint64_t t100 = 321359086LLU;
  
      t100 = ((x6133/x6134)|(x6135<<x6136));
  
      if (t100 != 538648346011576320LLU) { NG(); } else { ; }
  	
  }
  
  void f101(void) {
      	static volatile uint16_t x6178 = 1U;
  	int32_t x6179 = 1;
  	uint64_t x6180 = 4LLU;
  	int32_t t101 = -160425;
  
      t101 = ((x6177/x6178)|(x6179<<x6180));
  
      if (t101 != 65535) { NG(); } else { ; }
  	
  }
  
  void f102(void) {
      	static volatile int8_t x6221 = INT8_MIN;
  	int32_t x6222 = -25823;
  	int64_t x6223 = 28LL;
  	int16_t x6224 = 1;
  
      t102 = ((x6221/x6222)|(x6223<<x6224));
  
      if (t102 != 56LL) { NG(); } else { ; }
  	
  }
  
  void f103(void) {
      	uint8_t x6365 = UINT8_MAX;
  	int32_t x6366 = 119;
  	volatile int8_t x6367 = 0;
  	uint64_t x6368 = 1LLU;
  	volatile int32_t t103 = 645878003;
  
      t103 = ((x6365/x6366)|(x6367<<x6368));
  
      if (t103 != 2) { NG(); } else { ; }
  	
  }
  
  void f104(void) {
      	uint32_t x6397 = UINT32_MAX;
  	uint16_t x6398 = 51U;
  	static uint16_t x6399 = UINT16_MAX;
  	int16_t x6400 = 2;
  
      t104 = ((x6397/x6398)|(x6399<<x6400));
  
      if (t104 != 84410365U) { NG(); } else { ; }
  	
  }
  
  void f105(void) {
      	uint32_t x6445 = UINT32_MAX;
  	uint32_t t105 = 7690U;
  
      t105 = ((x6445/x6446)|(x6447<<x6448));
  
      if (t105 != 131071U) { NG(); } else { ; }
  	
  }
  
  void f106(void) {
      	int8_t x6469 = INT8_MIN;
  	static uint16_t x6470 = 93U;
  	volatile int32_t x6471 = 6;
  	int8_t x6472 = 27;
  	static volatile int32_t t106 = -3131728;
  
      t106 = ((x6469/x6470)|(x6471<<x6472));
  
      if (t106 != -1) { NG(); } else { ; }
  	
  }
  
  void f107(void) {
      	int64_t x6581 = -2733577371323004LL;
  	int8_t x6582 = -1;
  	uint8_t x6583 = 0U;
  	volatile int64_t t107 = -56755LL;
  
      t107 = ((x6581/x6582)|(x6583<<x6584));
  
      if (t107 != 2733577371323004LL) { NG(); } else { ; }
  	
  }
  
  void f108(void) {
      	int32_t x6625 = INT32_MIN;
  	uint16_t x6626 = 32166U;
  	uint32_t x6627 = UINT32_MAX;
  	uint32_t t108 = 0U;
  
      t108 = ((x6625/x6626)|(x6627<<x6628));
  
      if (t108 != 4294967294U) { NG(); } else { ; }
  	
  }
  
  void f109(void) {
      	int16_t x6689 = -1;
  	volatile uint64_t x6691 = 734171904668LLU;
  	uint16_t x6692 = 1U;
  	volatile uint64_t t109 = 171LLU;
  
      t109 = ((x6689/x6690)|(x6691<<x6692));
  
      if (t109 != 1468343809336LLU) { NG(); } else { ; }
  	
  }
  
  void f110(void) {
      	volatile int32_t x6717 = 0;
  	int8_t x6718 = 7;
  	int32_t x6720 = 2;
  	volatile int32_t t110 = 75;
  
      t110 = ((x6717/x6718)|(x6719<<x6720));
  
      if (t110 != 260) { NG(); } else { ; }
  	
  }
  
  void f111(void) {
      	int32_t x6761 = INT32_MIN;
  	static uint8_t x6762 = 117U;
  	uint32_t x6763 = 25476U;
  	uint32_t x6764 = 15U;
  
      t111 = ((x6761/x6762)|(x6763<<x6764));
  
      if (t111 != 4293389951U) { NG(); } else { ; }
  	
  }
  
  void f112(void) {
      	int16_t x6853 = 15;
  	uint64_t x6855 = 86549696927LLU;
  	volatile uint8_t x6856 = 1U;
  	uint64_t t112 = UINT64_MAX;
  
      t112 = ((x6853/x6854)|(x6855<<x6856));
  
      if (t112 != UINT64_MAX) { NG(); } else { ; }
  	
  }
  
  void f113(void) {
      	uint64_t x6978 = 7LLU;
  	int8_t x6979 = INT8_MAX;
  	static uint8_t x6980 = 9U;
  
      t113 = ((x6977/x6978)|(x6979<<x6980));
  
      if (t113 != 2635249153387134603LLU) { NG(); } else { ; }
  	
  }
  
  void f114(void) {
      	int64_t x7037 = -352921117363LL;
  	int64_t x7038 = INT64_MAX;
  	uint32_t x7040 = 3U;
  	static int64_t t114 = 1369564301LL;
  
      t114 = ((x7037/x7038)|(x7039<<x7040));
  
      if (t114 != 2744LL) { NG(); } else { ; }
  	
  }
  
  void f115(void) {
      	static uint64_t x7105 = UINT64_MAX;
  	int32_t x7107 = 5457;
  	int16_t x7108 = 6;
  
      t115 = ((x7105/x7106)|(x7107<<x7108));
  
      if (t115 != 349249LLU) { NG(); } else { ; }
  	
  }
  
  void f116(void) {
      	volatile int64_t x7193 = INT64_MAX;
  	volatile uint8_t x7194 = 1U;
  	int64_t x7195 = 1LL;
  	uint8_t x7196 = 49U;
  	int64_t t116 = INT64_MAX;
  
      t116 = ((x7193/x7194)|(x7195<<x7196));
  
      if (t116 != INT64_MAX) { NG(); } else { ; }
  	
  }
  
  void f117(void) {
      	static int8_t x7197 = -1;
  	volatile int16_t x7198 = -187;
  	uint8_t x7199 = 16U;
  	int8_t x7200 = 3;
  
      t117 = ((x7197/x7198)|(x7199<<x7200));
  
      if (t117 != 128) { NG(); } else { ; }
  	
  }
  
  void f118(void) {
      	static uint64_t x7253 = 74676754193050LLU;
  	volatile int16_t x7254 = INT16_MIN;
  	int16_t x7255 = 4835;
  	volatile uint64_t t118 = 15LLU;
  
      t118 = ((x7253/x7254)|(x7255<<x7256));
  
      if (t118 != 4835LLU) { NG(); } else { ; }
  	
  }
  
  void f119(void) {
      	volatile int32_t x7297 = INT32_MIN;
  	int16_t x7298 = 877;
  	uint8_t x7299 = 47U;
  	int8_t x7300 = 0;
  
      t119 = ((x7297/x7298)|(x7299<<x7300));
  
      if (t119 != -2448657) { NG(); } else { ; }
  	
  }
  
  void f120(void) {
      	static uint16_t x7369 = 3U;
  	volatile int32_t x7370 = -102421292;
  	uint64_t x7371 = 119407915790LLU;
  	uint8_t x7372 = 5U;
  	uint64_t t120 = 13LLU;
  
      t120 = ((x7369/x7370)|(x7371<<x7372));
  
      if (t120 != 3821053305280LLU) { NG(); } else { ; }
  	
  }
  
  void f121(void) {
      	uint32_t x7407 = 479180U;
  	volatile uint8_t x7408 = 6U;
  	int64_t t121 = -13LL;
  
      t121 = ((x7405/x7406)|(x7407<<x7408));
  
      if (t121 != 30667520LL) { NG(); } else { ; }
  	
  }
  
  void f122(void) {
      	int16_t x7557 = -1;
  	static int8_t x7558 = INT8_MIN;
  	static int16_t x7560 = 4;
  	int32_t t122 = -2554055;
  
      t122 = ((x7557/x7558)|(x7559<<x7560));
  
      if (t122 != 592) { NG(); } else { ; }
  	
  }
  
  void f123(void) {
      	uint32_t x7617 = 25U;
  	static int32_t x7618 = INT32_MIN;
  	static int8_t x7620 = 0;
  	static volatile int64_t t123 = INT64_MAX;
  
      t123 = ((x7617/x7618)|(x7619<<x7620));
  
      if (t123 != INT64_MAX) { NG(); } else { ; }
  	
  }
  
  void f124(void) {
      	int8_t x7641 = INT8_MIN;
  	static int16_t x7642 = -11321;
  	uint32_t x7643 = UINT32_MAX;
  	static uint32_t t124 = 199271U;
  
      t124 = ((x7641/x7642)|(x7643<<x7644));
  
      if (t124 != 4286578688U) { NG(); } else { ; }
  	
  }
  
  void f125(void) {
      	int8_t x7673 = 0;
  	static int16_t x7674 = 1095;
  	int8_t x7675 = INT8_MAX;
  	static uint16_t x7676 = 0U;
  	static int32_t t125 = -43001479;
  
      t125 = ((x7673/x7674)|(x7675<<x7676));
  
      if (t125 != 127) { NG(); } else { ; }
  	
  }
  
  void f126(void) {
      	uint16_t x7701 = UINT16_MAX;
  	int16_t x7702 = INT16_MIN;
  	static uint32_t x7703 = 154316U;
  	uint8_t x7704 = 14U;
  	volatile uint32_t t126 = UINT32_MAX;
  
      t126 = ((x7701/x7702)|(x7703<<x7704));
  
      if (t126 != UINT32_MAX) { NG(); } else { ; }
  	
  }
  
  void f127(void) {
      	uint8_t x7853 = 1U;
  	int64_t x7854 = INT64_MIN;
  	static uint8_t x7855 = 0U;
  	static uint8_t x7856 = 5U;
  	volatile int64_t t127 = -1055341562839671003LL;
  
      t127 = ((x7853/x7854)|(x7855<<x7856));
  
      if (t127 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f128(void) {
      	static int8_t x7869 = 15;
  	int32_t x7870 = -2;
  	int8_t x7871 = 1;
  	int32_t x7872 = 10;
  	int32_t t128 = 2;
  
      t128 = ((x7869/x7870)|(x7871<<x7872));
  
      if (t128 != -7) { NG(); } else { ; }
  	
  }
  
  void f129(void) {
      	int64_t x7877 = 11970186345266LL;
  	int64_t x7878 = INT64_MIN;
  	uint32_t x7880 = 1U;
  	static volatile int64_t t129 = 56696877LL;
  
      t129 = ((x7877/x7878)|(x7879<<x7880));
  
      if (t129 != 44LL) { NG(); } else { ; }
  	
  }
  
  void f130(void) {
      	volatile int32_t x7933 = -1;
  	volatile int32_t x7934 = -10;
  	int8_t x7935 = 6;
  	int32_t t130 = 11280;
  
      t130 = ((x7933/x7934)|(x7935<<x7936));
  
      if (t130 != 6) { NG(); } else { ; }
  	
  }
  
  void f131(void) {
      	static volatile uint32_t x8033 = UINT32_MAX;
  	int16_t x8034 = -1;
  	uint8_t x8035 = UINT8_MAX;
  	uint8_t x8036 = 2U;
  	static volatile uint32_t t131 = 1546422386U;
  
      t131 = ((x8033/x8034)|(x8035<<x8036));
  
      if (t131 != 1021U) { NG(); } else { ; }
  	
  }
  
  void f132(void) {
      	static volatile int8_t x8101 = INT8_MIN;
  	uint32_t x8103 = UINT32_MAX;
  	uint8_t x8104 = 1U;
  	volatile int64_t t132 = 13545153LL;
  
      t132 = ((x8101/x8102)|(x8103<<x8104));
  
      if (t132 != 4294967294LL) { NG(); } else { ; }
  	
  }
  
  void f133(void) {
      	int32_t x8389 = INT32_MIN;
  	static volatile uint8_t x8390 = UINT8_MAX;
  	uint8_t x8392 = 30U;
  	uint32_t t133 = 709536U;
  
      t133 = ((x8389/x8390)|(x8391<<x8392));
  
      if (t133 != 4286545792U) { NG(); } else { ; }
  	
  }
  
  void f134(void) {
      	static volatile int32_t x8398 = INT32_MAX;
  	static uint64_t x8399 = 418680LLU;
  	int16_t x8400 = 0;
  	volatile uint64_t t134 = 6609965146778216LLU;
  
      t134 = ((x8397/x8398)|(x8399<<x8400));
  
      if (t134 != 418680LLU) { NG(); } else { ; }
  	
  }
  
  void f135(void) {
      	int64_t x8405 = INT64_MIN;
  	uint64_t x8407 = 380815197891484458LLU;
  	int8_t x8408 = 1;
  	volatile uint64_t t135 = 32640LLU;
  
      t135 = ((x8405/x8406)|(x8407<<x8408));
  
      if (t135 != 18446744071562067924LLU) { NG(); } else { ; }
  	
  }
  
  void f136(void) {
      	uint32_t x8441 = UINT32_MAX;
  	static int32_t x8442 = INT32_MIN;
  	uint8_t x8443 = 27U;
  	uint8_t x8444 = 1U;
  	volatile uint32_t t136 = 9U;
  
      t136 = ((x8441/x8442)|(x8443<<x8444));
  
      if (t136 != 55U) { NG(); } else { ; }
  	
  }
  
  void f137(void) {
      	volatile int16_t x8490 = 99;
  	int32_t x8491 = 646;
  	static int8_t x8492 = 17;
  	volatile int64_t t137 = 1984162LL;
  
      t137 = ((x8489/x8490)|(x8491<<x8492));
  
      if (t137 != -43513LL) { NG(); } else { ; }
  	
  }
  
  void f138(void) {
      	uint32_t x8517 = 3529U;
  	volatile uint64_t x8519 = 48019384711LLU;
  	uint32_t x8520 = 21U;
  	volatile uint64_t t138 = 682326723461464415LLU;
  
      t138 = ((x8517/x8518)|(x8519<<x8520));
  
      if (t138 != 18446744073709548087LLU) { NG(); } else { ; }
  	
  }
  
  void f139(void) {
      	volatile int32_t x8525 = -1;
  	int16_t x8526 = 5;
  	volatile int8_t x8527 = INT8_MAX;
  	static int8_t x8528 = 1;
  
      t139 = ((x8525/x8526)|(x8527<<x8528));
  
      if (t139 != 254) { NG(); } else { ; }
  	
  }
  
  void f140(void) {
      	uint64_t x8545 = 133359828224589053LLU;
  	int64_t x8546 = 2098110987230920LL;
  	int8_t x8548 = 0;
  	static volatile uint64_t t140 = 30LLU;
  
      t140 = ((x8545/x8546)|(x8547<<x8548));
  
      if (t140 != 63LLU) { NG(); } else { ; }
  	
  }
  
  void f141(void) {
      	static uint16_t x8701 = UINT16_MAX;
  	uint64_t x8702 = 140667190011722750LLU;
  	static volatile uint8_t x8703 = UINT8_MAX;
  	volatile uint8_t x8704 = 3U;
  	volatile uint64_t t141 = 19703844475LLU;
  
      t141 = ((x8701/x8702)|(x8703<<x8704));
  
      if (t141 != 2040LLU) { NG(); } else { ; }
  	
  }
  
  void f142(void) {
      	volatile int8_t x8742 = -1;
  	uint32_t x8743 = UINT32_MAX;
  	int16_t x8744 = 3;
  	volatile uint32_t t142 = 122U;
  
      t142 = ((x8741/x8742)|(x8743<<x8744));
  
      if (t142 != 4294967289U) { NG(); } else { ; }
  	
  }
  
  void f143(void) {
      	int32_t x8802 = -1;
  	uint16_t x8803 = 166U;
  	static volatile uint8_t x8804 = 2U;
  	uint64_t t143 = 49818996805962LLU;
  
      t143 = ((x8801/x8802)|(x8803<<x8804));
  
      if (t143 != 664LLU) { NG(); } else { ; }
  	
  }
  
  void f144(void) {
      	int16_t x8845 = INT16_MIN;
  	int8_t x8846 = 55;
  	static uint8_t x8847 = 1U;
  	static uint8_t x8848 = 12U;
  
      t144 = ((x8845/x8846)|(x8847<<x8848));
  
      if (t144 != -595) { NG(); } else { ; }
  	
  }
  
  void f145(void) {
      	static volatile int8_t x8865 = 39;
  	int16_t x8866 = INT16_MIN;
  	static uint32_t x8867 = 1444261U;
  	uint32_t x8868 = 1U;
  	static uint32_t t145 = 3030U;
  
      t145 = ((x8865/x8866)|(x8867<<x8868));
  
      if (t145 != 2888522U) { NG(); } else { ; }
  	
  }
  
  void f146(void) {
      	int16_t x8889 = 4;
  	int8_t x8892 = 1;
  	volatile int64_t t146 = 0LL;
  
      t146 = ((x8889/x8890)|(x8891<<x8892));
  
      if (t146 != 555885414108818336LL) { NG(); } else { ; }
  	
  }
  
  void f147(void) {
      	int64_t x8937 = INT64_MIN;
  	int16_t x8938 = INT16_MIN;
  	uint64_t x8939 = 1095LLU;
  	uint8_t x8940 = 16U;
  	volatile uint64_t t147 = 45570501615849601LLU;
  
      t147 = ((x8937/x8938)|(x8939<<x8940));
  
      if (t147 != 281475048472576LLU) { NG(); } else { ; }
  	
  }
  
  void f148(void) {
      	uint64_t x8941 = 58347256LLU;
  	int8_t x8942 = -1;
  	volatile uint16_t x8943 = 462U;
  	uint8_t x8944 = 19U;
  
      t148 = ((x8941/x8942)|(x8943<<x8944));
  
      if (t148 != 242221056LLU) { NG(); } else { ; }
  	
  }
  
  void f149(void) {
      	static volatile int32_t x9097 = -1;
  	int16_t x9098 = INT16_MIN;
  	uint32_t x9099 = 55184U;
  	uint8_t x9100 = 3U;
  	static volatile uint32_t t149 = 60220642U;
  
      t149 = ((x9097/x9098)|(x9099<<x9100));
  
      if (t149 != 441472U) { NG(); } else { ; }
  	
  }
  
  void f150(void) {
      	uint8_t x9309 = UINT8_MAX;
  	int8_t x9310 = -1;
  	uint16_t x9311 = 0U;
  	uint16_t x9312 = 4U;
  	volatile int32_t t150 = 82261570;
  
      t150 = ((x9309/x9310)|(x9311<<x9312));
  
      if (t150 != -255) { NG(); } else { ; }
  	
  }
  
  void f151(void) {
      	volatile int32_t x9346 = INT32_MIN;
  	uint32_t x9347 = UINT32_MAX;
  	uint8_t x9348 = 8U;
  	volatile uint32_t t151 = 17U;
  
      t151 = ((x9345/x9346)|(x9347<<x9348));
  
      if (t151 != 4294967040U) { NG(); } else { ; }
  	
  }
  
  void f152(void) {
      	volatile uint8_t x9381 = 16U;
  	volatile int8_t x9384 = 4;
  	volatile uint64_t t152 = 713334402308LLU;
  
      t152 = ((x9381/x9382)|(x9383<<x9384));
  
      if (t152 != 18446744073709551600LLU) { NG(); } else { ; }
  	
  }
  
  void f153(void) {
      	uint64_t x9397 = 250166LLU;
  	static int64_t x9398 = INT64_MIN;
  
      t153 = ((x9397/x9398)|(x9399<<x9400));
  
      if (t153 != 16140901064495857664LLU) { NG(); } else { ; }
  	
  }
  
  void f154(void) {
      	int64_t x9413 = INT64_MIN;
  	uint32_t x9414 = 369947U;
  	static volatile uint64_t x9415 = UINT64_MAX;
  	static volatile uint64_t t154 = UINT64_MAX;
  
      t154 = ((x9413/x9414)|(x9415<<x9416));
  
      if (t154 != UINT64_MAX) { NG(); } else { ; }
  	
  }
  
  void f155(void) {
      	volatile int8_t x9417 = 0;
  	int64_t x9418 = -1094731653067872LL;
  	uint8_t x9419 = 6U;
  	int16_t x9420 = 2;
  
      t155 = ((x9417/x9418)|(x9419<<x9420));
  
      if (t155 != 24LL) { NG(); } else { ; }
  	
  }
  
  void f156(void) {
      	int8_t x9530 = -25;
  	uint64_t x9531 = 33LLU;
  	uint32_t x9532 = 7U;
  	volatile uint64_t t156 = 1466749708120986521LLU;
  
      t156 = ((x9529/x9530)|(x9531<<x9532));
  
      if (t156 != 4224LLU) { NG(); } else { ; }
  	
  }
  
  void f157(void) {
      	volatile int64_t x9545 = INT64_MAX;
  	int16_t x9546 = INT16_MIN;
  	static int16_t x9547 = 0;
  	static volatile uint8_t x9548 = 21U;
  
      t157 = ((x9545/x9546)|(x9547<<x9548));
  
      if (t157 != -281474976710655LL) { NG(); } else { ; }
  	
  }
  
  void f158(void) {
      	int32_t x9570 = 44;
  	uint32_t x9572 = 2U;
  	uint64_t t158 = 15670463LLU;
  
      t158 = ((x9569/x9570)|(x9571<<x9572));
  
      if (t158 != 209622091748277178LLU) { NG(); } else { ; }
  	
  }
  
  void f159(void) {
      	uint8_t x9597 = 8U;
  	volatile int8_t x9598 = INT8_MIN;
  	int8_t x9599 = 12;
  	int32_t x9600 = 1;
  
      t159 = ((x9597/x9598)|(x9599<<x9600));
  
      if (t159 != 24) { NG(); } else { ; }
  	
  }
  
  void f160(void) {
      	int32_t x9601 = INT32_MAX;
  	uint64_t x9603 = 8839LLU;
  	static uint8_t x9604 = 4U;
  	uint64_t t160 = 7LLU;
  
      t160 = ((x9601/x9602)|(x9603<<x9604));
  
      if (t160 != 141424LLU) { NG(); } else { ; }
  	
  }
  
  void f161(void) {
      	uint8_t x9693 = 21U;
  	static volatile int16_t x9695 = INT16_MAX;
  	int64_t x9696 = 0LL;
  
      t161 = ((x9693/x9694)|(x9695<<x9696));
  
      if (t161 != 32767LL) { NG(); } else { ; }
  	
  }
  
  void f162(void) {
      	volatile uint8_t x9749 = UINT8_MAX;
  	static volatile uint64_t x9750 = 43151LLU;
  	uint8_t x9752 = 7U;
  
      t162 = ((x9749/x9750)|(x9751<<x9752));
  
      if (t162 != 3200LLU) { NG(); } else { ; }
  	
  }
  
  void f163(void) {
      	volatile int16_t x9778 = INT16_MAX;
  	int8_t x9779 = 0;
  	uint16_t x9780 = 3U;
  	int32_t t163 = 21041639;
  
      t163 = ((x9777/x9778)|(x9779<<x9780));
  
      if (t163 != 0) { NG(); } else { ; }
  	
  }
  
  void f164(void) {
      	static int8_t x9937 = INT8_MAX;
  	int32_t x9938 = INT32_MIN;
  	uint8_t x9940 = 3U;
  	volatile uint32_t t164 = 63041U;
  
      t164 = ((x9937/x9938)|(x9939<<x9940));
  
      if (t164 != 3487742440U) { NG(); } else { ; }
  	
  }
  
  void f165(void) {
      	int64_t x10049 = -1LL;
  	uint32_t x10050 = UINT32_MAX;
  	int8_t x10051 = 46;
  	static volatile int8_t x10052 = 25;
  	volatile int64_t t165 = 278921130783117LL;
  
      t165 = ((x10049/x10050)|(x10051<<x10052));
  
      if (t165 != 1543503872LL) { NG(); } else { ; }
  	
  }
  
  void f166(void) {
      	int32_t x10085 = INT32_MAX;
  	int16_t x10086 = INT16_MAX;
  	static uint16_t x10087 = 1U;
  	int32_t x10088 = 1;
  
      t166 = ((x10085/x10086)|(x10087<<x10088));
  
      if (t166 != 65538) { NG(); } else { ; }
  	
  }
  
  void f167(void) {
      	int16_t x10174 = INT16_MIN;
  	uint8_t x10175 = 56U;
  	static int8_t x10176 = 3;
  	volatile int64_t t167 = -100LL;
  
      t167 = ((x10173/x10174)|(x10175<<x10176));
  
      if (t167 != 448LL) { NG(); } else { ; }
  	
  }
  
  void f168(void) {
      	int16_t x10285 = 8;
  	volatile int16_t x10286 = 105;
  	static int16_t x10287 = INT16_MAX;
  	static volatile int16_t x10288 = 0;
  	volatile int32_t t168 = -577;
  
      t168 = ((x10285/x10286)|(x10287<<x10288));
  
      if (t168 != 32767) { NG(); } else { ; }
  	
  }
  
  void f169(void) {
      	volatile int32_t x10377 = INT32_MIN;
  	volatile uint32_t x10378 = UINT32_MAX;
  	uint16_t x10380 = 3U;
  	uint32_t t169 = 0U;
  
      t169 = ((x10377/x10378)|(x10379<<x10380));
  
      if (t169 != 524280U) { NG(); } else { ; }
  	
  }
  
  void f170(void) {
      	uint16_t x10413 = 34U;
  	uint32_t x10414 = 28U;
  	int8_t x10416 = 0;
  	uint32_t t170 = 750764U;
  
      t170 = ((x10413/x10414)|(x10415<<x10416));
  
      if (t170 != 2147483647U) { NG(); } else { ; }
  	
  }
  
  void f171(void) {
      	uint8_t x10569 = UINT8_MAX;
  	int32_t x10570 = -114;
  	volatile uint8_t x10571 = UINT8_MAX;
  	uint64_t x10572 = 3LLU;
  	volatile int32_t t171 = 329;
  
      t171 = ((x10569/x10570)|(x10571<<x10572));
  
      if (t171 != -2) { NG(); } else { ; }
  	
  }
  
  void f172(void) {
      	static int16_t x10649 = -830;
  	volatile int8_t x10651 = 1;
  	int8_t x10652 = 0;
  	int32_t t172 = 100137;
  
      t172 = ((x10649/x10650)|(x10651<<x10652));
  
      if (t172 != 1) { NG(); } else { ; }
  	
  }
  
  void f173(void) {
      	int16_t x10729 = -1;
  	volatile int32_t x10730 = INT32_MIN;
  	int16_t x10731 = INT16_MAX;
  	static volatile uint16_t x10732 = 0U;
  	int32_t t173 = -11;
  
      t173 = ((x10729/x10730)|(x10731<<x10732));
  
      if (t173 != 32767) { NG(); } else { ; }
  	
  }
  
  void f174(void) {
      	static int16_t x10861 = INT16_MIN;
  	int8_t x10863 = INT8_MAX;
  	int8_t x10864 = 15;
  	volatile int32_t t174 = 14354;
  
      t174 = ((x10861/x10862)|(x10863<<x10864));
  
      if (t174 != 4161537) { NG(); } else { ; }
  	
  }
  
  void f175(void) {
      	uint32_t x10865 = 923U;
  	int16_t x10866 = INT16_MIN;
  	volatile uint32_t x10867 = 9897U;
  	int8_t x10868 = 6;
  
      t175 = ((x10865/x10866)|(x10867<<x10868));
  
      if (t175 != 633408U) { NG(); } else { ; }
  	
  }
  
  void f176(void) {
      	volatile int8_t x10929 = INT8_MIN;
  	volatile int8_t x10930 = 41;
  	int8_t x10931 = INT8_MAX;
  	uint16_t x10932 = 1U;
  	volatile int32_t t176 = 4184197;
  
      t176 = ((x10929/x10930)|(x10931<<x10932));
  
      if (t176 != -1) { NG(); } else { ; }
  	
  }
  
  void f177(void) {
      	uint8_t x10945 = 0U;
  	volatile int64_t x10946 = INT64_MIN;
  	int64_t t177 = -1112639LL;
  
      t177 = ((x10945/x10946)|(x10947<<x10948));
  
      if (t177 != 4294967294LL) { NG(); } else { ; }
  	
  }
  
  void f178(void) {
      	uint32_t x11037 = 2479U;
  	uint64_t x11038 = 94268226LLU;
  	static volatile uint16_t x11039 = 455U;
  	int64_t x11040 = 0LL;
  	static uint64_t t178 = 40530787485069LLU;
  
      t178 = ((x11037/x11038)|(x11039<<x11040));
  
      if (t178 != 455LLU) { NG(); } else { ; }
  	
  }
  
  void f179(void) {
      	uint64_t x11174 = 93007134LLU;
  	int16_t x11176 = 14;
  	uint64_t t179 = 31934174010910033LLU;
  
      t179 = ((x11173/x11174)|(x11175<<x11176));
  
      if (t179 != 198336872456LLU) { NG(); } else { ; }
  	
  }
  
  void f180(void) {
      	static volatile int16_t x11230 = -3612;
  	int64_t x11231 = 27030509796018109LL;
  	int16_t x11232 = 1;
  	volatile int64_t t180 = 107839LL;
  
      t180 = ((x11229/x11230)|(x11231<<x11232));
  
      if (t180 != 54061019592036218LL) { NG(); } else { ; }
  	
  }
  
  void f181(void) {
      	uint8_t x11253 = UINT8_MAX;
  	uint32_t x11256 = 7U;
  	volatile int32_t t181 = -195;
  
      t181 = ((x11253/x11254)|(x11255<<x11256));
  
      if (t181 != -1) { NG(); } else { ; }
  	
  }
  
  void f182(void) {
      	int16_t x11317 = -17;
  	volatile uint16_t x11318 = 123U;
  	uint64_t x11319 = 48035LLU;
  	int8_t x11320 = 61;
  	static uint64_t t182 = 2LLU;
  
      t182 = ((x11317/x11318)|(x11319<<x11320));
  
      if (t182 != 6917529027641081856LLU) { NG(); } else { ; }
  	
  }
  
  void f183(void) {
      	uint16_t x11334 = 803U;
  	uint32_t x11336 = 0U;
  	static int32_t t183 = -536405;
  
      t183 = ((x11333/x11334)|(x11335<<x11336));
  
      if (t183 != 1) { NG(); } else { ; }
  	
  }
  
  void f184(void) {
      	uint32_t x11357 = 882353167U;
  	static int16_t x11358 = INT16_MIN;
  	volatile int8_t x11360 = 1;
  	uint64_t t184 = 2152966345710719LLU;
  
      t184 = ((x11357/x11358)|(x11359<<x11360));
  
      if (t184 != 1490418106387837356LLU) { NG(); } else { ; }
  	
  }
  
  void f185(void) {
      	int32_t x11377 = -2;
  	static int32_t x11378 = 1630;
  	int8_t x11380 = 1;
  	uint64_t t185 = 2754LLU;
  
      t185 = ((x11377/x11378)|(x11379<<x11380));
  
      if (t185 != 18446744073709551614LLU) { NG(); } else { ; }
  	
  }
  
  void f186(void) {
      	uint32_t x11450 = 44854497U;
  	int8_t x11451 = INT8_MAX;
  	uint32_t x11452 = 1U;
  	volatile uint32_t t186 = 2U;
  
      t186 = ((x11449/x11450)|(x11451<<x11452));
  
      if (t186 != 255U) { NG(); } else { ; }
  	
  }
  
  void f187(void) {
      	int32_t x11501 = INT32_MAX;
  	static uint32_t x11502 = 8180963U;
  	static uint16_t x11503 = 29800U;
  	uint32_t t187 = 6850U;
  
      t187 = ((x11501/x11502)|(x11503<<x11504));
  
      if (t187 != 30062U) { NG(); } else { ; }
  	
  }
  
  void f188(void) {
      	int64_t x11701 = 386113702084931LL;
  	uint16_t x11702 = UINT16_MAX;
  	uint8_t x11703 = 108U;
  	uint8_t x11704 = 11U;
  
      t188 = ((x11701/x11702)|(x11703<<x11704));
  
      if (t188 != 5891914042LL) { NG(); } else { ; }
  	
  }
  
  void f189(void) {
      	uint8_t x11840 = 2U;
  	static volatile uint64_t t189 = 8858174549455011985LLU;
  
      t189 = ((x11837/x11838)|(x11839<<x11840));
  
      if (t189 != 1020LLU) { NG(); } else { ; }
  	
  }
  
  void f190(void) {
      	int16_t x11853 = INT16_MIN;
  	static volatile int64_t x11854 = -24053566621581LL;
  	int64_t x11855 = 456LL;
  	int8_t x11856 = 7;
  	volatile int64_t t190 = 4940LL;
  
      t190 = ((x11853/x11854)|(x11855<<x11856));
  
      if (t190 != 58368LL) { NG(); } else { ; }
  	
  }
  
  void f191(void) {
      	static volatile int8_t x11989 = -1;
  	uint8_t x11990 = 54U;
  	volatile uint32_t x11991 = 615014U;
  	int32_t x11992 = 0;
  	uint32_t t191 = 179346U;
  
      t191 = ((x11989/x11990)|(x11991<<x11992));
  
      if (t191 != 615014U) { NG(); } else { ; }
  	
  }
  
  void f192(void) {
      	static int32_t x12009 = INT32_MAX;
  	static int8_t x12010 = INT8_MIN;
  	uint8_t x12011 = 1U;
  	volatile uint8_t x12012 = 3U;
  	volatile int32_t t192 = 0;
  
      t192 = ((x12009/x12010)|(x12011<<x12012));
  
      if (t192 != -16777207) { NG(); } else { ; }
  	
  }
  
  void f193(void) {
      	int64_t x12082 = -1LL;
  	static int64_t x12083 = 525712063LL;
  	uint8_t x12084 = 25U;
  	static int64_t t193 = -55268200393LL;
  
      t193 = ((x12081/x12082)|(x12083<<x12084));
  
      if (t193 != -9205732067185262591LL) { NG(); } else { ; }
  	
  }
  
  void f194(void) {
      	int8_t x12101 = 0;
  	int16_t x12103 = INT16_MAX;
  	uint32_t x12104 = 1U;
  	volatile int32_t t194 = -129407;
  
      t194 = ((x12101/x12102)|(x12103<<x12104));
  
      if (t194 != 65534) { NG(); } else { ; }
  	
  }
  
  void f195(void) {
      	int64_t x12173 = INT64_MAX;
  	static int16_t x12174 = INT16_MAX;
  	uint8_t x12176 = 0U;
  	static int64_t t195 = -2521LL;
  
      t195 = ((x12173/x12174)|(x12175<<x12176));
  
      if (t195 != 281483572224456LL) { NG(); } else { ; }
  	
  }
  
  void f196(void) {
      	uint32_t x12225 = UINT32_MAX;
  	uint32_t x12228 = 0U;
  	volatile uint32_t t196 = 1044932174U;
  
      t196 = ((x12225/x12226)|(x12227<<x12228));
  
      if (t196 != 65537U) { NG(); } else { ; }
  	
  }
  
  void f197(void) {
      	uint64_t x12405 = 199179799159LLU;
  	static int64_t x12406 = INT64_MIN;
  	int64_t x12407 = INT64_MAX;
  
      t197 = ((x12405/x12406)|(x12407<<x12408));
  
      if (t197 != 9223372036854775807LLU) { NG(); } else { ; }
  	
  }
  
  void f198(void) {
      	volatile int8_t x12417 = 2;
  	static int8_t x12420 = 6;
  	static volatile int32_t t198 = 2;
  
      t198 = ((x12417/x12418)|(x12419<<x12420));
  
      if (t198 != 8128) { NG(); } else { ; }
  	
  }
  
  void f199(void) {
      	uint32_t x12477 = UINT32_MAX;
  	static int32_t x12478 = INT32_MIN;
  	int64_t x12479 = 2375LL;
  	static uint16_t x12480 = 6U;
  	int64_t t199 = 41703LL;
  
      t199 = ((x12477/x12478)|(x12479<<x12480));
  
      if (t199 != 152001LL) { 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;
  }
  
  