| /* PR tree-optimization/86990 */ |
| /* Testcase by Zhendong Su <su@cs.ucdavis.edu> */ |
| |
| const char *ss; |
| |
| int __attribute__((noipa)) dummy (const char *s, ...) |
| { |
| ss = s; |
| } |
| |
| int i[6]; |
| static int j, v, e, f, h = 5, k, l, n, o, p, q, r, s, u, w, x, y, z, aa, ab, ac, |
| ad, ae, af, ag = 8, ah, ai, aj, ak, al; |
| char c; |
| struct a { |
| unsigned b; |
| int c : 9; |
| int d; |
| } static g = {9, 5}; |
| static short m[1], t = 95, am; |
| int an, ao, ap; |
| void aq(int ar) { |
| j = j & 5 ^ i[j ^ v & 5]; |
| j = j & 5 ^ i[(j ^ v) & 5]; |
| j = j & 4095 ^ (j ^ v) & 5; |
| } |
| void as(int ar) { |
| if (n) |
| s = 0; |
| } |
| static unsigned at() { |
| int au[] = {2080555007, 0}; |
| for (; al; al--) { |
| if (r) |
| --x; |
| if (g.d) |
| l++; |
| dummy("", j); |
| if (u) |
| ae = n = au[al]; |
| } |
| r = 0; |
| return 0; |
| } |
| int aw(int ar) { |
| int ax[] = {9, 5, 5, 9, 5}, ay = 3; |
| struct a az = {1, 3}; |
| av: |
| an = (as((at(), ax)[2]), ax[4]); |
| { |
| int ba[] = {5, 5, 9, 8, 1, 0, 5, 5, 9, 8, 1, 0, |
| 5, 5, 9, 8, 1, 0, 5, 5, 9, 8, 1}; |
| int a[] = {8, 2, 8, 2, 8, 2, 8}; |
| int b[] = {1027239, 8, 1, 7, 9, 2, 9, 4, 4, 2, 8, 1, 0, 4, 4, 2, |
| 4, 4, 2, 9, 2, 9, 8, 1, 7, 9, 2, 9, 4, 4, 2}; |
| if (z) { |
| struct a bc; |
| bb: |
| for (; e; e++) |
| for (; q;) |
| return ax[e]; |
| if (bc.c < g.d <= a[7]) |
| aa--; |
| } |
| { |
| struct a bd = {5}; |
| int d[20] = {1, 9, 7, 7, 8, 4, 4, 4, 4, 8, 1, 9, 7, 7, 8, 4, 4, 4, 4}; |
| c = h | r % g.c ^ x; |
| dummy("", g); |
| am -= t | x; |
| if (h) |
| while (1) { |
| if (a[o]) { |
| struct a be; |
| if (ar) { |
| struct a bf = {908, 5, 3}; |
| int bg[3], bh = k, bj = ag | ae, bk = aj + 3, bl = u << e; |
| if (f) |
| if (ac) |
| ak = w; |
| ag = -(ag & t); |
| af = ag ^ af; |
| if (8 < af) |
| break; |
| if (bj) |
| goto bi; |
| if (s) |
| dummy("", 6); |
| be.d = k; |
| w = f - bh; |
| dummy("", be); |
| if (w) |
| goto bb; |
| ao = r - aa && g.b; |
| if (y) |
| k++; |
| goto av; |
| bi: |
| if (aa) |
| continue; |
| if (f) |
| if (k) |
| dummy("", g); |
| aj = ac + k ^ g.c; |
| g.c = bk; |
| ah = 0; |
| for (; ah < 3; ah++) |
| if (s) |
| bg[ah] = 8; |
| if (!ay) |
| dummy("", ai); |
| u = bl; |
| g = bf; |
| } else |
| for (;; o += a[ap]) |
| ; |
| int bm[] = {0}; |
| for (; p; p++) |
| c = ad; |
| ad = l; |
| if (bd.c) { |
| dummy(" "); |
| goto bi; |
| } |
| } |
| int bn[] = {5, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 5, |
| 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, |
| 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2}; |
| struct a a[] = {3440025416, 2, 8, 4, 2, 8, 4, 4, 2, 8, 4}; |
| struct a b = {3075920}; |
| if (f) { |
| aq(m[am + e]); |
| dummy("", j); |
| dummy("", e); |
| ab--; |
| } |
| if (ax[4]) { |
| if (l) |
| goto av; |
| ++f; |
| } else |
| ay = az.c && a; |
| for (; ac; ac++) |
| m[f] = 0; |
| } |
| h = 9; |
| for (; y; y = 1) |
| if (f) |
| goto av; |
| } |
| } |
| return 0; |
| } |
| |
| int main (void) |
| { |
| aw(1); |
| if (g.c!= 5) |
| __builtin_abort (); |
| return 0; |
| } |
