text: 
  /*
  CF3
  
  Copyright (c) 2015 ishiura-lab.
  
  Released under the MIT license.  
  https://github.com/ishiura-compiler/CF3/MIT-LICENSE.md
  */
  
  #include<stdio.h>
  #include<stdint.h>
  #include<stdlib.h>
  #include"test1.h"
  
  uint8_t x22 = 1U;
  uint32_t x24 = 996U;
  volatile uint32_t t0 = 155421416U;
  volatile uint8_t x78 = 1U;
  int32_t t1 = 9206621;
  int8_t x191 = INT8_MIN;
  volatile int32_t x192 = -1;
  int64_t t3 = 95852408604498LL;
  volatile int16_t x503 = 243;
  static uint32_t x509 = 850672712U;
  static int16_t x512 = INT16_MAX;
  int32_t x553 = 14;
  int8_t x555 = -1;
  volatile uint16_t x612 = 105U;
  uint16_t x717 = 2U;
  volatile uint32_t x720 = 335268U;
  int16_t x815 = 122;
  static volatile uint32_t t15 = 14539993U;
  uint32_t x1185 = 5081192U;
  uint32_t t19 = 5U;
  int16_t x1204 = -1;
  uint8_t x1213 = 97U;
  static uint64_t x1337 = 216570813LLU;
  static volatile int64_t t24 = -9934918312580LL;
  int64_t x1487 = INT64_MAX;
  uint32_t x1495 = UINT32_MAX;
  volatile uint8_t x1522 = 1U;
  static int16_t x1523 = -1;
  uint32_t t27 = 995U;
  static int32_t t28 = 0;
  volatile int64_t x1991 = -1003LL;
  volatile int16_t x2069 = INT16_MAX;
  int16_t x2072 = INT16_MAX;
  int64_t x2099 = -1LL;
  static volatile uint16_t x2195 = 3U;
  int32_t t36 = -499917543;
  uint64_t x2267 = UINT64_MAX;
  volatile uint64_t t38 = 2LLU;
  uint32_t x2381 = UINT32_MAX;
  volatile uint32_t x2517 = UINT32_MAX;
  volatile int64_t t40 = 2815066236422698076LL;
  volatile int64_t x2599 = INT64_MIN;
  static int64_t t41 = -83272255LL;
  static uint32_t t43 = 51540455U;
  uint16_t x2777 = UINT16_MAX;
  static uint32_t x2789 = 6U;
  volatile int8_t x2936 = -1;
  static uint16_t x2942 = 4U;
  static volatile int32_t t48 = -420850639;
  static uint16_t x3025 = 524U;
  volatile uint64_t t51 = 3162309965LLU;
  uint16_t x3252 = UINT16_MAX;
  static uint16_t x3276 = 19U;
  static int64_t t53 = -730LL;
  volatile uint8_t x3286 = 11U;
  uint64_t x3288 = UINT64_MAX;
  uint64_t t54 = 52402329267692853LLU;
  uint16_t x3509 = 6551U;
  int16_t x3510 = 0;
  volatile uint16_t x3843 = UINT16_MAX;
  static int16_t x3844 = INT16_MIN;
  static int32_t t59 = 82828157;
  volatile int64_t x3916 = INT64_MIN;
  static int64_t x4023 = -238545LL;
  uint16_t x4027 = UINT16_MAX;
  static volatile int32_t t66 = -69;
  volatile uint64_t t67 = 12579LLU;
  uint16_t x4280 = UINT16_MAX;
  int16_t x4314 = 23;
  int64_t x4315 = INT64_MAX;
  int16_t x4316 = INT16_MIN;
  int16_t x4604 = -130;
  volatile int32_t t72 = 0;
  int32_t x4667 = -1;
  static volatile uint64_t t73 = 716736357230812804LLU;
  uint64_t x4816 = 222313LLU;
  uint8_t x4825 = 2U;
  uint64_t t77 = 1699851410LLU;
  int16_t x5103 = 378;
  uint8_t x5207 = UINT8_MAX;
  int64_t x5342 = 1LL;
  static uint32_t x5346 = 1U;
  int8_t x5348 = -1;
  uint32_t x5549 = 662892664U;
  uint32_t t87 = 30099288U;
  int8_t x5646 = 3;
  static volatile uint32_t x5785 = 672296U;
  int64_t x5797 = 8246103366LL;
  volatile int64_t t91 = 810LL;
  uint16_t x5867 = UINT16_MAX;
  int8_t x5868 = INT8_MIN;
  int16_t x5893 = INT16_MAX;
  int16_t x5894 = 0;
  volatile uint8_t x5927 = 50U;
  int64_t x5943 = 27LL;
  int16_t x5950 = 3;
  int16_t x5980 = INT16_MIN;
  int32_t x6012 = INT32_MIN;
  int64_t x6192 = -1217318219406534132LL;
  static volatile int16_t x6255 = -12;
  int8_t x6404 = -8;
  int8_t x6647 = INT8_MIN;
  uint16_t x6656 = UINT16_MAX;
  int64_t t107 = -182267602889LL;
  static volatile uint32_t x6657 = UINT32_MAX;
  uint64_t x6660 = UINT64_MAX;
  uint8_t x6701 = 0U;
  int16_t x6841 = INT16_MAX;
  uint8_t x6842 = 5U;
  static int16_t x6843 = 1469;
  volatile uint64_t t110 = 668505587951LLU;
  uint32_t t111 = 1869398187U;
  volatile uint8_t x6942 = 14U;
  uint64_t x7053 = 1388105511694074776LLU;
  int8_t x7184 = INT8_MIN;
  static int32_t t116 = -101;
  volatile int64_t x7452 = -1LL;
  uint16_t x7559 = 400U;
  static int8_t x7637 = 38;
  volatile uint8_t x7640 = 20U;
  int32_t t121 = -4601;
  volatile uint32_t x7653 = 1U;
  static int64_t x7668 = INT64_MIN;
  static int8_t x7743 = INT8_MIN;
  static uint16_t x7744 = 9846U;
  volatile uint64_t t124 = 191462912506164453LLU;
  int64_t x7889 = 2526662467191LL;
  static uint8_t x7891 = UINT8_MAX;
  static uint8_t x7947 = UINT8_MAX;
  uint16_t x8033 = 2U;
  int64_t x8036 = -1LL;
  uint16_t x8146 = 1U;
  int64_t t131 = 72328402LL;
  static volatile int16_t x8219 = INT16_MIN;
  int8_t x8220 = INT8_MIN;
  static volatile int32_t x8358 = 9;
  uint64_t x8425 = 2055042846413066907LLU;
  uint64_t x8433 = 15LLU;
  volatile uint64_t t136 = 190543804293189151LLU;
  int8_t x8454 = 2;
  int16_t x8456 = INT16_MIN;
  uint64_t x8547 = 484284LLU;
  volatile int8_t x8766 = 5;
  int8_t x8767 = 2;
  static uint32_t x8801 = 10861U;
  uint64_t x8833 = 6416874291534LLU;
  volatile int16_t x8852 = INT16_MAX;
  static volatile int32_t x8928 = 312329672;
  static uint8_t x8974 = 2U;
  uint32_t x9053 = 0U;
  uint16_t x9054 = 1U;
  uint16_t x9055 = 34U;
  uint16_t x9233 = 15380U;
  volatile int32_t x9321 = 486;
  int16_t x9396 = -1;
  int16_t x9440 = -1;
  int32_t x9539 = INT32_MAX;
  int16_t x9585 = INT16_MAX;
  uint32_t x9688 = 13U;
  int32_t t157 = -11453598;
  int16_t x10021 = INT16_MAX;
  uint16_t x10022 = 0U;
  uint16_t x10023 = 94U;
  static uint64_t t161 = 228433LLU;
  int64_t x10111 = INT64_MIN;
  int64_t t163 = 252159619232484606LL;
  static volatile uint32_t x10337 = UINT32_MAX;
  int8_t x10340 = 14;
  static uint32_t t164 = 886607U;
  volatile uint16_t x10358 = 16U;
  uint32_t x10393 = UINT32_MAX;
  uint8_t x10396 = 1U;
  volatile uint64_t t167 = 9383LLU;
  static int64_t x10667 = -228596702LL;
  int8_t x10770 = 4;
  volatile uint32_t t170 = 51U;
  uint64_t t171 = 215LLU;
  int16_t x11043 = INT16_MIN;
  volatile int16_t x11105 = INT16_MAX;
  uint8_t x11213 = UINT8_MAX;
  volatile int32_t t174 = -3769638;
  static uint64_t x11324 = 239036897223LLU;
  static uint32_t x11421 = 484U;
  uint64_t x11422 = 0LLU;
  uint32_t x11841 = 11U;
  uint64_t x11843 = 3190563730LLU;
  int16_t x11861 = 6188;
  uint64_t t181 = 7476LLU;
  int16_t x11876 = -1;
  volatile uint16_t x12001 = UINT16_MAX;
  volatile uint32_t t185 = 1463096U;
  static int16_t x12025 = INT16_MAX;
  volatile int32_t t186 = 239;
  int32_t x12089 = INT32_MAX;
  uint16_t x12105 = UINT16_MAX;
  uint8_t x12106 = 8U;
  static int32_t t188 = -130760514;
  static uint16_t x12125 = 7942U;
  uint8_t x12174 = 3U;
  int64_t t190 = -3203077465LL;
  uint8_t x12270 = 3U;
  static int8_t x12272 = INT8_MIN;
  int64_t x12295 = -7LL;
  int32_t x12363 = INT32_MAX;
  uint16_t x12402 = 3U;
  volatile int8_t x12469 = 1;
  
  
  void f0(void) {
      	int16_t x21 = INT16_MAX;
  	int16_t x23 = -1;
  
      t0 = ((x21<<x22)+(x23/x24));
  
      if (t0 != 4377750U) { NG(); } else { ; }
  	
  }
  
  void f1(void) {
      	uint8_t x77 = UINT8_MAX;
  	int8_t x79 = 47;
  	uint16_t x80 = 21U;
  
      t1 = ((x77<<x78)+(x79/x80));
  
      if (t1 != 512) { NG(); } else { ; }
  	
  }
  
  void f2(void) {
      	uint8_t x189 = 24U;
  	uint16_t x190 = 0U;
  	int32_t t2 = 220977;
  
      t2 = ((x189<<x190)+(x191/x192));
  
      if (t2 != 152) { NG(); } else { ; }
  	
  }
  
  void f3(void) {
      	int64_t x309 = 10LL;
  	int16_t x310 = 2;
  	int64_t x311 = INT64_MIN;
  	int64_t x312 = 7818576769LL;
  
      t3 = ((x309<<x310)+(x311/x312));
  
      if (t3 != -1179673999LL) { NG(); } else { ; }
  	
  }
  
  void f4(void) {
      	uint64_t x313 = UINT64_MAX;
  	int16_t x314 = 28;
  	static int32_t x315 = INT32_MIN;
  	static int64_t x316 = INT64_MIN;
  	uint64_t t4 = 193557633401499061LLU;
  
      t4 = ((x313<<x314)+(x315/x316));
  
      if (t4 != 18446744073441116160LLU) { NG(); } else { ; }
  	
  }
  
  void f5(void) {
      	volatile uint32_t x397 = 91373U;
  	uint64_t x398 = 0LLU;
  	int32_t x399 = -3265915;
  	int8_t x400 = 1;
  	uint32_t t5 = 400462U;
  
      t5 = ((x397<<x398)+(x399/x400));
  
      if (t5 != 4291792754U) { NG(); } else { ; }
  	
  }
  
  void f6(void) {
      	volatile uint16_t x493 = 66U;
  	uint16_t x494 = 22U;
  	int64_t x495 = INT64_MIN;
  	int32_t x496 = INT32_MIN;
  	int64_t t6 = 933892LL;
  
      t6 = ((x493<<x494)+(x495/x496));
  
      if (t6 != 4571791360LL) { NG(); } else { ; }
  	
  }
  
  void f7(void) {
      	int64_t x501 = INT64_MAX;
  	int8_t x502 = 0;
  	uint64_t x504 = 1641LLU;
  	volatile uint64_t t7 = 389576861LLU;
  
      t7 = ((x501<<x502)+(x503/x504));
  
      if (t7 != 9223372036854775807LLU) { NG(); } else { ; }
  	
  }
  
  void f8(void) {
      	uint8_t x510 = 1U;
  	volatile int16_t x511 = -3;
  	volatile uint32_t t8 = 1194U;
  
      t8 = ((x509<<x510)+(x511/x512));
  
      if (t8 != 1701345424U) { NG(); } else { ; }
  	
  }
  
  void f9(void) {
      	uint64_t x513 = 58109025293671141LLU;
  	uint8_t x514 = 7U;
  	int64_t x515 = -1LL;
  	int64_t x516 = INT64_MAX;
  	volatile uint64_t t9 = 102932998535397LLU;
  
      t9 = ((x513<<x514)+(x515/x516));
  
      if (t9 != 7437955237589906048LLU) { NG(); } else { ; }
  	
  }
  
  void f10(void) {
      	uint16_t x554 = 3U;
  	int32_t x556 = INT32_MIN;
  	volatile int32_t t10 = -320579099;
  
      t10 = ((x553<<x554)+(x555/x556));
  
      if (t10 != 112) { NG(); } else { ; }
  	
  }
  
  void f11(void) {
      	int8_t x609 = 8;
  	int16_t x610 = 7;
  	static int16_t x611 = 91;
  	volatile int32_t t11 = 4702;
  
      t11 = ((x609<<x610)+(x611/x612));
  
      if (t11 != 1024) { NG(); } else { ; }
  	
  }
  
  void f12(void) {
      	uint16_t x625 = UINT16_MAX;
  	static int16_t x626 = 1;
  	volatile int32_t x627 = -1;
  	int16_t x628 = INT16_MAX;
  	int32_t t12 = -113208;
  
      t12 = ((x625<<x626)+(x627/x628));
  
      if (t12 != 131070) { NG(); } else { ; }
  	
  }
  
  void f13(void) {
      	int32_t x718 = 0;
  	int32_t x719 = 17830;
  	volatile uint32_t t13 = 991U;
  
      t13 = ((x717<<x718)+(x719/x720));
  
      if (t13 != 2U) { NG(); } else { ; }
  	
  }
  
  void f14(void) {
      	uint16_t x813 = UINT16_MAX;
  	int16_t x814 = 1;
  	volatile int8_t x816 = INT8_MIN;
  	int32_t t14 = 18938705;
  
      t14 = ((x813<<x814)+(x815/x816));
  
      if (t14 != 131070) { NG(); } else { ; }
  	
  }
  
  void f15(void) {
      	static uint8_t x957 = UINT8_MAX;
  	uint16_t x958 = 14U;
  	int32_t x959 = INT32_MIN;
  	uint32_t x960 = 2276U;
  
      t15 = ((x957<<x958)+(x959/x960));
  
      if (t15 != 5121454U) { NG(); } else { ; }
  	
  }
  
  void f16(void) {
      	uint32_t x985 = UINT32_MAX;
  	uint16_t x986 = 0U;
  	volatile uint8_t x987 = UINT8_MAX;
  	static int8_t x988 = INT8_MAX;
  	volatile uint32_t t16 = 166329U;
  
      t16 = ((x985<<x986)+(x987/x988));
  
      if (t16 != 1U) { NG(); } else { ; }
  	
  }
  
  void f17(void) {
      	int32_t x1137 = 4893;
  	static uint32_t x1138 = 2U;
  	int64_t x1139 = INT64_MIN;
  	uint8_t x1140 = 3U;
  	int64_t t17 = -151917LL;
  
      t17 = ((x1137<<x1138)+(x1139/x1140));
  
      if (t17 != -3074457345618239030LL) { NG(); } else { ; }
  	
  }
  
  void f18(void) {
      	volatile int8_t x1149 = 1;
  	uint8_t x1150 = 2U;
  	static int32_t x1151 = 1;
  	int8_t x1152 = INT8_MIN;
  	int32_t t18 = -9819118;
  
      t18 = ((x1149<<x1150)+(x1151/x1152));
  
      if (t18 != 4) { NG(); } else { ; }
  	
  }
  
  void f19(void) {
      	int8_t x1186 = 4;
  	volatile int32_t x1187 = 21;
  	int16_t x1188 = 7;
  
      t19 = ((x1185<<x1186)+(x1187/x1188));
  
      if (t19 != 81299075U) { NG(); } else { ; }
  	
  }
  
  void f20(void) {
      	uint64_t x1201 = 13419223391518LLU;
  	static int16_t x1202 = 7;
  	int8_t x1203 = -1;
  	uint64_t t20 = 15686834LLU;
  
      t20 = ((x1201<<x1202)+(x1203/x1204));
  
      if (t20 != 1717660594114305LLU) { NG(); } else { ; }
  	
  }
  
  void f21(void) {
      	static uint32_t x1214 = 7U;
  	uint16_t x1215 = 24518U;
  	static volatile int16_t x1216 = -1;
  	int32_t t21 = 1;
  
      t21 = ((x1213<<x1214)+(x1215/x1216));
  
      if (t21 != -12102) { NG(); } else { ; }
  	
  }
  
  void f22(void) {
      	volatile uint64_t x1229 = UINT64_MAX;
  	static int8_t x1230 = 3;
  	static volatile int64_t x1231 = 42909LL;
  	static volatile uint32_t x1232 = UINT32_MAX;
  	volatile uint64_t t22 = 223588740759LLU;
  
      t22 = ((x1229<<x1230)+(x1231/x1232));
  
      if (t22 != 18446744073709551608LLU) { NG(); } else { ; }
  	
  }
  
  void f23(void) {
      	uint8_t x1338 = 6U;
  	int64_t x1339 = INT64_MAX;
  	static volatile int64_t x1340 = INT64_MAX;
  	uint64_t t23 = 16LLU;
  
      t23 = ((x1337<<x1338)+(x1339/x1340));
  
      if (t23 != 13860532033LLU) { NG(); } else { ; }
  	
  }
  
  void f24(void) {
      	uint16_t x1453 = 471U;
  	uint16_t x1454 = 1U;
  	uint32_t x1455 = 1640090U;
  	int64_t x1456 = INT64_MAX;
  
      t24 = ((x1453<<x1454)+(x1455/x1456));
  
      if (t24 != 942LL) { NG(); } else { ; }
  	
  }
  
  void f25(void) {
      	uint16_t x1485 = 4941U;
  	int32_t x1486 = 0;
  	int16_t x1488 = INT16_MIN;
  	volatile int64_t t25 = 366LL;
  
      t25 = ((x1485<<x1486)+(x1487/x1488));
  
      if (t25 != -281474976705714LL) { NG(); } else { ; }
  	
  }
  
  void f26(void) {
      	int8_t x1493 = 1;
  	int8_t x1494 = 5;
  	int32_t x1496 = -1;
  	static uint32_t t26 = 214071U;
  
      t26 = ((x1493<<x1494)+(x1495/x1496));
  
      if (t26 != 33U) { NG(); } else { ; }
  	
  }
  
  void f27(void) {
      	volatile uint32_t x1521 = UINT32_MAX;
  	int32_t x1524 = -55079;
  
      t27 = ((x1521<<x1522)+(x1523/x1524));
  
      if (t27 != 4294967294U) { NG(); } else { ; }
  	
  }
  
  void f28(void) {
      	uint8_t x1693 = UINT8_MAX;
  	int8_t x1694 = 0;
  	static int16_t x1695 = INT16_MIN;
  	int16_t x1696 = INT16_MAX;
  
      t28 = ((x1693<<x1694)+(x1695/x1696));
  
      if (t28 != 254) { NG(); } else { ; }
  	
  }
  
  void f29(void) {
      	uint8_t x1717 = 98U;
  	volatile uint8_t x1718 = 1U;
  	uint8_t x1719 = 24U;
  	volatile uint8_t x1720 = 3U;
  	int32_t t29 = -190;
  
      t29 = ((x1717<<x1718)+(x1719/x1720));
  
      if (t29 != 204) { NG(); } else { ; }
  	
  }
  
  void f30(void) {
      	int8_t x1777 = INT8_MAX;
  	int8_t x1778 = 7;
  	int32_t x1779 = INT32_MAX;
  	uint16_t x1780 = 27U;
  	volatile int32_t t30 = 556076618;
  
      t30 = ((x1777<<x1778)+(x1779/x1780));
  
      if (t30 != 79552687) { NG(); } else { ; }
  	
  }
  
  void f31(void) {
      	int16_t x1989 = INT16_MAX;
  	int32_t x1990 = 0;
  	static int16_t x1992 = 918;
  	int64_t t31 = 8078729730LL;
  
      t31 = ((x1989<<x1990)+(x1991/x1992));
  
      if (t31 != 32766LL) { NG(); } else { ; }
  	
  }
  
  void f32(void) {
      	int8_t x2037 = INT8_MAX;
  	uint8_t x2038 = 6U;
  	static int64_t x2039 = INT64_MIN;
  	static int64_t x2040 = INT64_MIN;
  	int64_t t32 = -1633349506712435063LL;
  
      t32 = ((x2037<<x2038)+(x2039/x2040));
  
      if (t32 != 8129LL) { NG(); } else { ; }
  	
  }
  
  void f33(void) {
      	uint16_t x2041 = 50U;
  	volatile int8_t x2042 = 1;
  	volatile uint16_t x2043 = UINT16_MAX;
  	static int8_t x2044 = INT8_MIN;
  	int32_t t33 = 1;
  
      t33 = ((x2041<<x2042)+(x2043/x2044));
  
      if (t33 != -411) { NG(); } else { ; }
  	
  }
  
  void f34(void) {
      	uint8_t x2070 = 14U;
  	uint64_t x2071 = 13115752648402LLU;
  	volatile uint64_t t34 = 1446520030478656LLU;
  
      t34 = ((x2069<<x2070)+(x2071/x2072));
  
      if (t34 != 937127749LLU) { NG(); } else { ; }
  	
  }
  
  void f35(void) {
      	uint32_t x2097 = UINT32_MAX;
  	uint16_t x2098 = 2U;
  	volatile uint32_t x2100 = UINT32_MAX;
  	volatile int64_t t35 = -32410728LL;
  
      t35 = ((x2097<<x2098)+(x2099/x2100));
  
      if (t35 != 4294967292LL) { NG(); } else { ; }
  	
  }
  
  void f36(void) {
      	static uint16_t x2193 = UINT16_MAX;
  	uint16_t x2194 = 2U;
  	int8_t x2196 = INT8_MIN;
  
      t36 = ((x2193<<x2194)+(x2195/x2196));
  
      if (t36 != 262140) { NG(); } else { ; }
  	
  }
  
  void f37(void) {
      	uint16_t x2217 = 9U;
  	uint8_t x2218 = 9U;
  	uint32_t x2219 = 135395097U;
  	int8_t x2220 = 5;
  	volatile uint32_t t37 = 2U;
  
      t37 = ((x2217<<x2218)+(x2219/x2220));
  
      if (t37 != 27083627U) { NG(); } else { ; }
  	
  }
  
  void f38(void) {
      	int64_t x2265 = 7LL;
  	volatile uint32_t x2266 = 7U;
  	static int8_t x2268 = INT8_MIN;
  
      t38 = ((x2265<<x2266)+(x2267/x2268));
  
      if (t38 != 897LLU) { NG(); } else { ; }
  	
  }
  
  void f39(void) {
      	uint16_t x2382 = 19U;
  	volatile int16_t x2383 = -7;
  	uint8_t x2384 = UINT8_MAX;
  	volatile uint32_t t39 = 48505353U;
  
      t39 = ((x2381<<x2382)+(x2383/x2384));
  
      if (t39 != 4294443008U) { NG(); } else { ; }
  	
  }
  
  void f40(void) {
      	static uint32_t x2518 = 1U;
  	uint32_t x2519 = UINT32_MAX;
  	int64_t x2520 = INT64_MAX;
  
      t40 = ((x2517<<x2518)+(x2519/x2520));
  
      if (t40 != 4294967294LL) { NG(); } else { ; }
  	
  }
  
  void f41(void) {
      	uint8_t x2597 = 7U;
  	uint8_t x2598 = 21U;
  	static int32_t x2600 = INT32_MAX;
  
      t41 = ((x2597<<x2598)+(x2599/x2600));
  
      if (t41 != -4280287234LL) { NG(); } else { ; }
  	
  }
  
  void f42(void) {
      	uint64_t x2665 = 1891173LLU;
  	uint16_t x2666 = 18U;
  	int64_t x2667 = -592095049102LL;
  	volatile int64_t x2668 = INT64_MIN;
  	uint64_t t42 = 239105736579810129LLU;
  
      t42 = ((x2665<<x2666)+(x2667/x2668));
  
      if (t42 != 495759654912LLU) { NG(); } else { ; }
  	
  }
  
  void f43(void) {
      	volatile uint16_t x2769 = UINT16_MAX;
  	uint8_t x2770 = 1U;
  	uint32_t x2771 = 348213598U;
  	uint32_t x2772 = 12U;
  
      t43 = ((x2769<<x2770)+(x2771/x2772));
  
      if (t43 != 29148869U) { NG(); } else { ; }
  	
  }
  
  void f44(void) {
      	int8_t x2778 = 0;
  	uint16_t x2779 = UINT16_MAX;
  	int64_t x2780 = INT64_MIN;
  	volatile int64_t t44 = -1804038301LL;
  
      t44 = ((x2777<<x2778)+(x2779/x2780));
  
      if (t44 != 65535LL) { NG(); } else { ; }
  	
  }
  
  void f45(void) {
      	static int8_t x2790 = 2;
  	volatile int32_t x2791 = 423101520;
  	volatile uint8_t x2792 = UINT8_MAX;
  	volatile uint32_t t45 = 2896U;
  
      t45 = ((x2789<<x2790)+(x2791/x2792));
  
      if (t45 != 1659245U) { NG(); } else { ; }
  	
  }
  
  void f46(void) {
      	uint16_t x2793 = 4763U;
  	static volatile uint16_t x2794 = 2U;
  	int8_t x2795 = INT8_MIN;
  	uint64_t x2796 = 37997452643068094LLU;
  	volatile uint64_t t46 = 1LLU;
  
      t46 = ((x2793<<x2794)+(x2795/x2796));
  
      if (t46 != 19537LLU) { NG(); } else { ; }
  	
  }
  
  void f47(void) {
      	static volatile uint8_t x2933 = 75U;
  	int8_t x2934 = 15;
  	uint32_t x2935 = UINT32_MAX;
  	uint32_t t47 = 4491087U;
  
      t47 = ((x2933<<x2934)+(x2935/x2936));
  
      if (t47 != 2457601U) { NG(); } else { ; }
  	
  }
  
  void f48(void) {
      	static int16_t x2941 = INT16_MAX;
  	int8_t x2943 = INT8_MIN;
  	volatile int16_t x2944 = -48;
  
      t48 = ((x2941<<x2942)+(x2943/x2944));
  
      if (t48 != 524274) { NG(); } else { ; }
  	
  }
  
  void f49(void) {
      	static volatile int64_t x3005 = 0LL;
  	uint8_t x3006 = 1U;
  	int32_t x3007 = INT32_MIN;
  	uint16_t x3008 = 30342U;
  	volatile int64_t t49 = 3260243LL;
  
      t49 = ((x3005<<x3006)+(x3007/x3008));
  
      if (t49 != -70775LL) { NG(); } else { ; }
  	
  }
  
  void f50(void) {
      	int8_t x3026 = 2;
  	int64_t x3027 = INT64_MIN;
  	volatile int64_t x3028 = INT64_MIN;
  	int64_t t50 = -319799243988LL;
  
      t50 = ((x3025<<x3026)+(x3027/x3028));
  
      if (t50 != 2097LL) { NG(); } else { ; }
  	
  }
  
  void f51(void) {
      	uint8_t x3049 = 25U;
  	uint16_t x3050 = 9U;
  	static uint64_t x3051 = 46380320LLU;
  	volatile int32_t x3052 = INT32_MAX;
  
      t51 = ((x3049<<x3050)+(x3051/x3052));
  
      if (t51 != 12800LLU) { NG(); } else { ; }
  	
  }
  
  void f52(void) {
      	uint16_t x3249 = 10U;
  	uint16_t x3250 = 19U;
  	volatile int8_t x3251 = -1;
  	static volatile int32_t t52 = -1345;
  
      t52 = ((x3249<<x3250)+(x3251/x3252));
  
      if (t52 != 5242880) { NG(); } else { ; }
  	
  }
  
  void f53(void) {
      	volatile uint32_t x3273 = 15721244U;
  	uint16_t x3274 = 1U;
  	static volatile int64_t x3275 = -7177984565LL;
  
      t53 = ((x3273<<x3274)+(x3275/x3276));
  
      if (t53 != -346346173LL) { NG(); } else { ; }
  	
  }
  
  void f54(void) {
      	uint64_t x3285 = UINT64_MAX;
  	volatile int32_t x3287 = -1;
  
      t54 = ((x3285<<x3286)+(x3287/x3288));
  
      if (t54 != 18446744073709549569LLU) { NG(); } else { ; }
  	
  }
  
  void f55(void) {
      	static int32_t x3511 = INT32_MIN;
  	int8_t x3512 = INT8_MIN;
  	int32_t t55 = -943;
  
      t55 = ((x3509<<x3510)+(x3511/x3512));
  
      if (t55 != 16783767) { NG(); } else { ; }
  	
  }
  
  void f56(void) {
      	uint8_t x3569 = 37U;
  	static volatile uint8_t x3570 = 16U;
  	int8_t x3571 = -1;
  	int16_t x3572 = -1;
  	int32_t t56 = -10;
  
      t56 = ((x3569<<x3570)+(x3571/x3572));
  
      if (t56 != 2424833) { NG(); } else { ; }
  	
  }
  
  void f57(void) {
      	int8_t x3745 = 25;
  	int8_t x3746 = 21;
  	uint32_t x3747 = 7952117U;
  	int32_t x3748 = INT32_MIN;
  	uint32_t t57 = 504U;
  
      t57 = ((x3745<<x3746)+(x3747/x3748));
  
      if (t57 != 52428800U) { NG(); } else { ; }
  	
  }
  
  void f58(void) {
      	uint16_t x3841 = UINT16_MAX;
  	int16_t x3842 = 1;
  	static volatile int32_t t58 = 15363314;
  
      t58 = ((x3841<<x3842)+(x3843/x3844));
  
      if (t58 != 131069) { NG(); } else { ; }
  	
  }
  
  void f59(void) {
      	int32_t x3885 = 118047;
  	uint8_t x3886 = 1U;
  	int32_t x3887 = -57571;
  	uint16_t x3888 = 10U;
  
      t59 = ((x3885<<x3886)+(x3887/x3888));
  
      if (t59 != 230337) { NG(); } else { ; }
  	
  }
  
  void f60(void) {
      	uint16_t x3897 = 6322U;
  	static uint16_t x3898 = 2U;
  	uint8_t x3899 = 62U;
  	int8_t x3900 = -7;
  	volatile int32_t t60 = 26837292;
  
      t60 = ((x3897<<x3898)+(x3899/x3900));
  
      if (t60 != 25280) { NG(); } else { ; }
  	
  }
  
  void f61(void) {
      	uint32_t x3913 = UINT32_MAX;
  	volatile uint8_t x3914 = 1U;
  	int64_t x3915 = INT64_MIN;
  	static volatile int64_t t61 = 1572745427020LL;
  
      t61 = ((x3913<<x3914)+(x3915/x3916));
  
      if (t61 != 4294967295LL) { NG(); } else { ; }
  	
  }
  
  void f62(void) {
      	uint64_t x3977 = 125838746703724187LLU;
  	static int8_t x3978 = 40;
  	uint16_t x3979 = UINT16_MAX;
  	int16_t x3980 = INT16_MAX;
  	uint64_t t62 = 8880199917685930LLU;
  
      t62 = ((x3977<<x3978)+(x3979/x3980));
  
      if (t62 != 4719379883833163778LLU) { NG(); } else { ; }
  	
  }
  
  void f63(void) {
      	volatile uint64_t x3989 = 20025421LLU;
  	int64_t x3990 = 1LL;
  	volatile uint16_t x3991 = 44U;
  	volatile int32_t x3992 = INT32_MAX;
  	volatile uint64_t t63 = 33753051LLU;
  
      t63 = ((x3989<<x3990)+(x3991/x3992));
  
      if (t63 != 40050842LLU) { NG(); } else { ; }
  	
  }
  
  void f64(void) {
      	static uint16_t x4021 = 0U;
  	uint8_t x4022 = 11U;
  	volatile int32_t x4024 = INT32_MIN;
  	static volatile int64_t t64 = 0LL;
  
      t64 = ((x4021<<x4022)+(x4023/x4024));
  
      if (t64 != 0LL) { NG(); } else { ; }
  	
  }
  
  void f65(void) {
      	uint64_t x4025 = 299360809LLU;
  	uint8_t x4026 = 2U;
  	int8_t x4028 = -44;
  	static volatile uint64_t t65 = 6871752474210264665LLU;
  
      t65 = ((x4025<<x4026)+(x4027/x4028));
  
      if (t65 != 1197441747LLU) { NG(); } else { ; }
  	
  }
  
  void f66(void) {
      	int32_t x4053 = 429;
  	static volatile int8_t x4054 = 7;
  	int16_t x4055 = INT16_MIN;
  	uint16_t x4056 = UINT16_MAX;
  
      t66 = ((x4053<<x4054)+(x4055/x4056));
  
      if (t66 != 54912) { NG(); } else { ; }
  	
  }
  
  void f67(void) {
      	uint8_t x4097 = 14U;
  	volatile uint8_t x4098 = 16U;
  	uint64_t x4099 = UINT64_MAX;
  	int64_t x4100 = -2773149LL;
  
      t67 = ((x4097<<x4098)+(x4099/x4100));
  
      if (t67 != 917505LLU) { NG(); } else { ; }
  	
  }
  
  void f68(void) {
      	int16_t x4269 = 0;
  	uint8_t x4270 = 7U;
  	static volatile int32_t x4271 = INT32_MIN;
  	static volatile int16_t x4272 = INT16_MAX;
  	int32_t t68 = 167537413;
  
      t68 = ((x4269<<x4270)+(x4271/x4272));
  
      if (t68 != -65538) { NG(); } else { ; }
  	
  }
  
  void f69(void) {
      	volatile uint16_t x4277 = 28U;
  	int8_t x4278 = 3;
  	static int64_t x4279 = -1LL;
  	int64_t t69 = -7881474110105306LL;
  
      t69 = ((x4277<<x4278)+(x4279/x4280));
  
      if (t69 != 224LL) { NG(); } else { ; }
  	
  }
  
  void f70(void) {
      	static uint8_t x4313 = 12U;
  	volatile int64_t t70 = 0LL;
  
      t70 = ((x4313<<x4314)+(x4315/x4316));
  
      if (t70 != -281474876047359LL) { NG(); } else { ; }
  	
  }
  
  void f71(void) {
      	static uint32_t x4369 = UINT32_MAX;
  	int8_t x4370 = 0;
  	uint64_t x4371 = 10301243LLU;
  	volatile int32_t x4372 = -1;
  	volatile uint64_t t71 = 56LLU;
  
      t71 = ((x4369<<x4370)+(x4371/x4372));
  
      if (t71 != 4294967295LLU) { NG(); } else { ; }
  	
  }
  
  void f72(void) {
      	int8_t x4601 = 2;
  	uint16_t x4602 = 0U;
  	int16_t x4603 = INT16_MAX;
  
      t72 = ((x4601<<x4602)+(x4603/x4604));
  
      if (t72 != -250) { NG(); } else { ; }
  	
  }
  
  void f73(void) {
      	uint64_t x4665 = 7070LLU;
  	uint16_t x4666 = 1U;
  	static int8_t x4668 = -1;
  
      t73 = ((x4665<<x4666)+(x4667/x4668));
  
      if (t73 != 14141LLU) { NG(); } else { ; }
  	
  }
  
  void f74(void) {
      	uint64_t x4725 = 30695472262268LLU;
  	uint64_t x4726 = 3LLU;
  	volatile uint16_t x4727 = UINT16_MAX;
  	int16_t x4728 = -380;
  	volatile uint64_t t74 = 34557649LLU;
  
      t74 = ((x4725<<x4726)+(x4727/x4728));
  
      if (t74 != 245563778097972LLU) { NG(); } else { ; }
  	
  }
  
  void f75(void) {
      	volatile int8_t x4813 = 19;
  	uint8_t x4814 = 9U;
  	volatile int32_t x4815 = 204;
  	static volatile uint64_t t75 = 712LLU;
  
      t75 = ((x4813<<x4814)+(x4815/x4816));
  
      if (t75 != 9728LLU) { NG(); } else { ; }
  	
  }
  
  void f76(void) {
      	uint8_t x4826 = 1U;
  	static int8_t x4827 = -1;
  	static int16_t x4828 = INT16_MIN;
  	volatile int32_t t76 = 6944;
  
      t76 = ((x4825<<x4826)+(x4827/x4828));
  
      if (t76 != 4) { NG(); } else { ; }
  	
  }
  
  void f77(void) {
      	int32_t x4845 = INT32_MAX;
  	int8_t x4846 = 0;
  	static int8_t x4847 = -19;
  	volatile uint64_t x4848 = UINT64_MAX;
  
      t77 = ((x4845<<x4846)+(x4847/x4848));
  
      if (t77 != 2147483647LLU) { NG(); } else { ; }
  	
  }
  
  void f78(void) {
      	volatile int32_t x4969 = 49282;
  	int8_t x4970 = 0;
  	volatile int32_t x4971 = 3360;
  	int32_t x4972 = INT32_MAX;
  	int32_t t78 = -1;
  
      t78 = ((x4969<<x4970)+(x4971/x4972));
  
      if (t78 != 49282) { NG(); } else { ; }
  	
  }
  
  void f79(void) {
      	static int16_t x5101 = INT16_MAX;
  	static int16_t x5102 = 0;
  	int32_t x5104 = INT32_MAX;
  	int32_t t79 = -121;
  
      t79 = ((x5101<<x5102)+(x5103/x5104));
  
      if (t79 != 32767) { NG(); } else { ; }
  	
  }
  
  void f80(void) {
      	uint32_t x5133 = 40020834U;
  	static int8_t x5134 = 1;
  	uint64_t x5135 = UINT64_MAX;
  	uint64_t x5136 = 37533353LLU;
  	static uint64_t t80 = 32791102LLU;
  
      t80 = ((x5133<<x5134)+(x5135/x5136));
  
      if (t80 != 491556091615LLU) { NG(); } else { ; }
  	
  }
  
  void f81(void) {
      	static volatile uint64_t x5205 = 883766536300452LLU;
  	int16_t x5206 = 4;
  	static int16_t x5208 = INT16_MIN;
  	uint64_t t81 = 31011943LLU;
  
      t81 = ((x5205<<x5206)+(x5207/x5208));
  
      if (t81 != 14140264580807232LLU) { NG(); } else { ; }
  	
  }
  
  void f82(void) {
      	volatile int32_t x5277 = 108;
  	uint32_t x5278 = 1U;
  	static uint64_t x5279 = 965477436628LLU;
  	volatile uint64_t x5280 = 2113769084949013LLU;
  	volatile uint64_t t82 = 32LLU;
  
      t82 = ((x5277<<x5278)+(x5279/x5280));
  
      if (t82 != 216LLU) { NG(); } else { ; }
  	
  }
  
  void f83(void) {
      	int16_t x5341 = INT16_MAX;
  	int16_t x5343 = INT16_MIN;
  	int64_t x5344 = 1630652350LL;
  	int64_t t83 = -50013820129886LL;
  
      t83 = ((x5341<<x5342)+(x5343/x5344));
  
      if (t83 != 65534LL) { NG(); } else { ; }
  	
  }
  
  void f84(void) {
      	uint64_t x5345 = 3641703LLU;
  	volatile int8_t x5347 = -1;
  	volatile uint64_t t84 = 637372664597195LLU;
  
      t84 = ((x5345<<x5346)+(x5347/x5348));
  
      if (t84 != 7283407LLU) { NG(); } else { ; }
  	
  }
  
  void f85(void) {
      	int32_t x5381 = 9;
  	static int16_t x5382 = 3;
  	int64_t x5383 = INT64_MIN;
  	int16_t x5384 = INT16_MAX;
  	volatile int64_t t85 = -644LL;
  
      t85 = ((x5381<<x5382)+(x5383/x5384));
  
      if (t85 != -281483566907328LL) { NG(); } else { ; }
  	
  }
  
  void f86(void) {
      	int8_t x5437 = 47;
  	static volatile uint8_t x5438 = 1U;
  	static volatile int32_t x5439 = INT32_MAX;
  	static int16_t x5440 = INT16_MIN;
  	volatile int32_t t86 = -704;
  
      t86 = ((x5437<<x5438)+(x5439/x5440));
  
      if (t86 != -65441) { NG(); } else { ; }
  	
  }
  
  void f87(void) {
      	static uint8_t x5550 = 12U;
  	int8_t x5551 = INT8_MAX;
  	static int32_t x5552 = -1;
  
      t87 = ((x5549<<x5550)+(x5551/x5552));
  
      if (t87 != 789020545U) { NG(); } else { ; }
  	
  }
  
  void f88(void) {
      	uint64_t x5645 = UINT64_MAX;
  	volatile int8_t x5647 = INT8_MIN;
  	int64_t x5648 = -1LL;
  	uint64_t t88 = 15516004510655914LLU;
  
      t88 = ((x5645<<x5646)+(x5647/x5648));
  
      if (t88 != 120LLU) { NG(); } else { ; }
  	
  }
  
  void f89(void) {
      	static int32_t x5721 = 1024811;
  	volatile uint8_t x5722 = 4U;
  	int8_t x5723 = 2;
  	int16_t x5724 = 2;
  	volatile int32_t t89 = 34;
  
      t89 = ((x5721<<x5722)+(x5723/x5724));
  
      if (t89 != 16396977) { NG(); } else { ; }
  	
  }
  
  void f90(void) {
      	volatile uint16_t x5786 = 3U;
  	volatile int32_t x5787 = INT32_MIN;
  	uint64_t x5788 = 600974874399841LLU;
  	uint64_t t90 = 28098LLU;
  
      t90 = ((x5785<<x5786)+(x5787/x5788));
  
      if (t90 != 5409062LLU) { NG(); } else { ; }
  	
  }
  
  void f91(void) {
      	uint8_t x5798 = 26U;
  	volatile int16_t x5799 = -44;
  	int64_t x5800 = -1LL;
  
      t91 = ((x5797<<x5798)+(x5799/x5800));
  
      if (t91 != 553386629318836268LL) { NG(); } else { ; }
  	
  }
  
  void f92(void) {
      	uint32_t x5865 = 459U;
  	int8_t x5866 = 0;
  	static volatile uint32_t t92 = 0U;
  
      t92 = ((x5865<<x5866)+(x5867/x5868));
  
      if (t92 != 4294967244U) { NG(); } else { ; }
  	
  }
  
  void f93(void) {
      	int64_t x5895 = -1LL;
  	int16_t x5896 = INT16_MIN;
  	int64_t t93 = -14400563724435LL;
  
      t93 = ((x5893<<x5894)+(x5895/x5896));
  
      if (t93 != 32767LL) { NG(); } else { ; }
  	
  }
  
  void f94(void) {
      	volatile int64_t x5925 = 1705436LL;
  	int8_t x5926 = 0;
  	static uint8_t x5928 = 5U;
  	int64_t t94 = -10LL;
  
      t94 = ((x5925<<x5926)+(x5927/x5928));
  
      if (t94 != 1705446LL) { NG(); } else { ; }
  	
  }
  
  void f95(void) {
      	volatile int64_t x5941 = 66539563LL;
  	uint32_t x5942 = 24U;
  	static volatile int32_t x5944 = -1;
  	int64_t t95 = 235026LL;
  
      t95 = ((x5941<<x5942)+(x5943/x5944));
  
      if (t95 != 1116348620996581LL) { NG(); } else { ; }
  	
  }
  
  void f96(void) {
      	uint8_t x5949 = 0U;
  	uint64_t x5951 = UINT64_MAX;
  	volatile int16_t x5952 = 66;
  	uint64_t t96 = 1524200422263LLU;
  
      t96 = ((x5949<<x5950)+(x5951/x5952));
  
      if (t96 != 279496122328932600LLU) { NG(); } else { ; }
  	
  }
  
  void f97(void) {
      	volatile int8_t x5977 = 14;
  	int64_t x5978 = 0LL;
  	uint16_t x5979 = 4U;
  	int32_t t97 = 4;
  
      t97 = ((x5977<<x5978)+(x5979/x5980));
  
      if (t97 != 14) { NG(); } else { ; }
  	
  }
  
  void f98(void) {
      	uint8_t x5989 = 3U;
  	int8_t x5990 = 0;
  	volatile int8_t x5991 = INT8_MIN;
  	static int8_t x5992 = -1;
  	volatile int32_t t98 = 257472;
  
      t98 = ((x5989<<x5990)+(x5991/x5992));
  
      if (t98 != 131) { NG(); } else { ; }
  	
  }
  
  void f99(void) {
      	static volatile uint8_t x6009 = 3U;
  	uint8_t x6010 = 19U;
  	uint16_t x6011 = UINT16_MAX;
  	volatile int32_t t99 = 0;
  
      t99 = ((x6009<<x6010)+(x6011/x6012));
  
      if (t99 != 1572864) { NG(); } else { ; }
  	
  }
  
  void f100(void) {
      	uint8_t x6137 = UINT8_MAX;
  	uint8_t x6138 = 1U;
  	int16_t x6139 = 194;
  	static int8_t x6140 = INT8_MAX;
  	int32_t t100 = -6967;
  
      t100 = ((x6137<<x6138)+(x6139/x6140));
  
      if (t100 != 511) { NG(); } else { ; }
  	
  }
  
  void f101(void) {
      	uint32_t x6189 = UINT32_MAX;
  	volatile uint8_t x6190 = 4U;
  	uint16_t x6191 = 7U;
  	int64_t t101 = -8961LL;
  
      t101 = ((x6189<<x6190)+(x6191/x6192));
  
      if (t101 != 4294967280LL) { NG(); } else { ; }
  	
  }
  
  void f102(void) {
      	static volatile int32_t x6253 = 28815;
  	volatile uint8_t x6254 = 13U;
  	int64_t x6256 = INT64_MAX;
  	volatile int64_t t102 = 25986494LL;
  
      t102 = ((x6253<<x6254)+(x6255/x6256));
  
      if (t102 != 236052480LL) { NG(); } else { ; }
  	
  }
  
  void f103(void) {
      	uint64_t x6333 = 642871LLU;
  	int32_t x6334 = 0;
  	int32_t x6335 = -1;
  	volatile int8_t x6336 = INT8_MAX;
  	volatile uint64_t t103 = 134458317478201508LLU;
  
      t103 = ((x6333<<x6334)+(x6335/x6336));
  
      if (t103 != 642871LLU) { NG(); } else { ; }
  	
  }
  
  void f104(void) {
      	uint64_t x6401 = UINT64_MAX;
  	uint8_t x6402 = 9U;
  	volatile int64_t x6403 = -1LL;
  	uint64_t t104 = 55513LLU;
  
      t104 = ((x6401<<x6402)+(x6403/x6404));
  
      if (t104 != 18446744073709551104LLU) { NG(); } else { ; }
  	
  }
  
  void f105(void) {
      	uint16_t x6597 = 1U;
  	static uint16_t x6598 = 3U;
  	static volatile int8_t x6599 = INT8_MIN;
  	int8_t x6600 = -1;
  	int32_t t105 = 55851;
  
      t105 = ((x6597<<x6598)+(x6599/x6600));
  
      if (t105 != 136) { NG(); } else { ; }
  	
  }
  
  void f106(void) {
      	static int8_t x6645 = 5;
  	int16_t x6646 = 0;
  	uint8_t x6648 = 2U;
  	volatile int32_t t106 = 103084316;
  
      t106 = ((x6645<<x6646)+(x6647/x6648));
  
      if (t106 != -59) { NG(); } else { ; }
  	
  }
  
  void f107(void) {
      	volatile uint32_t x6653 = UINT32_MAX;
  	int32_t x6654 = 1;
  	int64_t x6655 = INT64_MIN;
  
      t107 = ((x6653<<x6654)+(x6655/x6656));
  
      if (t107 != -140735340904450LL) { NG(); } else { ; }
  	
  }
  
  void f108(void) {
      	static uint8_t x6658 = 0U;
  	static volatile int8_t x6659 = INT8_MIN;
  	volatile uint64_t t108 = 2011999728875663LLU;
  
      t108 = ((x6657<<x6658)+(x6659/x6660));
  
      if (t108 != 4294967295LLU) { NG(); } else { ; }
  	
  }
  
  void f109(void) {
      	static int8_t x6702 = 13;
  	uint8_t x6703 = 123U;
  	int16_t x6704 = -1;
  	volatile int32_t t109 = 1894;
  
      t109 = ((x6701<<x6702)+(x6703/x6704));
  
      if (t109 != -123) { NG(); } else { ; }
  	
  }
  
  void f110(void) {
      	uint64_t x6844 = 1LLU;
  
      t110 = ((x6841<<x6842)+(x6843/x6844));
  
      if (t110 != 1050013LLU) { NG(); } else { ; }
  	
  }
  
  void f111(void) {
      	volatile uint16_t x6909 = 3943U;
  	int8_t x6910 = 4;
  	uint32_t x6911 = 71U;
  	uint32_t x6912 = 203670U;
  
      t111 = ((x6909<<x6910)+(x6911/x6912));
  
      if (t111 != 63088U) { NG(); } else { ; }
  	
  }
  
  void f112(void) {
      	uint16_t x6941 = 26336U;
  	volatile uint16_t x6943 = 744U;
  	static uint32_t x6944 = 2532404U;
  	static uint32_t t112 = 51835987U;
  
      t112 = ((x6941<<x6942)+(x6943/x6944));
  
      if (t112 != 431489024U) { NG(); } else { ; }
  	
  }
  
  void f113(void) {
      	static int8_t x7054 = 5;
  	int64_t x7055 = INT64_MAX;
  	static volatile int16_t x7056 = -1;
  	volatile uint64_t t113 = 1095080960421444267LLU;
  
      t113 = ((x7053<<x7054)+(x7055/x7056));
  
      if (t113 != 16749260263646065409LLU) { NG(); } else { ; }
  	
  }
  
  void f114(void) {
      	int32_t x7069 = 261659;
  	int32_t x7070 = 0;
  	volatile int32_t x7071 = INT32_MIN;
  	uint16_t x7072 = UINT16_MAX;
  	static int32_t t114 = -201711;
  
      t114 = ((x7069<<x7070)+(x7071/x7072));
  
      if (t114 != 228891) { NG(); } else { ; }
  	
  }
  
  void f115(void) {
      	static uint8_t x7097 = 1U;
  	int8_t x7098 = 1;
  	int8_t x7099 = INT8_MIN;
  	int16_t x7100 = INT16_MIN;
  	volatile int32_t t115 = 371705;
  
      t115 = ((x7097<<x7098)+(x7099/x7100));
  
      if (t115 != 2) { NG(); } else { ; }
  	
  }
  
  void f116(void) {
      	int8_t x7181 = 5;
  	int8_t x7182 = 13;
  	uint16_t x7183 = 12U;
  
      t116 = ((x7181<<x7182)+(x7183/x7184));
  
      if (t116 != 40960) { NG(); } else { ; }
  	
  }
  
  void f117(void) {
      	uint32_t x7449 = 12606091U;
  	int8_t x7450 = 0;
  	int16_t x7451 = INT16_MAX;
  	int64_t t117 = -3171LL;
  
      t117 = ((x7449<<x7450)+(x7451/x7452));
  
      if (t117 != 12573324LL) { NG(); } else { ; }
  	
  }
  
  void f118(void) {
      	int8_t x7513 = 2;
  	static uint8_t x7514 = 0U;
  	uint32_t x7515 = 415U;
  	uint8_t x7516 = UINT8_MAX;
  	volatile uint32_t t118 = 1U;
  
      t118 = ((x7513<<x7514)+(x7515/x7516));
  
      if (t118 != 3U) { NG(); } else { ; }
  	
  }
  
  void f119(void) {
      	uint32_t x7533 = 170470U;
  	static uint8_t x7534 = 0U;
  	int16_t x7535 = INT16_MIN;
  	static int16_t x7536 = -1;
  	volatile uint32_t t119 = 248634U;
  
      t119 = ((x7533<<x7534)+(x7535/x7536));
  
      if (t119 != 203238U) { NG(); } else { ; }
  	
  }
  
  void f120(void) {
      	int64_t x7557 = 26LL;
  	static uint8_t x7558 = 29U;
  	volatile uint64_t x7560 = 173370795292844LLU;
  	volatile uint64_t t120 = 7241161890LLU;
  
      t120 = ((x7557<<x7558)+(x7559/x7560));
  
      if (t120 != 13958643712LLU) { NG(); } else { ; }
  	
  }
  
  void f121(void) {
      	volatile uint8_t x7638 = 4U;
  	int8_t x7639 = INT8_MIN;
  
      t121 = ((x7637<<x7638)+(x7639/x7640));
  
      if (t121 != 602) { NG(); } else { ; }
  	
  }
  
  void f122(void) {
      	volatile int16_t x7654 = 1;
  	static int8_t x7655 = INT8_MIN;
  	uint32_t x7656 = UINT32_MAX;
  	volatile uint32_t t122 = 7U;
  
      t122 = ((x7653<<x7654)+(x7655/x7656));
  
      if (t122 != 2U) { NG(); } else { ; }
  	
  }
  
  void f123(void) {
      	int64_t x7665 = 3216LL;
  	static int8_t x7666 = 13;
  	volatile int16_t x7667 = INT16_MAX;
  	volatile int64_t t123 = 400016LL;
  
      t123 = ((x7665<<x7666)+(x7667/x7668));
  
      if (t123 != 26345472LL) { NG(); } else { ; }
  	
  }
  
  void f124(void) {
      	volatile uint64_t x7741 = 6LLU;
  	static uint16_t x7742 = 17U;
  
      t124 = ((x7741<<x7742)+(x7743/x7744));
  
      if (t124 != 786432LLU) { NG(); } else { ; }
  	
  }
  
  void f125(void) {
      	uint16_t x7890 = 3U;
  	uint32_t x7892 = 451363U;
  	volatile int64_t t125 = 3999LL;
  
      t125 = ((x7889<<x7890)+(x7891/x7892));
  
      if (t125 != 20213299737528LL) { NG(); } else { ; }
  	
  }
  
  void f126(void) {
      	int8_t x7893 = 1;
  	static uint16_t x7894 = 14U;
  	int64_t x7895 = INT64_MAX;
  	static uint16_t x7896 = 4U;
  	volatile int64_t t126 = 7202LL;
  
      t126 = ((x7893<<x7894)+(x7895/x7896));
  
      if (t126 != 2305843009213710335LL) { NG(); } else { ; }
  	
  }
  
  void f127(void) {
      	uint16_t x7945 = 404U;
  	int64_t x7946 = 1LL;
  	int64_t x7948 = 1018592670294LL;
  	volatile int64_t t127 = -34446LL;
  
      t127 = ((x7945<<x7946)+(x7947/x7948));
  
      if (t127 != 808LL) { NG(); } else { ; }
  	
  }
  
  void f128(void) {
      	volatile uint32_t x7973 = UINT32_MAX;
  	uint8_t x7974 = 1U;
  	static int64_t x7975 = INT64_MIN;
  	uint64_t x7976 = 1693927118LLU;
  	volatile uint64_t t128 = 177LLU;
  
      t128 = ((x7973<<x7974)+(x7975/x7976));
  
      if (t128 != 9739931211LLU) { NG(); } else { ; }
  	
  }
  
  void f129(void) {
      	volatile int8_t x8034 = 0;
  	int16_t x8035 = INT16_MIN;
  	volatile int64_t t129 = 24575469LL;
  
      t129 = ((x8033<<x8034)+(x8035/x8036));
  
      if (t129 != 32770LL) { NG(); } else { ; }
  	
  }
  
  void f130(void) {
      	uint8_t x8101 = UINT8_MAX;
  	uint16_t x8102 = 4U;
  	int32_t x8103 = INT32_MIN;
  	static int8_t x8104 = INT8_MIN;
  	volatile int32_t t130 = -1;
  
      t130 = ((x8101<<x8102)+(x8103/x8104));
  
      if (t130 != 16781296) { NG(); } else { ; }
  	
  }
  
  void f131(void) {
      	int8_t x8145 = 0;
  	int64_t x8147 = INT64_MIN;
  	int8_t x8148 = INT8_MIN;
  
      t131 = ((x8145<<x8146)+(x8147/x8148));
  
      if (t131 != 72057594037927936LL) { NG(); } else { ; }
  	
  }
  
  void f132(void) {
      	static uint16_t x8209 = 8U;
  	uint32_t x8210 = 4U;
  	static int32_t x8211 = -1;
  	int16_t x8212 = -19;
  	volatile int32_t t132 = -4;
  
      t132 = ((x8209<<x8210)+(x8211/x8212));
  
      if (t132 != 128) { NG(); } else { ; }
  	
  }
  
  void f133(void) {
      	uint16_t x8217 = 3112U;
  	uint8_t x8218 = 0U;
  	int32_t t133 = 1;
  
      t133 = ((x8217<<x8218)+(x8219/x8220));
  
      if (t133 != 3368) { NG(); } else { ; }
  	
  }
  
  void f134(void) {
      	uint8_t x8357 = 37U;
  	int64_t x8359 = 5268609886LL;
  	static int8_t x8360 = -1;
  	volatile int64_t t134 = -30689456180902LL;
  
      t134 = ((x8357<<x8358)+(x8359/x8360));
  
      if (t134 != -5268590942LL) { NG(); } else { ; }
  	
  }
  
  void f135(void) {
      	static uint16_t x8426 = 43U;
  	int64_t x8427 = INT64_MAX;
  	static int32_t x8428 = INT32_MIN;
  	static volatile uint64_t t135 = 302089LLU;
  
      t135 = ((x8425<<x8426)+(x8427/x8428));
  
      if (t135 != 4941812181348909057LLU) { NG(); } else { ; }
  	
  }
  
  void f136(void) {
      	uint8_t x8434 = 0U;
  	int8_t x8435 = INT8_MIN;
  	uint32_t x8436 = 3U;
  
      t136 = ((x8433<<x8434)+(x8435/x8436));
  
      if (t136 != 1431655737LLU) { NG(); } else { ; }
  	
  }
  
  void f137(void) {
      	volatile uint8_t x8453 = 46U;
  	uint16_t x8455 = 30673U;
  	volatile int32_t t137 = 100;
  
      t137 = ((x8453<<x8454)+(x8455/x8456));
  
      if (t137 != 184) { NG(); } else { ; }
  	
  }
  
  void f138(void) {
      	uint64_t x8545 = UINT64_MAX;
  	uint8_t x8546 = 21U;
  	volatile uint16_t x8548 = 1U;
  	static volatile uint64_t t138 = 387200LLU;
  
      t138 = ((x8545<<x8546)+(x8547/x8548));
  
      if (t138 != 18446744073707938748LLU) { NG(); } else { ; }
  	
  }
  
  void f139(void) {
      	volatile uint8_t x8569 = UINT8_MAX;
  	static volatile uint8_t x8570 = 23U;
  	int32_t x8571 = -28269429;
  	int64_t x8572 = INT64_MAX;
  	volatile int64_t t139 = 1117201LL;
  
      t139 = ((x8569<<x8570)+(x8571/x8572));
  
      if (t139 != 2139095040LL) { NG(); } else { ; }
  	
  }
  
  void f140(void) {
      	volatile uint32_t x8765 = 44829796U;
  	uint8_t x8768 = 11U;
  	uint32_t t140 = 15U;
  
      t140 = ((x8765<<x8766)+(x8767/x8768));
  
      if (t140 != 1434553472U) { NG(); } else { ; }
  	
  }
  
  void f141(void) {
      	volatile int32_t x8802 = 3;
  	volatile uint16_t x8803 = 1699U;
  	volatile int64_t x8804 = -7010602LL;
  	int64_t t141 = -1835531131773LL;
  
      t141 = ((x8801<<x8802)+(x8803/x8804));
  
      if (t141 != 86888LL) { NG(); } else { ; }
  	
  }
  
  void f142(void) {
      	static uint8_t x8834 = 48U;
  	int8_t x8835 = -11;
  	int32_t x8836 = -1;
  	uint64_t t142 = 3520330LLU;
  
      t142 = ((x8833<<x8834)+(x8835/x8836));
  
      if (t142 != 4705698660648747019LLU) { NG(); } else { ; }
  	
  }
  
  void f143(void) {
      	volatile int16_t x8849 = 9;
  	int8_t x8850 = 1;
  	uint8_t x8851 = 0U;
  	static int32_t t143 = 2252;
  
      t143 = ((x8849<<x8850)+(x8851/x8852));
  
      if (t143 != 18) { NG(); } else { ; }
  	
  }
  
  void f144(void) {
      	static uint16_t x8925 = UINT16_MAX;
  	uint8_t x8926 = 0U;
  	uint32_t x8927 = UINT32_MAX;
  	static volatile uint32_t t144 = 44968687U;
  
      t144 = ((x8925<<x8926)+(x8927/x8928));
  
      if (t144 != 65548U) { NG(); } else { ; }
  	
  }
  
  void f145(void) {
      	uint8_t x8973 = UINT8_MAX;
  	static uint16_t x8975 = 4433U;
  	volatile int32_t x8976 = -1;
  	int32_t t145 = -1808658;
  
      t145 = ((x8973<<x8974)+(x8975/x8976));
  
      if (t145 != -3413) { NG(); } else { ; }
  	
  }
  
  void f146(void) {
      	uint16_t x9056 = 53U;
  	volatile uint32_t t146 = 22U;
  
      t146 = ((x9053<<x9054)+(x9055/x9056));
  
      if (t146 != 0U) { NG(); } else { ; }
  	
  }
  
  void f147(void) {
      	int16_t x9234 = 0;
  	uint8_t x9235 = 3U;
  	int32_t x9236 = INT32_MAX;
  	volatile int32_t t147 = 1;
  
      t147 = ((x9233<<x9234)+(x9235/x9236));
  
      if (t147 != 15380) { NG(); } else { ; }
  	
  }
  
  void f148(void) {
      	int8_t x9322 = 1;
  	int16_t x9323 = -1;
  	static uint32_t x9324 = UINT32_MAX;
  	volatile uint32_t t148 = 15028U;
  
      t148 = ((x9321<<x9322)+(x9323/x9324));
  
      if (t148 != 973U) { NG(); } else { ; }
  	
  }
  
  void f149(void) {
      	uint16_t x9393 = UINT16_MAX;
  	uint8_t x9394 = 0U;
  	int16_t x9395 = -1;
  	volatile int32_t t149 = -1;
  
      t149 = ((x9393<<x9394)+(x9395/x9396));
  
      if (t149 != 65536) { NG(); } else { ; }
  	
  }
  
  void f150(void) {
      	uint64_t x9425 = 17381LLU;
  	static int8_t x9426 = 1;
  	static uint32_t x9427 = UINT32_MAX;
  	int32_t x9428 = INT32_MAX;
  	static volatile uint64_t t150 = 239770628984000897LLU;
  
      t150 = ((x9425<<x9426)+(x9427/x9428));
  
      if (t150 != 34764LLU) { NG(); } else { ; }
  	
  }
  
  void f151(void) {
      	static volatile uint16_t x9437 = 2136U;
  	int8_t x9438 = 6;
  	volatile int16_t x9439 = INT16_MIN;
  	int32_t t151 = -3267532;
  
      t151 = ((x9437<<x9438)+(x9439/x9440));
  
      if (t151 != 169472) { NG(); } else { ; }
  	
  }
  
  void f152(void) {
      	uint64_t x9469 = 1090095019524LLU;
  	int8_t x9470 = 2;
  	int16_t x9471 = INT16_MIN;
  	uint64_t x9472 = UINT64_MAX;
  	static uint64_t t152 = 248400771561LLU;
  
      t152 = ((x9469<<x9470)+(x9471/x9472));
  
      if (t152 != 4360380078096LLU) { NG(); } else { ; }
  	
  }
  
  void f153(void) {
      	uint16_t x9537 = UINT16_MAX;
  	uint32_t x9538 = 13U;
  	int32_t x9540 = INT32_MIN;
  	volatile int32_t t153 = -1;
  
      t153 = ((x9537<<x9538)+(x9539/x9540));
  
      if (t153 != 536862720) { NG(); } else { ; }
  	
  }
  
  void f154(void) {
      	int8_t x9586 = 0;
  	volatile uint32_t x9587 = 3656499U;
  	int64_t x9588 = -1LL;
  	int64_t t154 = 22770693LL;
  
      t154 = ((x9585<<x9586)+(x9587/x9588));
  
      if (t154 != -3623732LL) { NG(); } else { ; }
  	
  }
  
  void f155(void) {
      	uint8_t x9685 = UINT8_MAX;
  	int8_t x9686 = 1;
  	static volatile int64_t x9687 = 2243LL;
  	volatile int64_t t155 = -446804LL;
  
      t155 = ((x9685<<x9686)+(x9687/x9688));
  
      if (t155 != 682LL) { NG(); } else { ; }
  	
  }
  
  void f156(void) {
      	static volatile uint8_t x9745 = UINT8_MAX;
  	int16_t x9746 = 1;
  	uint16_t x9747 = 62U;
  	volatile uint16_t x9748 = 36U;
  	int32_t t156 = 482101;
  
      t156 = ((x9745<<x9746)+(x9747/x9748));
  
      if (t156 != 511) { NG(); } else { ; }
  	
  }
  
  void f157(void) {
      	uint8_t x9913 = 79U;
  	uint64_t x9914 = 6LLU;
  	int16_t x9915 = INT16_MIN;
  	static uint8_t x9916 = UINT8_MAX;
  
      t157 = ((x9913<<x9914)+(x9915/x9916));
  
      if (t157 != 4928) { NG(); } else { ; }
  	
  }
  
  void f158(void) {
      	int32_t x9917 = 1;
  	int8_t x9918 = 2;
  	uint16_t x9919 = 2U;
  	volatile int32_t x9920 = -1;
  	volatile int32_t t158 = 161;
  
      t158 = ((x9917<<x9918)+(x9919/x9920));
  
      if (t158 != 2) { NG(); } else { ; }
  	
  }
  
  void f159(void) {
      	static int32_t x10024 = -89;
  	volatile int32_t t159 = 51035042;
  
      t159 = ((x10021<<x10022)+(x10023/x10024));
  
      if (t159 != 32766) { NG(); } else { ; }
  	
  }
  
  void f160(void) {
      	int16_t x10061 = INT16_MAX;
  	volatile uint16_t x10062 = 1U;
  	int64_t x10063 = INT64_MIN;
  	int64_t x10064 = INT64_MIN;
  	int64_t t160 = -1385373799420563LL;
  
      t160 = ((x10061<<x10062)+(x10063/x10064));
  
      if (t160 != 65535LL) { NG(); } else { ; }
  	
  }
  
  void f161(void) {
      	static uint64_t x10073 = 485122306315926381LLU;
  	uint16_t x10074 = 54U;
  	static volatile uint8_t x10075 = 1U;
  	int64_t x10076 = INT64_MAX;
  
      t161 = ((x10073<<x10074)+(x10075/x10076));
  
      if (t161 != 15798627492815699968LLU) { NG(); } else { ; }
  	
  }
  
  void f162(void) {
      	uint16_t x10105 = UINT16_MAX;
  	static int64_t x10106 = 1LL;
  	volatile int16_t x10107 = INT16_MAX;
  	volatile uint8_t x10108 = 6U;
  	static int32_t t162 = -56;
  
      t162 = ((x10105<<x10106)+(x10107/x10108));
  
      if (t162 != 136531) { NG(); } else { ; }
  	
  }
  
  void f163(void) {
      	uint16_t x10109 = 16U;
  	int8_t x10110 = 8;
  	int8_t x10112 = 2;
  
      t163 = ((x10109<<x10110)+(x10111/x10112));
  
      if (t163 != -4611686018427383808LL) { NG(); } else { ; }
  	
  }
  
  void f164(void) {
      	static int32_t x10338 = 1;
  	int32_t x10339 = -28203119;
  
      t164 = ((x10337<<x10338)+(x10339/x10340));
  
      if (t164 != 4292952786U) { NG(); } else { ; }
  	
  }
  
  void f165(void) {
      	uint32_t x10357 = 206U;
  	int16_t x10359 = INT16_MIN;
  	static int8_t x10360 = INT8_MIN;
  	uint32_t t165 = 3363755U;
  
      t165 = ((x10357<<x10358)+(x10359/x10360));
  
      if (t165 != 13500672U) { NG(); } else { ; }
  	
  }
  
  void f166(void) {
      	int16_t x10394 = 4;
  	volatile int32_t x10395 = INT32_MIN;
  	volatile uint32_t t166 = 645283U;
  
      t166 = ((x10393<<x10394)+(x10395/x10396));
  
      if (t166 != 2147483632U) { NG(); } else { ; }
  	
  }
  
  void f167(void) {
      	volatile uint64_t x10589 = UINT64_MAX;
  	uint8_t x10590 = 1U;
  	volatile int16_t x10591 = -7550;
  	uint64_t x10592 = UINT64_MAX;
  
      t167 = ((x10589<<x10590)+(x10591/x10592));
  
      if (t167 != 18446744073709551614LLU) { NG(); } else { ; }
  	
  }
  
  void f168(void) {
      	uint32_t x10665 = UINT32_MAX;
  	static uint16_t x10666 = 1U;
  	int8_t x10668 = INT8_MAX;
  	int64_t t168 = 21324598768963679LL;
  
      t168 = ((x10665<<x10666)+(x10667/x10668));
  
      if (t168 != 4293167320LL) { NG(); } else { ; }
  	
  }
  
  void f169(void) {
      	int32_t x10769 = 10846;
  	int32_t x10771 = 227619571;
  	volatile int64_t x10772 = 46LL;
  	static volatile int64_t t169 = -951372LL;
  
      t169 = ((x10769<<x10770)+(x10771/x10772));
  
      if (t169 != 5121787LL) { NG(); } else { ; }
  	
  }
  
  void f170(void) {
      	uint16_t x10853 = UINT16_MAX;
  	uint8_t x10854 = 4U;
  	volatile uint32_t x10855 = 12U;
  	int32_t x10856 = INT32_MIN;
  
      t170 = ((x10853<<x10854)+(x10855/x10856));
  
      if (t170 != 1048560U) { NG(); } else { ; }
  	
  }
  
  void f171(void) {
      	int8_t x10969 = 55;
  	volatile uint8_t x10970 = 24U;
  	uint64_t x10971 = 1825817568391LLU;
  	int16_t x10972 = INT16_MIN;
  
      t171 = ((x10969<<x10970)+(x10971/x10972));
  
      if (t171 != 922746880LLU) { NG(); } else { ; }
  	
  }
  
  void f172(void) {
      	static uint32_t x11041 = 0U;
  	uint16_t x11042 = 3U;
  	int16_t x11044 = INT16_MIN;
  	static uint32_t t172 = 3026U;
  
      t172 = ((x11041<<x11042)+(x11043/x11044));
  
      if (t172 != 1U) { NG(); } else { ; }
  	
  }
  
  void f173(void) {
      	int16_t x11106 = 1;
  	uint16_t x11107 = 612U;
  	int32_t x11108 = INT32_MIN;
  	int32_t t173 = 119;
  
      t173 = ((x11105<<x11106)+(x11107/x11108));
  
      if (t173 != 65534) { NG(); } else { ; }
  	
  }
  
  void f174(void) {
      	static int64_t x11214 = 2LL;
  	int16_t x11215 = INT16_MIN;
  	uint8_t x11216 = UINT8_MAX;
  
      t174 = ((x11213<<x11214)+(x11215/x11216));
  
      if (t174 != 892) { NG(); } else { ; }
  	
  }
  
  void f175(void) {
      	int32_t x11321 = INT32_MAX;
  	volatile int16_t x11322 = 0;
  	int64_t x11323 = 143482019567905532LL;
  	uint64_t t175 = 49LLU;
  
      t175 = ((x11321<<x11322)+(x11323/x11324));
  
      if (t175 != 2148083897LLU) { NG(); } else { ; }
  	
  }
  
  void f176(void) {
      	volatile int64_t x11423 = 1213319107LL;
  	uint8_t x11424 = 3U;
  	int64_t t176 = -86085LL;
  
      t176 = ((x11421<<x11422)+(x11423/x11424));
  
      if (t176 != 404440186LL) { NG(); } else { ; }
  	
  }
  
  void f177(void) {
      	int32_t x11541 = INT32_MAX;
  	volatile uint16_t x11542 = 0U;
  	uint32_t x11543 = UINT32_MAX;
  	int16_t x11544 = INT16_MAX;
  	uint32_t t177 = 3361U;
  
      t177 = ((x11541<<x11542)+(x11543/x11544));
  
      if (t177 != 2147614723U) { NG(); } else { ; }
  	
  }
  
  void f178(void) {
      	int16_t x11645 = 2;
  	uint8_t x11646 = 3U;
  	int8_t x11647 = -1;
  	uint64_t x11648 = 21LLU;
  	uint64_t t178 = 4417071LLU;
  
      t178 = ((x11645<<x11646)+(x11647/x11648));
  
      if (t178 != 878416384462359616LLU) { NG(); } else { ; }
  	
  }
  
  void f179(void) {
      	uint16_t x11709 = 4U;
  	int16_t x11710 = 8;
  	int64_t x11711 = -1LL;
  	uint64_t x11712 = UINT64_MAX;
  	volatile uint64_t t179 = 231489LLU;
  
      t179 = ((x11709<<x11710)+(x11711/x11712));
  
      if (t179 != 1025LLU) { NG(); } else { ; }
  	
  }
  
  void f180(void) {
      	volatile uint8_t x11842 = 1U;
  	static int8_t x11844 = INT8_MIN;
  	volatile uint64_t t180 = 28471715674843926LLU;
  
      t180 = ((x11841<<x11842)+(x11843/x11844));
  
      if (t180 != 22LLU) { NG(); } else { ; }
  	
  }
  
  void f181(void) {
      	static uint32_t x11862 = 5U;
  	uint64_t x11863 = 3305LLU;
  	uint64_t x11864 = UINT64_MAX;
  
      t181 = ((x11861<<x11862)+(x11863/x11864));
  
      if (t181 != 198016LLU) { NG(); } else { ; }
  	
  }
  
  void f182(void) {
      	uint64_t x11873 = 3181880914597LLU;
  	uint8_t x11874 = 2U;
  	int8_t x11875 = INT8_MAX;
  	volatile uint64_t t182 = 59097131LLU;
  
      t182 = ((x11873<<x11874)+(x11875/x11876));
  
      if (t182 != 12727523658261LLU) { NG(); } else { ; }
  	
  }
  
  void f183(void) {
      	uint16_t x11969 = 1U;
  	uint16_t x11970 = 6U;
  	int64_t x11971 = INT64_MIN;
  	volatile int16_t x11972 = INT16_MIN;
  	volatile int64_t t183 = 202093591253002379LL;
  
      t183 = ((x11969<<x11970)+(x11971/x11972));
  
      if (t183 != 281474976710720LL) { NG(); } else { ; }
  	
  }
  
  void f184(void) {
      	uint16_t x12002 = 1U;
  	static int32_t x12003 = INT32_MIN;
  	uint8_t x12004 = UINT8_MAX;
  	volatile int32_t t184 = 15028;
  
      t184 = ((x12001<<x12002)+(x12003/x12004));
  
      if (t184 != -8290434) { NG(); } else { ; }
  	
  }
  
  void f185(void) {
      	uint32_t x12009 = 11704353U;
  	uint8_t x12010 = 12U;
  	volatile uint32_t x12011 = 19756U;
  	static uint8_t x12012 = 5U;
  
      t185 = ((x12009<<x12010)+(x12011/x12012));
  
      if (t185 != 696393583U) { NG(); } else { ; }
  	
  }
  
  void f186(void) {
      	volatile int16_t x12026 = 0;
  	static int16_t x12027 = INT16_MIN;
  	uint8_t x12028 = UINT8_MAX;
  
      t186 = ((x12025<<x12026)+(x12027/x12028));
  
      if (t186 != 32639) { NG(); } else { ; }
  	
  }
  
  void f187(void) {
      	int16_t x12090 = 0;
  	int16_t x12091 = -1;
  	static int64_t x12092 = INT64_MIN;
  	int64_t t187 = -174289340LL;
  
      t187 = ((x12089<<x12090)+(x12091/x12092));
  
      if (t187 != 2147483647LL) { NG(); } else { ; }
  	
  }
  
  void f188(void) {
      	volatile int8_t x12107 = 30;
  	int16_t x12108 = INT16_MAX;
  
      t188 = ((x12105<<x12106)+(x12107/x12108));
  
      if (t188 != 16776960) { NG(); } else { ; }
  	
  }
  
  void f189(void) {
      	volatile uint8_t x12126 = 1U;
  	static int32_t x12127 = INT32_MIN;
  	int8_t x12128 = INT8_MIN;
  	volatile int32_t t189 = 5;
  
      t189 = ((x12125<<x12126)+(x12127/x12128));
  
      if (t189 != 16793100) { NG(); } else { ; }
  	
  }
  
  void f190(void) {
      	int8_t x12173 = 5;
  	int64_t x12175 = INT64_MIN;
  	int64_t x12176 = 1043453577921794424LL;
  
      t190 = ((x12173<<x12174)+(x12175/x12176));
  
      if (t190 != 32LL) { NG(); } else { ; }
  	
  }
  
  void f191(void) {
      	int8_t x12241 = 1;
  	int16_t x12242 = 1;
  	int64_t x12243 = INT64_MIN;
  	int16_t x12244 = INT16_MAX;
  	int64_t t191 = 14LL;
  
      t191 = ((x12241<<x12242)+(x12243/x12244));
  
      if (t191 != -281483566907398LL) { NG(); } else { ; }
  	
  }
  
  void f192(void) {
      	int32_t x12269 = 78;
  	static uint16_t x12271 = 10135U;
  	volatile int32_t t192 = 123676330;
  
      t192 = ((x12269<<x12270)+(x12271/x12272));
  
      if (t192 != 545) { NG(); } else { ; }
  	
  }
  
  void f193(void) {
      	int16_t x12293 = INT16_MAX;
  	uint8_t x12294 = 14U;
  	int8_t x12296 = -1;
  	int64_t t193 = -320237066094LL;
  
      t193 = ((x12293<<x12294)+(x12295/x12296));
  
      if (t193 != 536854535LL) { NG(); } else { ; }
  	
  }
  
  void f194(void) {
      	static int64_t x12297 = 318826LL;
  	volatile int8_t x12298 = 1;
  	int16_t x12299 = INT16_MIN;
  	volatile int32_t x12300 = INT32_MIN;
  	volatile int64_t t194 = -18770158LL;
  
      t194 = ((x12297<<x12298)+(x12299/x12300));
  
      if (t194 != 637652LL) { NG(); } else { ; }
  	
  }
  
  void f195(void) {
      	int8_t x12361 = INT8_MAX;
  	static uint16_t x12362 = 9U;
  	uint8_t x12364 = UINT8_MAX;
  	static int32_t t195 = 3707;
  
      t195 = ((x12361<<x12362)+(x12363/x12364));
  
      if (t195 != 8486528) { NG(); } else { ; }
  	
  }
  
  void f196(void) {
      	uint16_t x12401 = 11U;
  	int16_t x12403 = -1;
  	uint8_t x12404 = 1U;
  	volatile int32_t t196 = 7218965;
  
      t196 = ((x12401<<x12402)+(x12403/x12404));
  
      if (t196 != 87) { NG(); } else { ; }
  	
  }
  
  void f197(void) {
      	int32_t x12417 = 58;
  	uint16_t x12418 = 3U;
  	static int32_t x12419 = INT32_MAX;
  	static int8_t x12420 = INT8_MIN;
  	int32_t t197 = 894933;
  
      t197 = ((x12417<<x12418)+(x12419/x12420));
  
      if (t197 != -16776751) { NG(); } else { ; }
  	
  }
  
  void f198(void) {
      	uint16_t x12470 = 1U;
  	volatile uint64_t x12471 = UINT64_MAX;
  	volatile uint32_t x12472 = 485784993U;
  	volatile uint64_t t198 = 35898553826789LLU;
  
      t198 = ((x12469<<x12470)+(x12471/x12472));
  
      if (t198 != 37973062858LLU) { NG(); } else { ; }
  	
  }
  
  void f199(void) {
      	volatile uint32_t x12493 = 16739515U;
  	static uint64_t x12494 = 10LLU;
  	int32_t x12495 = 2672;
  	static int8_t x12496 = -1;
  	uint32_t t199 = 8021U;
  
      t199 = ((x12493<<x12494)+(x12495/x12496));
  
      if (t199 != 4256358800U) { 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;
  }
  
  