Debian Codegraph @

gcc/testsuite/g++.target/i386/pr114810.C

raw
1 // PR target/114810
2 // { dg-do compile { target { { { *-*-linux* } && ia32 } && c++17 } } }
3 // { dg-options "-mstackrealign -O2 -mbmi -fno-exceptions -fno-plt -march=x86-64 -w" }
4 // { dg-additional-options "-fpie" { target pie } }
5
6 enum E1 { a, dp, b, jm, c, dq, d, mj, e, dr, f, jn, h, dt, j, nt, l, du, m, jo, n, dv, o, mk, p, dw, q, jp, s, dx, t, ol, u, dy, v, jq, w };
7 enum dz { x, ml, y };
8 struct ea { short g; } z, jr;
9 long long aa;
10 struct eb { ea ab; ea dp[]; };
11 enum ac { };
12 typedef enum { } nu;
13 struct ad { ac k; };
14 unsigned ec (long);
15 struct ae;
16 int js (ae);
17 unsigned af ();
18 struct ed;
19 template < int ag > struct ee { using ah = ed[ag]; };
20 template < int ag > struct array { typename ee < ag >::ah ai; ed & operator[] (int aj) { return ai[aj]; } };
21 struct { void dp (...); } ak;
22 void ef (int);
23 template < typename al > struct jt { al & operator[] (short); };
24 struct am { void operator= (bool); };
25 struct an { am operator[] (unsigned); };
26 template < typename, unsigned, unsigned >using eg = an;
27 struct ao;
28 struct ae { ae (ao *); };
29 struct mm { mm (); mm (int); };
30 enum ap { };
31 enum eh { };
32 bool aq, ju, ar, ei, nv, as, ej, at;
33 struct jv
34 {
35 jv (eh au):dp (au) {}
36 jv ();
37 operator eh ();
38 unsigned av ()
39 {
40 aq = dp & 7;
41 return dp * (aq ? : 4);
42 }
43 unsigned ek ()
44 {
45 int aw;
46 bool mn = dp & 7;
47 aw = dp * (mn ? : 4);
48 return aw + 3 >> 2;
49 }
50 eh dp;
51 } ax, el, ay, jw, az, em, ba, om;
52 struct ed
53 {
54 ed ():bb (), dp () {}
55 int bc () { return bb; }
56 jv en () { return (eh) dp; }
57 unsigned ek ()
58 {
59 jv bd;
60 bd = (eh) dp;
61 return bd.ek ();
62 }
63 ap jx ();
64 unsigned bb:24;
65 int dp:8;
66 };
67 struct be { short dp = 0; } bf, eo;
68 struct bg
69 {
70 bg ();
71 bg (ed r)
72 {
73 dp.bh = r;
74 if (r.bc ())
75 mo = true;
76 else
77 bi = true;
78 }
79 static bg ep (int);
80 bg (be);
81 struct { ed bh; } dp;
82 union { char mo:1; char bi:1; short bj = 0; };
83 } jy, bk, eq, bl, mp, bm, er;
84 struct bn
85 {
86 explicit bn (ed bo):bh (bo) {}
87 ed dp ();
88 ed bh;
89 be es;
90 char bj = 0;
91 };
92 struct bp
93 {
94 eg < int, 6, 4 > dp;
95 };
96 jt < bg > bq;
97 jt < bn > definitions;
98 struct ao
99 {
100 bp & br ();
101 };
102 enum jz:short;
103 template < typename > using bs = ae;
104 ao *et ();
105 short bt, nw;
106 struct bu
107 {
108 int dp;
109 };
110 dz bv;
111 unsigned eu;
112 struct bw
113 {
114 ac k;
115 unsigned dp;
116 } *bx;
117 bool ka ();
118 struct by
119 {
120 bool dp;
121 };
122 typedef enum
123 { bz, ev } ca;
124 typedef enum
125 {
126 mq, cb, ew, cc, kb, cd, ex, ce
127 } on;
128 typedef struct cf
129 {
130 on jx;
131 char dp;
132 char cg;
133 } kc;
134 struct ch
135 {
136 kc *dp;
137 };
138 typedef enum
139 {
140 ci, ey, cj, mr, ck, ez, cl, kd, cm, fa, cn, nx, co, fb, cp, ke, cq, fc,
141 cr, ms, cs, fd, ct, kf, cu, fe, cv, os, cw, ff, cx, kg, cy, fg, cz, mt, da
142 } fh;
143 typedef struct { cf db; fh dp; kc dc; ch kh[]; } dd;
144 nu fi ();
145 typedef enum
146 { de, ny } fj;
147 typedef struct { fj jx; } df;
148 typedef struct { by dp; } dg;
149 dg *ki;
150 struct dh
151 {
152 ad *dp;
153 eb *args;
154 bw *di;
155 bu *block;
156 struct
157 {
158 struct
159 {
160 bool fk;
161 } dj;
162 bool dp;
163 bool dk;
164 } mu;
165 ed dl[84];
166 };
167 ed fl (dh *, ea);
168 enum dm
169 { };
170 dm kj ();
171 enum
172 { dn };
173 struct fm
174 {
175 operator ed ();
176 operator bg ();
177 bn dc ();
178 ao *operator-> ();
179 };
180 struct oo
181 {
182 oo (ed);
183 oo (bg);
184 oo (fm);
185 };
186 struct fn
187 {
188 enum dp
189 {
190 kk, fo, mv, fp, kl, fq
191 };
192 jv lm;
193 fn (bw *, bu *);
194 fn fr ();
195 ed bo (jv);
196 bn dc ();
197 bn dc (be);
198 ed km (oo);
199 fm copy (bn, oo);
200 fm fs ();
201 fm nz (bn, oo, oo, oo);
202 void ft (oo);
203 void ft (E1, bn, oo);
204 fm ft (E1, bn, oo, oo);
205 void ft (E1, bn, oo, oo, oo);
206 void ft (E1, bn, bn, oo);
207 void kn (E1, bn, oo);
208 fm kn (dp, bn, oo);
209 fm kn (dp, bn, bn, oo);
210 fm fu (E1, bn, oo, oo);
211 fm fu (E1, bn, bn, oo, oo);
212 fm fu (dp, bn, bn, oo, oo);
213 fm mw (E1, bn, int);
214 fm fv (E1, bn, oo, oo);
215 fm fv (dp, bn, oo, oo);
216 void dp (E1, bn, mm, bool = false, bool = false, bool = false);
217 void dp (E1, bn, oo, oo, mm = false, bool = false, bool = false);
218 fm ds (E1, bn, oo, short, char = 0, bool = false);
219 fm ds (E1, bn, oo, oo, short = 0, char = 0, bool = false);
220 fm ko (E1, bn, oo, oo);
221 fm ko (E1, bn, oo, oo, oo);
222 fm fw (E1, bn, oo, oo);
223 fm dp (E1, bn, oo, oo, oo);
224 fm oy (E1, bn, oo, short, char, char, bool, bool);
225 fm fx (E1, bn, oo, oo, oo);
226 };
227 int kp, fy, mx, fz, kq, ga, oa, gb;
228 int *kr, *gc, *my;
229 long gd;
230 ca ks;
231 namespace
232 {
233 void ge (dh *, char *, unsigned, cf *, char *);
234 ed kt (dh *, kc *);
235 ed gf (dh *, ed, bg = bg (), bg = bg ());
236 void mz (bool);
237 ed gg (dh *, fn, ed, ed);
238 ed ku (dh *, fn, ed, unsigned, bool);
239 ed gh (dh *, ed);
240 void op (dh *, ed, int, ed);
241 ed op (dh *, ed, int, jv);
242 void gi (dh *, ed, unsigned);
243 void kv (dh *, ed, bg, ed);
244 ed gj (dh *, ed, ed = ed ());
245 void na (dh *, int *);
246 void gk (dh *, ed, ed);
247 ed kw (dh *);
248 bool gl (dh *);
249 void ob (dh *, dd *);
250 void gm (dh * ctx, dd * db)
251 {
252 fn bld (ctx->di, ctx->block);
253 ed dst = kt (ctx, &db->dc), dp = kt (ctx, db->kh[0].dp), kx, gn;
254 unsigned count = db->dc.dp;
255 if (db->dc.cg)
256 count *= 2;
257 if (kr && db->dc.cg)
258 {
259 long dp = count == 4 ? 0 : (1ull << (count & 3)) - 1 << mx;
260 if ((aa | dp) == aa && mx + count)
261 {
262 array < 16 > elems;
263 bs < ao > gn
264 {
265 et ()};
266 unsigned g = ec (aa & mx ? : 1 << mx - 1);
267 for (unsigned i; count; ++i)
268 {
269 elems[i] = fl (ctx, ctx->args->dp[g]);
270 bq[i] = elems[i];
271 }
272 definitions[0] = bn (dst);
273 int dp = js (gn), ot = dst.bc ();
274 ef (dp);
275 ak.dp (ot, elems);
276 }
277 }
278 ed go = bld.km (dp);
279 if (kp)
280 {
281 bg dp = bg::ep (kp);
282 bn ky = bld.dc (), gp = bld.dc (eo);
283 go = bld.fr ().fu (e, ky, gp, dp, go);
284 }
285 ed nb = fl (ctx, ctx->args->ab);
286 bool aligned;
287 if (db->dc.cg)
288 aligned = kr && fy % 4;
289 bool gq = count == 1 || kr && kp + fy % 4 + count;
290 if (aligned)
291 gn = gq ? bld.bo (ax) : bld.bo (el);
292 E1 kz;
293 switch (gn.ek ())
294 {
295 case 1:
296 kz = dt;
297 break;
298 case 2:
299 kz = j;
300 break;
301 case 3:
302 gn = bld.bo (ay) = bld.bo (jw);
303 ei = true;
304 }
305 bld.dp (kz, bn (gn), kx, go);
306 if (aligned)
307 {
308 bg dp = kr ? bg::ep (kp + fy % 4) : go;
309 kv (ctx, gn, dp, dst);
310 }
311 if (ei)
312 {
313 gi (ctx, gn, 4);
314 jv dp = dst.ek ()? ax : el;
315 ed gr = op (ctx, gn, 2, dp),
316 oc = op (ctx, gn, 0, dp), gs = op (ctx, gn, 1, dp);
317 bld.ft (jm, bn (dst), oc, gs, gr);
318 }
319 gi (ctx, dst, db->dc.dp);
320 }
321 jz la (ca, unsigned);
322 void gt (dh *, dd *, ed);
323 bool nc (dh *, dd *);
324 void gu (dh *, E1, jz, unsigned, bn, ed);
325 void lb (dh *, jz, bn, ed);
326 bool gv (dh *, ed &, ed, unsigned, long);
327 dh *pb;
328 bu *gw;
329 dd *lc;
330 bool gx;
331 jv nd;
332 void gy ()
333 {
334 fn bld (pb->di, gw);
335 switch (lc->dp)
336 {
337 case ms:
338 ob (pb, lc);
339 case ke:
340 gm (pb, lc);
341 case fb:
342 ob (pb, lc);
343 case fc:
344 ob (pb, lc);
345 case fg:
346 ob (pb, lc);
347 case cp:
348 {
349 if (bv == x || bv == y)
350 {
351 ed dp = kt (pb, &lc->dc), ld = kw (pb);
352 bld.copy (bn (dp), ld);
353 }
354 if (eu <= pb->di->dp)
355 gf (pb, kt (pb, &lc->dc));
356 ed dp = bld.bo (az), bc = gf (pb, dp), gz =
357 fl (pb, jr), od = kt (pb, &lc->dc);
358 if (pb->di->dp)
359 {
360 bn dp = bld.dc (), ha = bld.dc (eo);
361 ed le = fl (pb, jr), hb = bld.fu (dr, dp, ha, jy, le), ne = kt (pb, &lc->dc);
362 bld.ko (jq, bn (ne), hb, bc);
363 }
364 bn hc = bld.dc (), lf = bld.dc (eo);
365 bg hd = bg::ep (0), oq = bg::ep (5);
366 ed hb = bld.fu (f, hc, lf, gz, hd);
367 bld.dp (u, bn (od), hb, oq, bc);
368 }
369 case cr:
370 {
371 ed dp = kt (pb, &lc->dc);
372 gf (pb, dp);
373 }
374 case mr:
375 case ey:
376 {
377 ed kh = kt (pb, lc->kh[0].dp), dst = kt (pb, &lc->dc);
378 if (lc)
379 if (lc->kh[0].dp->cg && kh.en ())
380 {
381 bn he = bld.dc ();
382 bg dp;
383 kh = bld.fw (dx, he, dp, kh);
384 }
385 if (lc->kh[0].dp->cg && kh.en ())
386 {
387 bn lg = bld.dc ();
388 bg dp;
389 kh = bld.fw (t, lg, dp, kh);
390 }
391 ge (pb, "", 8, &lc->db, "");
392 bn dc = bld.lm.ek ()? bn (dst) : bld.dc ();
393 if (lc->dp)
394 kh = bld.copy (dc, kh);
395 else
396 {
397 bn hf = bld.dc ();
398 kh = bld.fu (fn::kk, dc, hf, kh, bg (bf));
399 }
400 if (dst.ek () != bld.lm.ek ())
401 {
402 bg dp;
403 bld.ft (jm, bn (dst), kh, dp);
404 }
405 mz (pb);
406 }
407 case nx:
408 {
409 ed nf = kt (pb, lc->kh[0].dp), kh = bld.km (nf), dst = kt (pb, &lc->dc);
410 if (kh.ek ())
411 op (pb, kh, 0, dst);
412 if (dst.ek ())
413 {
414 bg dp;
415 bld.ft (jm, bn (dst), kh, dp);
416 }
417 bld.copy (bn (dst), kh);
418 }
419 case cy:
420 case ff:
421 {
422 ed kh = kt (pb, lc->kh[0].dp), delta = kt (pb, lc->kh[1].dp), dst =
423 kt (pb, &lc->dc), bo, hg, hi, dp = bld.bo (az), hh = gf (pb, dp), lh = bld.fs ();
424 if (ka ())
425 gt (pb, lc, kh);
426 {
427 ed hh = kt (pb, lc->kh[1].dp) = kt (pb, &lc->dc) = gh (pb, kh);
428 if (lc || ka ())
429 hh = bld.km (hh);
430 if (nd == ba || kh.en ())
431 bo = bld.bo (az) = gg (pb, bld, hh, kh);
432 if (dst.jx ())
433 bld.dc ();
434 bld.ft (mj, bn (dst), bo);
435 bld.ft (b, bn (dst), bo);
436 if (kh.en ())
437 bo = gg (pb, bld, hh, kh);
438 bld.copy (bn (dst), bo);
439 if (kh.en () == em)
440 {
441 hg = bld.bo (az) = bld.bo (az);
442 bld.ft (mj, bn (hg), kh);
443 gg (pb, bld, hh, hg) = gg (pb, bld, hh, hi);
444 bld.ft (jm, bn (dst), hg, hi);
445 gi (pb, dst, 2);
446 }
447 ge (pb, "", 4, &lc->db, "");
448 mz (pb);
449 }
450 kt (pb, lc->kh[0].dp);
451 if (ka ())
452 gt (pb, lc, kh);
453 if (fz)
454 bld.copy (bn (dst), kh);
455 delta = bld.km (delta) = gh (pb, kh);
456 if (ka () && gv (pb, bo, kh, fz, gd))
457 {
458 bn dp = bld.dc (), oe = bld.dc ();
459 bg hj = bg::ep (0);
460 ed li =
461 bld.fv (jn, dp, delta, hj), hk = ku (pb, bld, kh, oa, true);
462 gj (pb, li) = bld.ko (ol, oe, hk, kh, li);
463 }
464 if (pb->di->k && fz)
465 {
466 bn dp = bld.dc (), ng = bld.dc (eo), hl = bld.dc (), lj = bld.dc (eo);
467 delta = bld.fu (dr, dp, ng, delta, bk);
468 bg hm = bg::ep (2);
469 delta = bld.fu (nt, hl, lj, delta, hm);
470 }
471 bn ou = bld.dc (), hn = bld.dc (), lk = bld.dc (), ho = bld.dc (eo) = bld.dc (), nh = bld.dc (eo) = bld.dc (), hp = bld.dc (eo) = bld.dc (), ll = bld.dc (eo), hq = bld.dc ();
472 bg of = bg::ep (0), hr = bg::ep (64) = bld.fu (q, nh, hr, delta);
473 if (fz)
474 {
475 bn dp = bld.dc (), ni = bld.dc () = bld.dc (), hs = bld.dc (), ln = bld.dc (), ht = bld.dc (), oz = bld.dc (), hu = bld.dc (), lo = bld.dc ();
476 ed hv = bld.fu (du, ni, hg, delta), nj = bld.fu (nt, hs, hg, delta);
477 if (fz)
478 {
479 bn dp = bld.dc () = bld.dc (), hw = bld.dc (), lp = bld.dc () = bld.dc (), hx = bld.dc ();
480 bg og = bg::ep (4444), hy = bg::ep (32);
481 ed lotolohi = bld.copy (dp, og), hz = bld.fu (dv, hw, hv, lotolohi) =
482 bld.fu (mk, lp, hv, hz) = bld.fu (q, hx, hy, delta);
483 }
484 hg = bld.fu (dv, ln, ht, hv, nj);
485 bg lq = bg::ep (88888888);
486 ed ia = bld.copy (oz, lq);
487 hi = bld.fu (dv, hu, lo, hg, ia);
488 }
489 else
490 {
491 bn dp = bld.dc ();
492 bg nk = bg::ep (4275878552);
493 hi = bld.copy (dp, nk);
494 }
495 ed hz = bld.ft (jm, hn, hg, hi);
496 ed hv = bld.fu (m, lk, ho, hz, delta);
497 ed nj = bld.fu (l, hp, hz, delta);
498 hz = bld.fu (o, ll, hv, nj);
499 hg = bld.bo (ax) = bld.bo (ax);
500 bld.ft (mj, bn (hg), bn (hi), hz);
501 fm ib = bld.dp (w, hq, kh, hg, hi);
502 bp & lr = ib->br (), &ic = ib->br ();
503 lr.dp[0] = true;
504 ic.dp[1] = true;
505 if (pb->di && fz)
506 {
507 bn dp = bld.dc (), ov = bld.dc (), id = bld.dc ();
508 bg ls = bg::ep (2), ie = bg::ep (1);
509 ed nl = bld.ko (dy, dp, ls, lh);
510 bo = bld.ds (a, ov, nl, kh);
511 lh = bld.dp (s, id, ie, lh, hh);
512 }
513 bo = gg (pb, bld, lh, kh);
514 jv ig;
515 bo = op (pb, bo, 0, ig);
516 bld.copy (bn (dst), bo);
517 mz (pb);
518 }
519 case cq:
520 {
521 ed dp = kt (pb, &lc->dc), lt = fl (pb, z);
522 bg ih = bg::ep (8), oh = bg::ep (4);
523 bld.dp (jp, bn (dp), lt, ih, oh);
524 }
525 case cw:
526 {
527 ed kh = kt (pb, lc->kh[0].dp), dst = kt (pb, &lc->dc);
528 if (lc->dc.cg)
529 {
530 bn dp = bld.dc (eo), ii = bld.dc ();
531 fm lu = bld.kn (fn::kl, ii, bg (bf));
532 ed bo = bld.fv (fn::fp, dp, kh, lu);
533 gj (pb, dst);
534 }
535 gk (pb, kh, dst);
536 mz (pb);
537 }
538 case ci:
539 {
540 ed kh = kt (pb, lc->kh[0].dp), dst = kt (pb, &lc->dc);
541 if (kh.jx ())
542 bld.ft (b, bn (dst), kh);
543 bld.copy (bn (dst), kh);
544 }
545 case mt:
546 {
547 ed kh = kt (pb, lc->kh[0].dp), dst = kt (pb, &lc->dc);
548 bn dp = bld.dc (), ij = bld.dc (eo), nm =
549 bld.dc (), ik = bld.dc (eo), lv = bld.dc (eo);
550 ed bo = bld.kn (fn::fo, dp, ij, kh);
551 bld.fu (fn::kk, nm, ik, bo, bg (bf)).dc ().dp ();
552 ed cond = gj (pb, bo);
553 bld.kn (fn::fo, bn (dst), lv, cond);
554 mz (pb);
555 }
556 case da:
557 {
558 ed kh = kt (pb, lc->kh[0].dp), dst = kt (pb, &lc->dc) = gj (pb, kh);
559 gj (pb, dst);
560 }
561 case os:
562 {
563 ed kh = kt (pb, lc->kh[0].dp), dp = kt (pb, &lc->dc);
564 bn il = bld.dc (), pc = bld.dc (eo), im = bld.dc (eo);
565 kh = bld.fu (fn::kk, il, pc, kh, bg (bf));
566 bld.kn (fn::mv, bn (dp), im, kh);
567 mz (pb);
568 }
569 case cv:
570 {
571 ed kh = kt (pb, lc->kh[0].dp), dp = kt (pb, &lc->dc);
572 bn lw = bld.dc (), in = bld.dc (eo), nn = bld.dc (), io = bld.dc (eo), lx = bld.dc (), ip = bld.dc (eo), oi = bld.dc (eo);
573 kh = bld.kn (fn::fo, lw, in, kh);
574 kh = bld.fu (fn::kk, nn, io, kh, bg (bf));
575 kh = bld.kn (fn::mv, lx, ip, kh);
576 bld.kn (fn::fo, bn (dp), oi, kh);
577 mz (pb);
578 }
579 case cx:
580 case cn:
581 case cm:
582 {
583 ed kh = kt (pb, lc->kh[0].dp), dst = kt (pb, &lc->dc);
584 unsigned dp = lc->dp ? af () : af ();
585 if (ka () == pb->di->dp)
586 if (lc->dp)
587 if (nc (pb, lc))
588 if (nc (pb, lc))
589 break;
590 jv iq;
591 kh = op (pb, kh, 0, iq);
592 jz ly = la (ks, lc->kh[0].dp->cg);
593 switch (lc->dp)
594 {
595 case cx:
596 case cn:
597 case cm:
598 break;
599 default:
600 __builtin_unreachable ();
601 }
602 bool ir = ks == bz || ks == ev && dst.jx ();
603 if (ir)
604 lb (pb, ly, bn (dst), kh);
605 gu (pb, dq, ly, dp, bn (dst), kh);
606 mz (pb);
607 }
608 case fe:
609 {
610 ed kh = kt (pb, lc->kh[0].dp), dst = kt (pb, &lc->dc);
611 if (gx)
612 gt (pb, lc, kh);
613 switch (lc->dp)
614 {
615 case kf:
616 kj ();
617 case cu:
618 case ct:
619 nw = kj ();
620 case fe:
621 nw = af ();
622 nv &= ka ();
623 case fd:
624 nw = kj ();
625 }
626 if (lc->dc.cg)
627 {
628 bn dp = bld.dc ();
629 bg lz;
630 kh = bld.fx (ol, dp, lz, eq, kh);
631 }
632 if (lc->dc.cg)
633 kh = gh (pb, kh);
634 if (lc->dc.cg && lc->dp)
635 {
636 bn dp = bld.dc (), is = bld.dc (), no = bld.dc (eo), it = bld.dc (), ma = bld.dc (eo), iu = bld.dc (eo);
637 bg oj = bld.lm.av ()? bg::ep (kq) : bld.ft (jm, dp, bl, mp);
638 kh = bld.fu (fn::kk, is, no, kh, bg (bf));
639 kh = bld.fu (fn::kk, it, ma, oj, kh);
640 bld.kn (fn::mv, bn (dst), iu, kh);
641 }
642 if (lc || lc->dc.cg)
643 {
644 unsigned iv = lc->dc.cg / 8;
645 bn dc = iv || lc->dc.cg ? bld.dc () : bn (dst);
646 if (pb->di->k)
647 bld.oy (v, dc, kh, nw, 5, 5, true, nv);
648 bld.ds (dp, dc, kh, 5 | nw);
649 if (iv)
650 {
651 bn dp = bld.dc ();
652 ed mb = dc.dp ();
653 bld.ft (mj, bn (dst), dp, mb);
654 }
655 if (lc->dc.cg)
656 {
657 bg dp;
658 ed iw = dc.dp ();
659 bld.fw (dx, bn (dst), dp, iw);
660 }
661 }
662 if (lc->dc.cg)
663 {
664 ed hg, hi = bld.ft (mj, bn (hg), hi, kh);
665 if (pb->di->k)
666 {
667 bn dp = bld.dc (), np = bld.dc ();
668 hg = bld.oy (v, dp, hg, nw, 5, 5, true, nv);
669 hi = bld.oy (v, np, hi, nw, 5, 5, true, nv);
670 }
671 bn ix = bld.dc (), mc = bld.dc ();
672 hg = bld.ds (dp, ix, hg, nw);
673 hi = bld.ds (dp, mc, hi, 5 | nw);
674 bld.ft (jm, bn (dst), hg, hi);
675 gi (pb, dst, 2);
676 }
677 ge (pb, "", 4, &lc->db, "");
678 mz (pb);
679 kh = kt (pb, lc->kh[0].dp) = kt (pb, &lc->dc);
680 gt (pb, lc, kh);
681 bool dp = ka ();
682 if (lc->dc.cg)
683 kh = gh (pb, kh);
684 if (lc->dc.cg)
685 {
686 bn iy = bld.dc ();
687 bg ow, iz;
688 kh = bld.fx (ol, iy, ow, bm, kh);
689 kh = ku (pb, bld, kh, ga, dp);
690 bld.fw (dx, bn (dst), iz, kh);
691 }
692 if (dst.en ())
693 {
694 ed bo = ku (pb, bld, kh, ga, dp);
695 op (pb, bo, 0, dst);
696 }
697 if (dst.en () == om)
698 {
699 ed bo = ku (pb, bld, kh, ga, dp);
700 op (pb, bo, 0, dst);
701 }
702 if (dst.en () == az)
703 {
704 ed md = ku (pb, bld, kh, ga, dp);
705 bld.copy (bn (dst), md);
706 }
707 if (dst.en () == em)
708 {
709 ed hg = bld.bo (az), hi = bld.bo (az);
710 bld.ft (mj, bn (hg), hi, kh);
711 hg = ku (pb, bld, hg, ga, dp) = ku (pb, bld, hi, ga, dp);
712 bld.ft (jm, bn (dst), hg, hi);
713 gi (pb, dst, 2);
714 }
715 ge (pb, "", 5, &lc->db, "");
716 mz (pb);
717 }
718 {
719 ed dp = kt (pb, lc->kh[0].dp), kh = gh (pb, dp), ja = kt (pb, lc->kh[1].dp), nq = bld.km (ja), jb = kt (pb, lc->kh[2].dp), lane = bld.km (jb), dst = kt (pb, &lc->dc);
720 if (dst.en ())
721 bld.nz (bn (dst), nq, lane, kh);
722 if (dst.en ())
723 {
724 ed dp = bld.bo (az), jc = bld.bo (az), me = bld.bo (ax), jd = bld.bo (ax);
725 bld.ft (mj, bn (dp), bn (jc), kh);
726 bld.ft (mj, bn (me), bn (jd), nq);
727 bn ok = bld.dc (), je = bld.dc ();
728 ed hg = bld.nz (ok, me, lane, jc);
729 ed hi = bld.nz (je, jd, lane, jc);
730 bld.ft (jm, bn (dst), hg, hi);
731 gi (pb, dst, 2);
732 }
733 ge (pb, "", 8, &lc->db, "");
734 }
735 case cs:
736 {
737 ed kh = kt (pb, lc->kh[0].dp), dp = kt (pb, lc->kh[1].dp), mf = gh (pb, dp), dst = kt (pb, &lc->dc) = op (pb, kh, 0, jv ());
738 gf (pb, dst, kh, mf);
739 mz (pb);
740 kh = kt (pb, lc->kh[0].dp) = kt (pb, &lc->dc);
741 if (kh.en ())
742 bld.copy (bn (dst), kh);
743 if (dst.en () && kh.en ())
744 {
745 ed dp = kt (pb, lc->kh[1].dp), jf = bld.km (dp), nr = kt (pb, lc->kh[2].dp), jg = bld.km (nr);
746 bld.dp (w, bn (dst), kh, jf, jg);
747 }
748 ge (pb, "", 4, &lc->db, "");
749 kt (pb, &lc->dc);
750 bld.ft (d, bn (dst), bg ());
751 }
752 if (lc->dp)
753 {
754 ed kh = kt (pb, lc->kh[0].dp);
755 bn dp = bld.dc (), mg = bld.dc (eo);
756 er = bld.fu (fn::kk, dp, mg, kh, bg (bf));
757 }
758 bld.ft (er);
759 if (bt || pb->mu.dj.fk)
760 pb->mu.dk = gw->dp |= ju;
761 if (ki->dp.dp)
762 ar = true;
763 case cz:
764 case ck:
765 case cl:
766 {
767 bg cond = bg::ep (1);
768 if (lc->dp == cl || lc->dp == cz)
769 {
770 ed kh = kt (pb, lc->kh[0].dp);
771 bn dp = bld.dc (), jh = bld.dc (eo);
772 cond = bld.fu (fn::kk, dp, jh, kh, bg (bf));
773 pb->mu.dp |= ka ();
774 }
775 bld.ft (cond);
776 if (bt || pb->mu.dj.fk)
777 pb->mu.dk = pb->mu.dp |= gl (pb);
778 gw->dp |= ju;
779 }
780 case fa:
781 {
782 ed dp = kt (pb, &lc->dc);
783 bld.kn (fn::kl, bn (dp), bg (bf));
784 }
785 mz (pb);
786 case co:
787 {
788 bn pa = bld.dc (), dp = bld.dc (eo);
789 ed flbit = bld.kn (fn::fq, pa, bg (bf)), ji = kt (pb, &lc->dc);
790 bg mh = bg::ep (pb->di->dp - 1);
791 bld.fu (dw, bn (ji), dp, mh, flbit);
792 mz (pb);
793 }
794 case kd:
795 {
796 ed dp = kt (pb, &lc->dc);
797 bld.ft (c, bn (dp), bg (bf));
798 }
799 mz (pb);
800 case kg:
801 ed dst = kt (pb, &lc->dc);
802 if (fi () && pb->dp->k)
803 {
804 bn jj = bld.dc ();
805 ed clock = bld.mw (h, jj, 9);
806 bg dp;
807 bld.ft (jm, bn (dst), clock, dp);
808 }
809 if (fi () && pb->dp->k)
810 {
811 bg ns = bg::ep (dn);
812 bld.kn (p, bn (dst), ns);
813 E1 dp = fi ()? jo : n;
814 bld.dp (dp, bn (dst), 0);
815 }
816 gi (pb, dst, 2);
817 }
818 }
819 dh *jk;
820 void mi (bool, bool, bool)
821 {
822 mm ();
823 for (df * dp (ka ()? (df *) bx : __null);
824 dp; dp = ka ()? (df *) bx : __null)
825 switch (dp->jx)
826 {
827 case de:
828 for (cf * db (ka ()? (cf *) bx : __null);
829 db; db = ka ()? (cf *) bx : __null)
830 switch (db->jx)
831 {
832 case mq:
833 na (jk, gc);
834 case kb:
835 na (jk, my);
836 case cc:
837 gy ();
838 case ew:
839 mm ();
840 case ce:
841 mm ();
842 case ex:
843 mm ();
844 case cb:
845 case cd:
846 mm ();
847 ge (jk, "", 6, db, "");
848 }
849 mm ();
850 case ny:
851 mm ();
852 }
853 }
854 }
855 void
856 jl ()
857 {
858 dh ctx;
859 if (gb)
860 mi (as, ej, at);
861 }