| 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 |
} |