char LInt_Div2(unsigned char *A, unsigned char *B, unsigned char *Quo,
               unsigned char *Odd) {
  unsigned char Odd1[256], Odd2[256], *OddA, *OddB, *Tmp, RtCod;
  int Cnt, Cnt1, Shft;
  unsigned int OSub, DivSub, QuoSub, BLth, OLth, QuoSubB;
  char LInt_Add(unsigned char *, unsigned char *);
  for (BLth = (int)*B; BLth != 0 && *(B + BLth) == (char)0; BLth--)
    ;
  if (BLth == 0) {
    *Odd = (char)0;
    *Quo = (char)0;
    return (char)1;
  }
  for (OLth = (int)*A; OLth != 0 && *(A + OLth) == (char)0; OLth--)
    ;
  *Quo = (char)0;
  for (Cnt = 1; Cnt <= OLth; Cnt++)
    *(Odd + Cnt) = *(A + Cnt);
  Odd1[0] = (char)OLth;
  if ((OLth < BLth) || ((OLth == BLth) && (*(A + OLth) < *(B + BLth)))) {
    for (Cnt = 0; Cnt <= OLth; Cnt++)
      *(Odd + Cnt) = Odd1[Cnt];
    return (char)0;
  }
  OddA = Odd1;
  OddB = Odd2;
  do {
    QuoSubB = (int)*(OddA + OLth) / ((int)*(B + BLth) + 1);
    QuoSub = (int)*(OddA + OLth) / (int)*(B + BLth);
    RtCod = (char)0;
    do {
      if (QuoSub != 0) {
        Shft = OLth - BLth;
        OSub = (int)*(OddA + OLth);
        DivSub = (int)*(B + BLth) * QuoSub;
        OSub -= DivSub;
        OSub <<= 8;
      } else if (OLth == BLth)
        RtCod = (char)2;
      else {
        QuoSub = (int)*(unsigned short *)(OddA + OLth - 1);
        OSub = QuoSub;
        QuoSub /= ((int)*(B + BLth) + 1);
        Shft = OLth - BLth - 1;
        DivSub = (int)*(B + BLth) * QuoSub;
        OSub -= DivSub;
        *(OddB + OLth) = (char)(OSub >> 8);
        OSub = (OSub & 0xff) << 8;
      }
      if (RtCod == (char)1)
        RtCod = (char)0;
      for (Cnt = BLth - 1; Cnt > 0 && RtCod == (char)0; Cnt--) {
        OSub += (int)*(OddA + Cnt + Shft);
        DivSub = (int)*(B + Cnt) * QuoSub;
        if (OSub >= DivSub) {
          OSub -= DivSub;
          *(OddB + Cnt + Shft + 1) = (char)(OSub >> 8);
          OSub = (OSub & 0xff) << 8;
        } else {
          for (Cnt1 = Cnt + Shft + 2; Cnt1 <= OLth && *(OddB + Cnt1) == (char)0;
               Cnt1++)
            ;
          if (Cnt1 <= OLth) {
            *(OddB + Cnt1) -= 1;
            for (Cnt1--; Cnt1 >= Cnt + Shft + 2; Cnt1--)
              *(OddB + Cnt1) = (char)0xff;
            OSub += (0xffff - DivSub) + 1;
            *(OddB + Cnt1) = (char)(OSub >> 8);
            OSub = (OSub & 0xff) << 8;
          } else {
            QuoSub -= (QuoSub - QuoSubB + 1) >> 1;
            RtCod = (char)1;
          }
        }
      }
      if (RtCod == (char)0) {
        *(OddB + Shft + 1) = (char)(OSub >> 8);
        if (((int)OddA - Shft) <= Shft) {
          for (Cnt = Shft; Cnt >= 0; Cnt--)
            *(OddB + Cnt) = *(OddA + Cnt);
          Tmp = OddB;
          OddB = OddA;
          OddA = Tmp;
        } else
          for (Cnt = (int)*OddA; Cnt > Shft; Cnt--)
            *(OddA + Cnt) = *(OddB + Cnt);
        for (OLth = (int)*OddA; OLth != 0 && *(OddA + OLth) == (char)0; OLth--)
          ;
        *OddA = (char)OLth;
        *OddB = (char)(Shft + 1);
        for (Cnt = 1; Cnt <= Shft; Cnt++)
          *(OddB + Cnt) = (char)0;
        *(OddB + Cnt) = QuoSub;
        LInt_Add(Quo, OddB);
        if (OLth >= BLth)
          RtCod = (char)0;
        else
          RtCod = (char)2;
      }
    } while (RtCod == (char)1);
  } while (RtCod == (char)0);
  for (Cnt = 0; Cnt <= OLth; Cnt++)
    *(Odd + Cnt) = *(OddA + Cnt);
  return (char)0;
}


x86 assembly (clang, -O0):
<LInt_Div2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x280,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x268(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x268(%rbp)
mov    %al,-0x271(%rbp)
je     1167 <LInt_Div2+0x57>
mov    -0x18(%rbp),%rax
mov    -0x268(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
sete   %al
mov    %al,-0x271(%rbp)
mov    -0x271(%rbp),%al
test   $0x1,%al
jne    117a <LInt_Div2+0x6a>
jmp    1193 <LInt_Div2+0x83>
jmp    117f <LInt_Div2+0x6f>
mov    -0x268(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x268(%rbp)
jmp    1138 <LInt_Div2+0x28>
cmpl   $0x0,-0x268(%rbp)
jne    11b7 <LInt_Div2+0xa7>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x20(%rbp),%rax
movb   $0x0,(%rax)
movb   $0x1,-0x1(%rbp)
jmp    1a3f <LInt_Div2+0x92f>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x26c(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x26c(%rbp)
mov    %al,-0x272(%rbp)
je     11f3 <LInt_Div2+0xe3>
mov    -0x10(%rbp),%rax
mov    -0x26c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
sete   %al
mov    %al,-0x272(%rbp)
mov    -0x272(%rbp),%al
test   $0x1,%al
jne    1206 <LInt_Div2+0xf6>
jmp    121f <LInt_Div2+0x10f>
jmp    120b <LInt_Div2+0xfb>
mov    -0x26c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x26c(%rbp)
jmp    11c4 <LInt_Div2+0xb4>
mov    -0x20(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x1,-0x250(%rbp)
mov    -0x250(%rbp),%eax
cmp    -0x26c(%rbp),%eax
ja     1272 <LInt_Div2+0x162>
mov    -0x10(%rbp),%rax
movslq -0x250(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
movslq -0x250(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x250(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x250(%rbp)
jmp    1230 <LInt_Div2+0x120>
mov    -0x26c(%rbp),%eax
mov    %al,-0x130(%rbp)
mov    -0x26c(%rbp),%eax
cmp    -0x268(%rbp),%eax
jb     12c6 <LInt_Div2+0x1b6>
mov    -0x26c(%rbp),%eax
cmp    -0x268(%rbp),%eax
jne    131b <LInt_Div2+0x20b>
mov    -0x10(%rbp),%rax
mov    -0x26c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x268(%rbp),%edx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jge    131b <LInt_Div2+0x20b>
movl   $0x0,-0x250(%rbp)
mov    -0x250(%rbp),%eax
cmp    -0x26c(%rbp),%eax
ja     1312 <LInt_Div2+0x202>
movslq -0x250(%rbp),%rax
mov    -0x130(%rbp,%rax,1),%dl
mov    -0x28(%rbp),%rax
movslq -0x250(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x250(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x250(%rbp)
jmp    12d0 <LInt_Div2+0x1c0>
movb   $0x0,-0x1(%rbp)
jmp    1a3f <LInt_Div2+0x92f>
lea    -0x130(%rbp),%rax
mov    %rax,-0x238(%rbp)
lea    -0x230(%rbp),%rax
mov    %rax,-0x240(%rbp)
mov    -0x238(%rbp),%rax
mov    -0x26c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x268(%rbp),%edx
movzbl (%rcx,%rdx,1),%ecx
add    $0x1,%ecx
cltd
idiv   %ecx
mov    %eax,-0x270(%rbp)
mov    -0x238(%rbp),%rax
mov    -0x26c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x268(%rbp),%edx
movzbl (%rcx,%rdx,1),%ecx
cltd
idiv   %ecx
mov    %eax,-0x264(%rbp)
movb   $0x0,-0x249(%rbp)
cmpl   $0x0,-0x264(%rbp)
je     140a <LInt_Div2+0x2fa>
mov    -0x26c(%rbp),%eax
sub    -0x268(%rbp),%eax
mov    %eax,-0x258(%rbp)
mov    -0x238(%rbp),%rax
mov    -0x26c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x25c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x268(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
imul   -0x264(%rbp),%eax
mov    %eax,-0x260(%rbp)
mov    -0x260(%rbp),%ecx
mov    -0x25c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x25c(%rbp)
mov    -0x25c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x25c(%rbp)
jmp    14e5 <LInt_Div2+0x3d5>
mov    -0x26c(%rbp),%eax
cmp    -0x268(%rbp),%eax
jne    1428 <LInt_Div2+0x318>
movb   $0x2,-0x249(%rbp)
jmp    14e0 <LInt_Div2+0x3d0>
mov    -0x238(%rbp),%rax
mov    -0x26c(%rbp),%ecx
movzwl -0x1(%rax,%rcx,1),%eax
mov    %eax,-0x264(%rbp)
mov    -0x264(%rbp),%eax
mov    %eax,-0x25c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x268(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
add    $0x1,%ecx
mov    -0x264(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    %eax,-0x264(%rbp)
mov    -0x26c(%rbp),%eax
sub    -0x268(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x258(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x268(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
imul   -0x264(%rbp),%eax
mov    %eax,-0x260(%rbp)
mov    -0x260(%rbp),%ecx
mov    -0x25c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x25c(%rbp)
mov    -0x25c(%rbp),%eax
shr    $0x8,%eax
mov    %al,%dl
mov    -0x240(%rbp),%rax
mov    -0x26c(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x25c(%rbp),%eax
and    $0xff,%eax
shl    $0x8,%eax
mov    %eax,-0x25c(%rbp)
jmp    14e5 <LInt_Div2+0x3d5>
movzbl -0x249(%rbp),%eax
cmp    $0x1,%eax
jne    14fc <LInt_Div2+0x3ec>
movb   $0x0,-0x249(%rbp)
mov    -0x268(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x250(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x250(%rbp)
mov    %al,-0x273(%rbp)
jle    1533 <LInt_Div2+0x423>
movzbl -0x249(%rbp),%eax
cmp    $0x0,%eax
sete   %al
mov    %al,-0x273(%rbp)
mov    -0x273(%rbp),%al
test   $0x1,%al
jne    1546 <LInt_Div2+0x436>
jmp    1779 <LInt_Div2+0x669>
mov    -0x238(%rbp),%rax
movslq -0x250(%rbp),%rcx
add    %rcx,%rax
movslq -0x258(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
add    -0x25c(%rbp),%eax
mov    %eax,-0x25c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x250(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
imul   -0x264(%rbp),%eax
mov    %eax,-0x260(%rbp)
mov    -0x25c(%rbp),%eax
cmp    -0x260(%rbp),%eax
jb     15f0 <LInt_Div2+0x4e0>
mov    -0x260(%rbp),%ecx
mov    -0x25c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x25c(%rbp)
mov    -0x25c(%rbp),%eax
shr    $0x8,%eax
mov    %al,%dl
mov    -0x240(%rbp),%rax
movslq -0x250(%rbp),%rcx
add    %rcx,%rax
movslq -0x258(%rbp),%rcx
mov    %dl,0x1(%rax,%rcx,1)
mov    -0x25c(%rbp),%eax
and    $0xff,%eax
shl    $0x8,%eax
mov    %eax,-0x25c(%rbp)
jmp    1760 <LInt_Div2+0x650>
mov    -0x250(%rbp),%eax
add    -0x258(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x254(%rbp)
mov    -0x254(%rbp),%ecx
xor    %eax,%eax
cmp    -0x26c(%rbp),%ecx
mov    %al,-0x274(%rbp)
ja     163d <LInt_Div2+0x52d>
mov    -0x240(%rbp),%rax
movslq -0x254(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
sete   %al
mov    %al,-0x274(%rbp)
mov    -0x274(%rbp),%al
test   $0x1,%al
jne    1650 <LInt_Div2+0x540>
jmp    1669 <LInt_Div2+0x559>
jmp    1655 <LInt_Div2+0x545>
mov    -0x254(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x254(%rbp)
jmp    1605 <LInt_Div2+0x4f5>
mov    -0x254(%rbp),%eax
cmp    -0x26c(%rbp),%eax
ja     1734 <LInt_Div2+0x624>
mov    -0x240(%rbp),%rax
movslq -0x254(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
sub    $0x1,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x254(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x254(%rbp)
mov    -0x254(%rbp),%eax
mov    -0x250(%rbp),%ecx
add    -0x258(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jl     16e5 <LInt_Div2+0x5d5>
mov    -0x240(%rbp),%rax
movslq -0x254(%rbp),%rcx
movb   $0xff,(%rax,%rcx,1)
mov    -0x254(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x254(%rbp)
jmp    16a2 <LInt_Div2+0x592>
mov    $0xffff,%eax
sub    -0x260(%rbp),%eax
add    $0x1,%eax
add    -0x25c(%rbp),%eax
mov    %eax,-0x25c(%rbp)
mov    -0x25c(%rbp),%eax
shr    $0x8,%eax
mov    %al,%dl
mov    -0x240(%rbp),%rax
movslq -0x254(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x25c(%rbp),%eax
and    $0xff,%eax
shl    $0x8,%eax
mov    %eax,-0x25c(%rbp)
jmp    175b <LInt_Div2+0x64b>
mov    -0x264(%rbp),%ecx
sub    -0x270(%rbp),%ecx
add    $0x1,%ecx
shr    $0x1,%ecx
mov    -0x264(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x264(%rbp)
movb   $0x1,-0x249(%rbp)
jmp    1760 <LInt_Div2+0x650>
jmp    1765 <LInt_Div2+0x655>
mov    -0x250(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x250(%rbp)
jmp    150b <LInt_Div2+0x3fb>
movzbl -0x249(%rbp),%eax
cmp    $0x0,%eax
jne    19c2 <LInt_Div2+0x8b2>
mov    -0x25c(%rbp),%eax
shr    $0x8,%eax
mov    %al,%dl
mov    -0x240(%rbp),%rax
movslq -0x258(%rbp),%rcx
mov    %dl,0x1(%rax,%rcx,1)
mov    -0x238(%rbp),%rax
sub    -0x258(%rbp),%eax
cmp    -0x258(%rbp),%eax
jg     183d <LInt_Div2+0x72d>
mov    -0x258(%rbp),%eax
mov    %eax,-0x250(%rbp)
cmpl   $0x0,-0x250(%rbp)
jl     180e <LInt_Div2+0x6fe>
mov    -0x238(%rbp),%rax
movslq -0x250(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x240(%rbp),%rax
movslq -0x250(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x250(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x250(%rbp)
jmp    17cb <LInt_Div2+0x6bb>
mov    -0x240(%rbp),%rax
mov    %rax,-0x248(%rbp)
mov    -0x238(%rbp),%rax
mov    %rax,-0x240(%rbp)
mov    -0x248(%rbp),%rax
mov    %rax,-0x238(%rbp)
jmp    189a <LInt_Div2+0x78a>
mov    -0x238(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x250(%rbp)
mov    -0x250(%rbp),%eax
cmp    -0x258(%rbp),%eax
jle    1895 <LInt_Div2+0x785>
mov    -0x240(%rbp),%rax
movslq -0x250(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x238(%rbp),%rax
movslq -0x250(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x250(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x250(%rbp)
jmp    184d <LInt_Div2+0x73d>
jmp    189a <LInt_Div2+0x78a>
mov    -0x238(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x26c(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x26c(%rbp)
mov    %al,-0x275(%rbp)
je     18dc <LInt_Div2+0x7cc>
mov    -0x238(%rbp),%rax
mov    -0x26c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
sete   %al
mov    %al,-0x275(%rbp)
mov    -0x275(%rbp),%al
test   $0x1,%al
jne    18ef <LInt_Div2+0x7df>
jmp    1908 <LInt_Div2+0x7f8>
jmp    18f4 <LInt_Div2+0x7e4>
mov    -0x26c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x26c(%rbp)
jmp    18aa <LInt_Div2+0x79a>
mov    -0x26c(%rbp),%eax
mov    %al,%cl
mov    -0x238(%rbp),%rax
mov    %cl,(%rax)
mov    -0x258(%rbp),%eax
add    $0x1,%eax
mov    %al,%cl
mov    -0x240(%rbp),%rax
mov    %cl,(%rax)
movl   $0x1,-0x250(%rbp)
mov    -0x250(%rbp),%eax
cmp    -0x258(%rbp),%eax
jg     196f <LInt_Div2+0x85f>
mov    -0x240(%rbp),%rax
movslq -0x250(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x250(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x250(%rbp)
jmp    1937 <LInt_Div2+0x827>
mov    -0x264(%rbp),%eax
mov    %al,%dl
mov    -0x240(%rbp),%rax
movslq -0x250(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%rdi
mov    -0x240(%rbp),%rsi
call   1030 <LInt_Add@plt>
mov    -0x26c(%rbp),%eax
cmp    -0x268(%rbp),%eax
jb     19b6 <LInt_Div2+0x8a6>
movb   $0x0,-0x249(%rbp)
jmp    19bd <LInt_Div2+0x8ad>
movb   $0x2,-0x249(%rbp)
jmp    19c2 <LInt_Div2+0x8b2>
jmp    19c7 <LInt_Div2+0x8b7>
movzbl -0x249(%rbp),%eax
cmp    $0x1,%eax
je     1391 <LInt_Div2+0x281>
jmp    19dc <LInt_Div2+0x8cc>
movzbl -0x249(%rbp),%eax
cmp    $0x0,%eax
je     1337 <LInt_Div2+0x227>
movl   $0x0,-0x250(%rbp)
mov    -0x250(%rbp),%eax
cmp    -0x26c(%rbp),%eax
ja     1a3b <LInt_Div2+0x92b>
mov    -0x238(%rbp),%rax
movslq -0x250(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
movslq -0x250(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x250(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x250(%rbp)
jmp    19f6 <LInt_Div2+0x8e6>
movb   $0x0,-0x1(%rbp)
movsbl -0x1(%rbp),%eax
add    $0x280,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LInt_Div2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2e8,%rsp
mov    %rcx,0x8(%rsp)
mov    %rsi,0x28(%rsp)
movzbl (%rsi),%r8d
test   %r8,%r8
je     1172 <LInt_Div2+0x42>
mov    0x28(%rsp),%rax
nopl   0x0(%rax)
mov    %r8d,%ebx
cmpb   $0x0,(%rax,%rbx,1)
jne    1184 <LInt_Div2+0x54>
add    $0xffffffffffffffff,%r8
test   %r8d,%r8d
jne    1160 <LInt_Div2+0x30>
mov    0x8(%rsp),%rax
movb   $0x0,(%rax)
movb   $0x0,(%rdx)
mov    $0x1,%al
jmp    19c1 <LInt_Div2+0x891>
movzbl (%rdi),%r11d
test   %r11d,%r11d
mov    %r8,0x10(%rsp)
mov    %rbx,0x18(%rsp)
je     11b2 <LInt_Div2+0x82>
lea    0x1(%r11),%ecx
nopl   0x0(%rax,%rax,1)
mov    %r11d,%eax
cmpb   $0x0,(%rdi,%rax,1)
jne    11bd <LInt_Div2+0x8d>
add    $0x3,%cl
add    $0xffffffff,%r11d
jne    11a0 <LInt_Div2+0x70>
movb   $0x0,(%rdx)
xor    %r11d,%r11d
jmp    13f6 <LInt_Div2+0x2c6>
movb   $0x0,(%rdx)
test   %r11d,%r11d
je     1214 <LInt_Div2+0xe4>
lea    0x1(%r11),%r10d
lea    -0x1(%r10),%r9
mov    $0x1,%ebx
cmp    $0x8,%r9
jb     1374 <LInt_Div2+0x244>
mov    0x8(%rsp),%rax
add    $0x1,%rax
lea    (%rdi,%r10,1),%rbp
cmp    %rbp,%rax
jae    1203 <LInt_Div2+0xd3>
mov    0x8(%rsp),%rax
add    %r10,%rax
lea    0x1(%rdi),%rbp
cmp    %rax,%rbp
jb     1374 <LInt_Div2+0x244>
mov    %rdx,%r12
cmp    $0x20,%r9
jae    121c <LInt_Div2+0xec>
xor    %r15d,%r15d
jmp    132a <LInt_Div2+0x1fa>
xor    %r11d,%r11d
jmp    13f6 <LInt_Div2+0x2c6>
mov    %r11,%r14
mov    %r9,%r15
and    $0xffffffffffffffe0,%r15
lea    -0x20(%r15),%rsi
mov    %rsi,%r8
shr    $0x5,%r8
add    $0x1,%r8
cmp    $0x60,%rsi
jae    1247 <LInt_Div2+0x117>
xor    %eax,%eax
mov    0x8(%rsp),%r11
jmp    12cb <LInt_Div2+0x19b>
mov    %r10d,%ebx
add    $0xffffffffffffffff,%rbx
and    $0xffffffffffffffe0,%rbx
add    $0xffffffffffffffe0,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffc,%rbx
xor    %eax,%eax
mov    0x8(%rsp),%r11
movups 0x1(%rdi,%rax,1),%xmm0
movups 0x11(%rdi,%rax,1),%xmm1
movups %xmm0,0x1(%r11,%rax,1)
movups %xmm1,0x11(%r11,%rax,1)
movups 0x21(%rdi,%rax,1),%xmm0
movups 0x31(%rdi,%rax,1),%xmm1
movups %xmm0,0x21(%r11,%rax,1)
movups %xmm1,0x31(%r11,%rax,1)
movups 0x41(%rdi,%rax,1),%xmm0
movups 0x51(%rdi,%rax,1),%xmm1
movups %xmm0,0x41(%r11,%rax,1)
movups %xmm1,0x51(%r11,%rax,1)
movups 0x61(%rdi,%rax,1),%xmm0
movups 0x71(%rdi,%rax,1),%xmm1
movups %xmm0,0x61(%r11,%rax,1)
movups %xmm1,0x71(%r11,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rbx
jne    1269 <LInt_Div2+0x139>
test   $0x3,%r8b
je     1311 <LInt_Div2+0x1e1>
lea    -0x1(%r10),%ebp
and    $0x60,%bpl
add    $0xe0,%bpl
shr    $0x5,%bpl
add    $0x1,%bpl
movzbl %bpl,%ebx
and    $0x3,%ebx
mov    %rax,%rsi
or     $0x1,%rsi
movups (%rdi,%rsi,1),%xmm0
movups 0x10(%rdi,%rsi,1),%xmm1
movups %xmm0,(%r11,%rsi,1)
movups %xmm1,0x10(%r11,%rsi,1)
add    $0x20,%rax
add    $0xffffffffffffffff,%rbx
jne    12ec <LInt_Div2+0x1bc>
cmp    %r15,%r9
mov    %r12,%rdx
jne    1321 <LInt_Div2+0x1f1>
mov    %r14,%r11
jmp    13ec <LInt_Div2+0x2bc>
test   $0x18,%r9b
mov    %r14,%r11
je     136d <LInt_Div2+0x23d>
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    0x1(%r8),%rbx
mov    %r10d,%edx
add    $0xffffffffffffffff,%rdx
and    $0xfffffffffffffff8,%rdx
mov    0x8(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x1(%rdi,%r15,1),%rax
mov    %rax,0x1(%rbp,%r15,1)
add    $0x8,%r15
cmp    %r15,%rdx
jne    1350 <LInt_Div2+0x220>
cmp    %r8,%r9
mov    %r12,%rdx
jne    1374 <LInt_Div2+0x244>
jmp    13ec <LInt_Div2+0x2bc>
or     $0x1,%r15
mov    %r15,%rbx
mov    %r10d,%eax
sub    %ebx,%eax
mov    %rbx,%r8
not    %r8
add    %r10,%r8
test   $0x3,%al
je     13b2 <LInt_Div2+0x282>
sub    %bl,%cl
movzbl %cl,%ecx
and    $0x3,%ecx
mov    0x8(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rdi,%rbx,1),%eax
mov    %al,0x0(%rbp,%rbx,1)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rcx
jne    13a0 <LInt_Div2+0x270>
cmp    $0x3,%r8
jb     13ec <LInt_Div2+0x2bc>
mov    %r10d,%eax
mov    0x8(%rsp),%rbp
movzbl (%rdi,%rbx,1),%ecx
mov    %cl,0x0(%rbp,%rbx,1)
movzbl 0x1(%rdi,%rbx,1),%ecx
mov    %cl,0x1(%rbp,%rbx,1)
movzbl 0x2(%rdi,%rbx,1),%ecx
mov    %cl,0x2(%rbp,%rbx,1)
movzbl 0x3(%rdi,%rbx,1),%ecx
mov    %cl,0x3(%rbp,%rbx,1)
add    $0x4,%rbx
cmp    %rbx,%rax
jne    13c0 <LInt_Div2+0x290>
mov    0x10(%rsp),%r8
mov    0x18(%rsp),%rbx
mov    %r11b,0xe0(%rsp)
cmp    %r8d,%r11d
jae    1421 <LInt_Div2+0x2f1>
mov    %r11d,%edx
add    $0x1,%rdx
lea    0xe0(%rsp),%rsi
mov    0x8(%rsp),%rdi
call   1050 <memcpy@plt>
jmp    19bf <LInt_Div2+0x88f>
jne    1430 <LInt_Div2+0x300>
mov    (%rdi,%rbx,1),%al
mov    0x28(%rsp),%rcx
cmp    (%rcx,%rbx,1),%al
jb     1403 <LInt_Div2+0x2d3>
mov    %rdx,0x78(%rsp)
lea    0x1e0(%rsp),%r13
lea    0xe0(%rsp),%r14
lea    -0x1(%r8),%eax
mov    %eax,0x70(%rsp)
mov    %r8d,%eax
not    %eax
mov    %rax,0xb0(%rsp)
mov    %r8d,%eax
neg    %eax
mov    %rax,0xa8(%rsp)
jmp    14c2 <LInt_Div2+0x392>
nopl   0x0(%rax)
mov    %eax,%edx
mov    %dl,(%r14)
lea    0x1(%rbx),%eax
mov    %al,(%rdi)
mov    %rdx,%rbp
test   %ebx,%ebx
jle    1920 <LInt_Div2+0x7f0>
mov    %rdi,%r13
add    $0x1,%rdi
mov    %ebx,%edx
xor    %esi,%esi
call   1040 <memset@plt>
add    $0x1,%ebx
mov    0x78(%rsp),%rdi
mov    %ebx,%eax
mov    %r15b,0x0(%r13,%rax,1)
mov    %r13,%rsi
call   1030 <LInt_Add@plt>
mov    %rbp,%r11
mov    0x10(%rsp),%r8
cmp    %r8d,%r11d
mov    0x18(%rsp),%rbx
jb     192d <LInt_Div2+0x7fd>
mov    %r11d,%eax
mov    %rax,0x90(%rsp)
movzbl (%r14,%rax,1),%ecx
mov    0x28(%rsp),%rax
movzbl (%rax,%rbx,1),%ebp
mov    %ebp,%edi
add    $0x1,%edi
mov    %ecx,%eax
xor    %edx,%edx
div    %di
movzwl %ax,%edx
movzbl %cl,%eax
div    %bpl
movzbl %al,%r15d
mov    $0x1,%eax
sub    %edx,%eax
mov    %rax,0xc0(%rsp)
mov    0xa8(%rsp),%rax
add    %r11d,%eax
mov    %eax,0x6c(%rsp)
mov    0xb0(%rsp),%rax
lea    (%rax,%r11,1),%eax
mov    %eax,0x64(%rsp)
lea    -0x1(%r13),%rax
mov    %rax,0xb8(%rsp)
lea    0x1(%r13),%rax
mov    %rax,0xc8(%rsp)
mov    %r13,%rdi
mov    %r13,0x20(%rsp)
mov    %r11,0x80(%rsp)
mov    %r14,0x98(%rsp)
jmp    1582 <LInt_Div2+0x452>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x58(%rsp),%r15
mov    0xc0(%rsp),%rax
add    %r15d,%eax
shr    %eax
sub    %eax,%r15d
mov    0x98(%rsp),%r14
mov    0x18(%rsp),%rbx
test   %r15d,%r15d
je     15b0 <LInt_Div2+0x480>
mov    0x90(%rsp),%rax
movzbl (%r14,%rax,1),%eax
mov    0x28(%rsp),%rcx
movzbl (%rcx,%rbx,1),%ecx
imul   %r15d,%ecx
sub    %ecx,%eax
shl    $0x8,%eax
mov    0x6c(%rsp),%ecx
jmp    15f6 <LInt_Div2+0x4c6>
nopl   0x0(%rax)
cmp    %r8d,%r11d
je     192d <LInt_Div2+0x7fd>
mov    0x90(%rsp),%rsi
movzwl -0x1(%r14,%rsi,1),%ecx
mov    0x28(%rsp),%rax
movzbl (%rax,%rbx,1),%ebp
lea    0x1(%rbp),%edi
mov    %ecx,%eax
xor    %edx,%edx
div    %di
mov    0x20(%rsp),%rdi
movzwl %ax,%r15d
imul   %r15d,%ebp
sub    %ebp,%ecx
mov    %ch,(%rdi,%rsi,1)
shl    $0x8,%ecx
movzwl %cx,%eax
mov    0x64(%rsp),%ecx
mov    %ecx,%esi
movslq %ecx,%rdx
cmpl   $0x0,0x70(%rsp)
mov    %rsi,0x88(%rsp)
mov    %rdi,%r10
jle    1868 <LInt_Div2+0x738>
lea    (%r14,%rdx,1),%r9
mov    0xc8(%rsp),%rcx
lea    (%rcx,%rdx,1),%rdi
lea    (%r8,%rsi,1),%ebx
mov    %ebx,0x74(%rsp)
lea    0x2(%rdx),%r13d
lea    (%r8,%rdx,1),%r14d
add    $0x1,%r14d
xor    %ebp,%ebp
mov    %r8,%rbx
mov    %r15,0x58(%rsp)
mov    %rdx,0x50(%rsp)
mov    %r9,0x48(%rsp)
mov    %rdi,0xd0(%rsp)
mov    %r13,0x40(%rsp)
lea    -0x1(%rbx),%rcx
movzbl -0x1(%r9,%rbx,1),%r12d
add    %eax,%r12d
mov    %rbx,0xa0(%rsp)
mov    0x28(%rsp),%rax
movzbl -0x1(%rax,%rbx,1),%esi
imul   %r15d,%esi
mov    %r12d,%eax
sub    %esi,%eax
jae    1700 <LInt_Div2+0x5d0>
mov    %r12d,0x38(%rsp)
mov    %ebp,0x3c(%rsp)
lea    (%rcx,%r13,1),%ebx
cmp    %r11d,%ebx
mov    %r10,%rdi
mov    %rcx,0xd8(%rsp)
ja     1560 <LInt_Div2+0x430>
movslq %r14d,%rbp
lea    (%rdi,%rbp,1),%rcx
lea    -0x1(%rbp),%rax
shl    $0x20,%rbp
mov    0x74(%rsp),%edx
sub    0x3c(%rsp),%edx
add    $0x1,%edx
movslq %edx,%r9
xor    %r12d,%r12d
mov    %r14d,%r15d
xor    %r13d,%r13d
nopl   0x0(%rax,%rax,1)
movzbl (%rcx,%r13,1),%edx
test   %dl,%dl
jne    1710 <LInt_Div2+0x5e0>
add    $0x1,%r13
lea    (%r14,%r13,1),%edx
movabs $0x100000000,%r10
add    %r10,%rbp
add    $0x1,%r15d
add    $0x1,%r12b
cmp    %edx,%r11d
jae    16d0 <LInt_Div2+0x5a0>
jmp    1560 <LInt_Div2+0x430>
mov    %ah,(%rdi,%rcx,1)
mov    0xa0(%rsp),%rbx
jmp    184e <LInt_Div2+0x71e>
lea    (%r14,%r13,1),%edi
add    $0xff,%dl
mov    %dl,(%rcx,%r13,1)
cmp    %edi,%ebx
jge    17a3 <LInt_Div2+0x673>
mov    %ebx,0x68(%rsp)
mov    %esi,0x34(%rsp)
sar    $0x20,%rbp
lea    -0x1(%r13),%edx
mov    %rbp,%rdi
sub    %rdx,%rdi
add    0xb8(%rsp),%rdi
add    $0x1,%rdx
mov    $0xff,%esi
mov    %r9,%rbx
call   1040 <memset@plt>
mov    %rbx,%rcx
not    %rcx
add    %rbp,%rcx
test   $0x7,%r13b
je     17c5 <LInt_Div2+0x695>
movzbl %r12b,%eax
and    $0x7,%eax
xor    %ebp,%ebp
mov    0x40(%rsp),%r13
nop
add    $0x1,%rbp
cmp    %rbp,%rax
jne    1770 <LInt_Div2+0x640>
movslq %r15d,%rax
not    %rbp
add    %rax,%rbp
mov    %rbp,%rax
mov    0x80(%rsp),%r11
mov    0x10(%rsp),%r8
mov    0x20(%rsp),%r10
mov    0x50(%rsp),%rdx
mov    0x48(%rsp),%r9
jmp    17ea <LInt_Div2+0x6ba>
add    %r13,%rax
mov    0x20(%rsp),%r10
mov    0x58(%rsp),%r15
mov    0x50(%rsp),%rdx
mov    0x48(%rsp),%r9
mov    0x40(%rsp),%r13
mov    0x38(%rsp),%ebx
jmp    1820 <LInt_Div2+0x6f0>
add    $0xffffffffffffffff,%rbp
mov    0x80(%rsp),%r11
mov    0x10(%rsp),%r8
mov    0x20(%rsp),%r10
mov    0x50(%rsp),%rdx
mov    0x48(%rsp),%r9
mov    0x40(%rsp),%r13
mov    0x34(%rsp),%esi
cmp    $0x7,%rcx
mov    0x58(%rsp),%r15
mov    0x38(%rsp),%ebx
jb     1820 <LInt_Div2+0x6f0>
movslq 0x68(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x8(%rbp),%rax
add    $0xfffffffffffffff9,%rbp
cmp    %rcx,%rbp
mov    %rax,%rbp
jg     1810 <LInt_Div2+0x6e0>
sub    %esi,%ebx
add    $0x10000,%ebx
cltq
mov    %r10,%rcx
mov    %bh,(%rcx,%rax,1)
mov    %ebx,%eax
mov    0xd0(%rsp),%rdi
mov    0x3c(%rsp),%ebp
mov    0xa0(%rsp),%rbx
mov    0xd8(%rsp),%rcx
shl    $0x8,%eax
movzwl %ax,%eax
add    $0xffffffffffffffff,%r14
add    $0x1,%ebp
cmp    $0x2,%rbx
mov    %rcx,%rbx
jg     1656 <LInt_Div2+0x526>
mov    %r10,%rdi
mov    %ah,0x1(%rdi,%rdx,1)
mov    0x98(%rsp),%r14
mov    %r14d,%eax
sub    %edx,%eax
cmp    %edx,%eax
jle    18c0 <LInt_Div2+0x790>
mov    (%r14),%al
movzbl %al,%ecx
mov    0x88(%rsp),%rbx
cmp    %ecx,%ebx
jge    18f2 <LInt_Div2+0x7c2>
mov    %ebx,%edx
not    %edx
add    %ecx,%edx
sub    %rdx,%rcx
mov    %rdi,%rbp
lea    (%r14,%rcx,1),%rdi
add    %rbp,%rcx
add    $0x1,%rdx
mov    %rcx,%rsi
call   1050 <memcpy@plt>
mov    %rbp,%rcx
mov    %r14,%rdi
jmp    18ea <LInt_Div2+0x7ba>
nopl   0x0(%rax)
mov    0x88(%rsp),%rbx
test   %ebx,%ebx
js     18e7 <LInt_Div2+0x7b7>
mov    %ebx,%edx
add    $0x1,%rdx
mov    0x20(%rsp),%rdi
mov    %r14,%rsi
mov    %r14,%rbp
call   1050 <memcpy@plt>
mov    0x20(%rsp),%rdi
mov    %r14,%rcx
mov    %rdi,%r14
mov    (%rdi),%al
mov    %rcx,%rdi
xor    %edx,%edx
test   %al,%al
je     1472 <LInt_Div2+0x342>
movzbl %al,%eax
nop
mov    %eax,%ecx
cmpb   $0x0,(%r14,%rcx,1)
jne    1470 <LInt_Div2+0x340>
add    $0xffffffff,%eax
jne    1900 <LInt_Div2+0x7d0>
jmp    1472 <LInt_Div2+0x342>
nopw   0x0(%rax,%rax,1)
mov    $0x1,%ebx
mov    %rdi,%r13
jmp    1498 <LInt_Div2+0x368>
add    $0x1,%r11d
cmp    $0x8,%r11d
mov    0x8(%rsp),%rdi
jb     1956 <LInt_Div2+0x826>
lea    (%r14,%r11,1),%rax
cmp    %rdi,%rax
jbe    19d3 <LInt_Div2+0x8a3>
lea    (%rdi,%r11,1),%rax
cmp    %rax,%r14
jae    19d3 <LInt_Div2+0x8a3>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
mov    %r11,%rdx
and    $0x3,%rdx
je     1982 <LInt_Div2+0x852>
nopw   0x0(%rax,%rax,1)
movzbl (%r14,%rax,1),%ebx
mov    %bl,(%rdi,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1970 <LInt_Div2+0x840>
cmp    $0x3,%rcx
jb     19bf <LInt_Div2+0x88f>
nopl   0x0(%rax,%rax,1)
movzbl (%r14,%rax,1),%ecx
mov    %cl,(%rdi,%rax,1)
movzbl 0x1(%r14,%rax,1),%ecx
mov    %cl,0x1(%rdi,%rax,1)
movzbl 0x2(%r14,%rax,1),%ecx
mov    %cl,0x2(%rdi,%rax,1)
movzbl 0x3(%r14,%rax,1),%ecx
mov    %cl,0x3(%rdi,%rax,1)
add    $0x4,%rax
cmp    %rax,%r11
jne    1990 <LInt_Div2+0x860>
xor    %eax,%eax
add    $0x2e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x20,%r11d
jae    19e0 <LInt_Div2+0x8b0>
xor    %eax,%eax
jmp    1ac3 <LInt_Div2+0x993>
mov    %r11d,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rsi
mov    %rsi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x60,%rsi
jae    1a04 <LInt_Div2+0x8d4>
xor    %esi,%esi
jmp    1a70 <LInt_Div2+0x940>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%r14,%rsi,1),%xmm0
movups 0x10(%r14,%rsi,1),%xmm1
movups %xmm0,(%rdi,%rsi,1)
movups %xmm1,0x10(%rdi,%rsi,1)
movups 0x20(%r14,%rsi,1),%xmm0
movups 0x30(%r14,%rsi,1),%xmm1
movups %xmm0,0x20(%rdi,%rsi,1)
movups %xmm1,0x30(%rdi,%rsi,1)
movups 0x40(%r14,%rsi,1),%xmm0
movups 0x50(%r14,%rsi,1),%xmm1
movups %xmm0,0x40(%rdi,%rsi,1)
movups %xmm1,0x50(%rdi,%rsi,1)
movups 0x60(%r14,%rsi,1),%xmm0
movups 0x70(%r14,%rsi,1),%xmm1
movups %xmm0,0x60(%rdi,%rsi,1)
movups %xmm1,0x70(%rdi,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1a10 <LInt_Div2+0x8e0>
test   %rcx,%rcx
je     1aab <LInt_Div2+0x97b>
mov    0x8(%rsp),%rdx
add    %rsi,%rdx
add    $0x10,%rdx
add    %r14,%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
xchg   %ax,%ax
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movups %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1a90 <LInt_Div2+0x960>
cmp    %r11,%rax
je     19bf <LInt_Div2+0x88f>
test   $0x18,%r11b
mov    0x8(%rsp),%rdi
je     1958 <LInt_Div2+0x828>
mov    %rax,%rcx
mov    %r11d,%eax
and    $0xfffffff8,%eax
nopl   0x0(%rax)
mov    (%r14,%rcx,1),%rdx
mov    %rdx,(%rdi,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1ad0 <LInt_Div2+0x9a0>
cmp    %r11,%rax
je     19bf <LInt_Div2+0x88f>
jmp    1958 <LInt_Div2+0x828>

LLVM IR (-O0):
define signext i8 @LInt_Div2(i8* %0, i8* %1, i8* %2, i8* %3) {
%5 = alloca i8
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca [256 x i8]
%11 = alloca [256 x i8]
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i8
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
store i8* %0, i8** %6
store i8* %1, i8** %7
store i8* %2, i8** %8
store i8* %3, i8** %9
%25 = load i8*, i8** %7
%26 = load i8, i8* %25
%27 = zext i8 %26 to i32
store i32 %27, i32* %22
br label %28
28: ; preds = %42, %4
%29 = load i32, i32* %22
%30 = icmp ne i32 %29, 0
br i1 %30, label %31, label %39
31: ; preds = %28
%32 = load i8*, i8** %7
%33 = load i32, i32* %22
%34 = zext i32 %33 to i64
%35 = getelementptr inbounds i8, i8* %32, i64 %34
%36 = load i8, i8* %35
%37 = zext i8 %36 to i32
%38 = icmp eq i32 %37, 0
br label %39
39: ; preds = %31, %28
%40 = phi i1 [ false, %28 ], [ %38, %31 ]
br i1 %40, label %41, label %45
41: ; preds = %39
br label %42
42: ; preds = %41
%43 = load i32, i32* %22
%44 = add i32 %43, -1
store i32 %44, i32* %22
br label %28
45: ; preds = %39
%46 = load i32, i32* %22
%47 = icmp eq i32 %46, 0
br i1 %47, label %48, label %51
48: ; preds = %45
%49 = load i8*, i8** %9
store i8 0, i8* %49
%50 = load i8*, i8** %8
store i8 0, i8* %50
store i8 1, i8* %5
br label %530
51: ; preds = %45
%52 = load i8*, i8** %6
%53 = load i8, i8* %52
%54 = zext i8 %53 to i32
store i32 %54, i32* %23
br label %55
55: ; preds = %69, %51
%56 = load i32, i32* %23
%57 = icmp ne i32 %56, 0
br i1 %57, label %58, label %66
58: ; preds = %55
%59 = load i8*, i8** %6
%60 = load i32, i32* %23
%61 = zext i32 %60 to i64
%62 = getelementptr inbounds i8, i8* %59, i64 %61
%63 = load i8, i8* %62
%64 = zext i8 %63 to i32
%65 = icmp eq i32 %64, 0
br label %66
66: ; preds = %58, %55
%67 = phi i1 [ false, %55 ], [ %65, %58 ]
br i1 %67, label %68, label %72
68: ; preds = %66
br label %69
69: ; preds = %68
%70 = load i32, i32* %23
%71 = add i32 %70, -1
store i32 %71, i32* %23
br label %55
72: ; preds = %66
%73 = load i8*, i8** %8
store i8 0, i8* %73
store i32 1, i32* %16
br label %74
74: ; preds = %88, %72
%75 = load i32, i32* %16
%76 = load i32, i32* %23
%77 = icmp ule i32 %75, %76
br i1 %77, label %78, label %91
78: ; preds = %74
%79 = load i8*, i8** %6
%80 = load i32, i32* %16
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i8, i8* %79, i64 %81
%83 = load i8, i8* %82
%84 = load i8*, i8** %9
%85 = load i32, i32* %16
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i8, i8* %84, i64 %86
store i8 %83, i8* %87
br label %88
88: ; preds = %78
%89 = load i32, i32* %16
%90 = add nsw i32 %89, 1
store i32 %90, i32* %16
br label %74
91: ; preds = %74
%92 = load i32, i32* %23
%93 = trunc i32 %92 to i8
%94 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 0
store i8 %93, i8* %94
%95 = load i32, i32* %23
%96 = load i32, i32* %22
%97 = icmp ult i32 %95, %96
br i1 %97, label %116, label %98
98: ; preds = %91
%99 = load i32, i32* %23
%100 = load i32, i32* %22
%101 = icmp eq i32 %99, %100
br i1 %101, label %102, label %134
102: ; preds = %98
%103 = load i8*, i8** %6
%104 = load i32, i32* %23
%105 = zext i32 %104 to i64
%106 = getelementptr inbounds i8, i8* %103, i64 %105
%107 = load i8, i8* %106
%108 = zext i8 %107 to i32
%109 = load i8*, i8** %7
%110 = load i32, i32* %22
%111 = zext i32 %110 to i64
%112 = getelementptr inbounds i8, i8* %109, i64 %111
%113 = load i8, i8* %112
%114 = zext i8 %113 to i32
%115 = icmp slt i32 %108, %114
br i1 %115, label %116, label %134
116: ; preds = %102, %91
store i32 0, i32* %16
br label %117
117: ; preds = %130, %116
%118 = load i32, i32* %16
%119 = load i32, i32* %23
%120 = icmp ule i32 %118, %119
br i1 %120, label %121, label %133
121: ; preds = %117
%122 = load i32, i32* %16
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %123
%125 = load i8, i8* %124
%126 = load i8*, i8** %9
%127 = load i32, i32* %16
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i8, i8* %126, i64 %128
store i8 %125, i8* %129
br label %130
130: ; preds = %121
%131 = load i32, i32* %16
%132 = add nsw i32 %131, 1
store i32 %132, i32* %16
br label %117
133: ; preds = %117
store i8 0, i8* %5
br label %530
134: ; preds = %102, %98
%135 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 0
store i8* %135, i8** %12
%136 = getelementptr inbounds [256 x i8], [256 x i8]* %11, i64 0, i64 0
store i8* %136, i8** %13
br label %137
137: ; preds = %507, %134
%138 = load i8*, i8** %12
%139 = load i32, i32* %23
%140 = zext i32 %139 to i64
%141 = getelementptr inbounds i8, i8* %138, i64 %140
%142 = load i8, i8* %141
%143 = zext i8 %142 to i32
%144 = load i8*, i8** %7
%145 = load i32, i32* %22
%146 = zext i32 %145 to i64
%147 = getelementptr inbounds i8, i8* %144, i64 %146
%148 = load i8, i8* %147
%149 = zext i8 %148 to i32
%150 = add nsw i32 %149, 1
%151 = sdiv i32 %143, %150
store i32 %151, i32* %24
%152 = load i8*, i8** %12
%153 = load i32, i32* %23
%154 = zext i32 %153 to i64
%155 = getelementptr inbounds i8, i8* %152, i64 %154
%156 = load i8, i8* %155
%157 = zext i8 %156 to i32
%158 = load i8*, i8** %7
%159 = load i32, i32* %22
%160 = zext i32 %159 to i64
%161 = getelementptr inbounds i8, i8* %158, i64 %160
%162 = load i8, i8* %161
%163 = zext i8 %162 to i32
%164 = sdiv i32 %157, %163
store i32 %164, i32* %21
store i8 0, i8* %15
br label %165
165: ; preds = %502, %137
%166 = load i32, i32* %21
%167 = icmp ne i32 %166, 0
br i1 %167, label %168, label %191
168: ; preds = %165
%169 = load i32, i32* %23
%170 = load i32, i32* %22
%171 = sub i32 %169, %170
store i32 %171, i32* %18
%172 = load i8*, i8** %12
%173 = load i32, i32* %23
%174 = zext i32 %173 to i64
%175 = getelementptr inbounds i8, i8* %172, i64 %174
%176 = load i8, i8* %175
%177 = zext i8 %176 to i32
store i32 %177, i32* %19
%178 = load i8*, i8** %7
%179 = load i32, i32* %22
%180 = zext i32 %179 to i64
%181 = getelementptr inbounds i8, i8* %178, i64 %180
%182 = load i8, i8* %181
%183 = zext i8 %182 to i32
%184 = load i32, i32* %21
%185 = mul i32 %183, %184
store i32 %185, i32* %20
%186 = load i32, i32* %20
%187 = load i32, i32* %19
%188 = sub i32 %187, %186
store i32 %188, i32* %19
%189 = load i32, i32* %19
%190 = shl i32 %189, 8
store i32 %190, i32* %19
br label %241
191: ; preds = %165
%192 = load i32, i32* %23
%193 = load i32, i32* %22
%194 = icmp eq i32 %192, %193
br i1 %194, label %195, label %196
195: ; preds = %191
store i8 2, i8* %15
br label %240
196: ; preds = %191
%197 = load i8*, i8** %12
%198 = load i32, i32* %23
%199 = zext i32 %198 to i64
%200 = getelementptr inbounds i8, i8* %197, i64 %199
%201 = getelementptr inbounds i8, i8* %200, i64 -1
%202 = bitcast i8* %201 to i16*
%203 = load i16, i16* %202
%204 = zext i16 %203 to i32
store i32 %204, i32* %21
%205 = load i32, i32* %21
store i32 %205, i32* %19
%206 = load i8*, i8** %7
%207 = load i32, i32* %22
%208 = zext i32 %207 to i64
%209 = getelementptr inbounds i8, i8* %206, i64 %208
%210 = load i8, i8* %209
%211 = zext i8 %210 to i32
%212 = add nsw i32 %211, 1
%213 = load i32, i32* %21
%214 = udiv i32 %213, %212
store i32 %214, i32* %21
%215 = load i32, i32* %23
%216 = load i32, i32* %22
%217 = sub i32 %215, %216
%218 = sub i32 %217, 1
store i32 %218, i32* %18
%219 = load i8*, i8** %7
%220 = load i32, i32* %22
%221 = zext i32 %220 to i64
%222 = getelementptr inbounds i8, i8* %219, i64 %221
%223 = load i8, i8* %222
%224 = zext i8 %223 to i32
%225 = load i32, i32* %21
%226 = mul i32 %224, %225
store i32 %226, i32* %20
%227 = load i32, i32* %20
%228 = load i32, i32* %19
%229 = sub i32 %228, %227
store i32 %229, i32* %19
%230 = load i32, i32* %19
%231 = lshr i32 %230, 8
%232 = trunc i32 %231 to i8
%233 = load i8*, i8** %13
%234 = load i32, i32* %23
%235 = zext i32 %234 to i64
%236 = getelementptr inbounds i8, i8* %233, i64 %235
store i8 %232, i8* %236
%237 = load i32, i32* %19
%238 = and i32 %237, 255
%239 = shl i32 %238, 8
store i32 %239, i32* %19
br label %240
240: ; preds = %196, %195
br label %241
241: ; preds = %240, %168
%242 = load i8, i8* %15
%243 = zext i8 %242 to i32
%244 = icmp eq i32 %243, 1
br i1 %244, label %245, label %246
245: ; preds = %241
store i8 0, i8* %15
br label %246
246: ; preds = %245, %241
%247 = load i32, i32* %22
%248 = sub i32 %247, 1
store i32 %248, i32* %16
br label %249
249: ; preds = %378, %246
%250 = load i32, i32* %16
%251 = icmp sgt i32 %250, 0
br i1 %251, label %252, label %256
252: ; preds = %249
%253 = load i8, i8* %15
%254 = zext i8 %253 to i32
%255 = icmp eq i32 %254, 0
br label %256
256: ; preds = %252, %249
%257 = phi i1 [ false, %249 ], [ %255, %252 ]
br i1 %257, label %258, label %381
258: ; preds = %256
%259 = load i8*, i8** %12
%260 = load i32, i32* %16
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds i8, i8* %259, i64 %261
%263 = load i32, i32* %18
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds i8, i8* %262, i64 %264
%266 = load i8, i8* %265
%267 = zext i8 %266 to i32
%268 = load i32, i32* %19
%269 = add i32 %268, %267
store i32 %269, i32* %19
%270 = load i8*, i8** %7
%271 = load i32, i32* %16
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds i8, i8* %270, i64 %272
%274 = load i8, i8* %273
%275 = zext i8 %274 to i32
%276 = load i32, i32* %21
%277 = mul i32 %275, %276
store i32 %277, i32* %20
%278 = load i32, i32* %19
%279 = load i32, i32* %20
%280 = icmp uge i32 %278, %279
br i1 %280, label %281, label %299
281: ; preds = %258
%282 = load i32, i32* %20
%283 = load i32, i32* %19
%284 = sub i32 %283, %282
store i32 %284, i32* %19
%285 = load i32, i32* %19
%286 = lshr i32 %285, 8
%287 = trunc i32 %286 to i8
%288 = load i8*, i8** %13
%289 = load i32, i32* %16
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds i8, i8* %288, i64 %290
%292 = load i32, i32* %18
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds i8, i8* %291, i64 %293
%295 = getelementptr inbounds i8, i8* %294, i64 1
store i8 %287, i8* %295
%296 = load i32, i32* %19
%297 = and i32 %296, 255
%298 = shl i32 %297, 8
store i32 %298, i32* %19
br label %377
299: ; preds = %258
%300 = load i32, i32* %16
%301 = load i32, i32* %18
%302 = add nsw i32 %300, %301
%303 = add nsw i32 %302, 2
store i32 %303, i32* %17
br label %304
304: ; preds = %319, %299
%305 = load i32, i32* %17
%306 = load i32, i32* %23
%307 = icmp ule i32 %305, %306
br i1 %307, label %308, label %316
308: ; preds = %304
%309 = load i8*, i8** %13
%310 = load i32, i32* %17
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds i8, i8* %309, i64 %311
%313 = load i8, i8* %312
%314 = zext i8 %313 to i32
%315 = icmp eq i32 %314, 0
br label %316
316: ; preds = %308, %304
%317 = phi i1 [ false, %304 ], [ %315, %308 ]
br i1 %317, label %318, label %322
318: ; preds = %316
br label %319
319: ; preds = %318
%320 = load i32, i32* %17
%321 = add nsw i32 %320, 1
store i32 %321, i32* %17
br label %304
322: ; preds = %316
%323 = load i32, i32* %17
%324 = load i32, i32* %23
%325 = icmp ule i32 %323, %324
br i1 %325, label %326, label %368
326: ; preds = %322
%327 = load i8*, i8** %13
%328 = load i32, i32* %17
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds i8, i8* %327, i64 %329
%331 = load i8, i8* %330
%332 = zext i8 %331 to i32
%333 = sub nsw i32 %332, 1
%334 = trunc i32 %333 to i8
store i8 %334, i8* %330
%335 = load i32, i32* %17
%336 = add nsw i32 %335, -1
store i32 %336, i32* %17
br label %337
337: ; preds = %349, %326
%338 = load i32, i32* %17
%339 = load i32, i32* %16
%340 = load i32, i32* %18
%341 = add nsw i32 %339, %340
%342 = add nsw i32 %341, 2
%343 = icmp sge i32 %338, %342
br i1 %343, label %344, label %352
344: ; preds = %337
%345 = load i8*, i8** %13
%346 = load i32, i32* %17
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds i8, i8* %345, i64 %347
store i8 -1, i8* %348
br label %349
349: ; preds = %344
%350 = load i32, i32* %17
%351 = add nsw i32 %350, -1
store i32 %351, i32* %17
br label %337
352: ; preds = %337
%353 = load i32, i32* %20
%354 = sub i32 65535, %353
%355 = add i32 %354, 1
%356 = load i32, i32* %19
%357 = add i32 %356, %355
store i32 %357, i32* %19
%358 = load i32, i32* %19
%359 = lshr i32 %358, 8
%360 = trunc i32 %359 to i8
%361 = load i8*, i8** %13
%362 = load i32, i32* %17
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds i8, i8* %361, i64 %363
store i8 %360, i8* %364
%365 = load i32, i32* %19
%366 = and i32 %365, 255
%367 = shl i32 %366, 8
store i32 %367, i32* %19
br label %376
368: ; preds = %322
%369 = load i32, i32* %21
%370 = load i32, i32* %24
%371 = sub i32 %369, %370
%372 = add i32 %371, 1
%373 = lshr i32 %372, 1
%374 = load i32, i32* %21
%375 = sub i32 %374, %373
store i32 %375, i32* %21
store i8 1, i8* %15
br label %376
376: ; preds = %368, %352
br label %377
377: ; preds = %376, %281
br label %378
378: ; preds = %377
%379 = load i32, i32* %16
%380 = add nsw i32 %379, -1
store i32 %380, i32* %16
br label %249
381: ; preds = %256
%382 = load i8, i8* %15
%383 = zext i8 %382 to i32
%384 = icmp eq i32 %383, 0
br i1 %384, label %385, label %501
385: ; preds = %381
%386 = load i32, i32* %19
%387 = lshr i32 %386, 8
%388 = trunc i32 %387 to i8
%389 = load i8*, i8** %13
%390 = load i32, i32* %18
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds i8, i8* %389, i64 %391
%393 = getelementptr inbounds i8, i8* %392, i64 1
store i8 %388, i8* %393
%394 = load i8*, i8** %12
%395 = ptrtoint i8* %394 to i32
%396 = load i32, i32* %18
%397 = sub nsw i32 %395, %396
%398 = load i32, i32* %18
%399 = icmp sle i32 %397, %398
br i1 %399, label %400, label %422
400: ; preds = %385
%401 = load i32, i32* %18
store i32 %401, i32* %16
br label %402
402: ; preds = %415, %400
%403 = load i32, i32* %16
%404 = icmp sge i32 %403, 0
br i1 %404, label %405, label %418
405: ; preds = %402
%406 = load i8*, i8** %12
%407 = load i32, i32* %16
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i8, i8* %406, i64 %408
%410 = load i8, i8* %409
%411 = load i8*, i8** %13
%412 = load i32, i32* %16
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds i8, i8* %411, i64 %413
store i8 %410, i8* %414
br label %415
415: ; preds = %405
%416 = load i32, i32* %16
%417 = add nsw i32 %416, -1
store i32 %417, i32* %16
br label %402
418: ; preds = %402
%419 = load i8*, i8** %13
store i8* %419, i8** %14
%420 = load i8*, i8** %12
store i8* %420, i8** %13
%421 = load i8*, i8** %14
store i8* %421, i8** %12
br label %444
422: ; preds = %385
%423 = load i8*, i8** %12
%424 = load i8, i8* %423
%425 = zext i8 %424 to i32
store i32 %425, i32* %16
br label %426
426: ; preds = %440, %422
%427 = load i32, i32* %16
%428 = load i32, i32* %18
%429 = icmp sgt i32 %427, %428
br i1 %429, label %430, label %443
430: ; preds = %426
%431 = load i8*, i8** %13
%432 = load i32, i32* %16
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds i8, i8* %431, i64 %433
%435 = load i8, i8* %434
%436 = load i8*, i8** %12
%437 = load i32, i32* %16
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds i8, i8* %436, i64 %438
store i8 %435, i8* %439
br label %440
440: ; preds = %430
%441 = load i32, i32* %16
%442 = add nsw i32 %441, -1
store i32 %442, i32* %16
br label %426
443: ; preds = %426
br label %444
444: ; preds = %443, %418
%445 = load i8*, i8** %12
%446 = load i8, i8* %445
%447 = zext i8 %446 to i32
store i32 %447, i32* %23
br label %448
448: ; preds = %462, %444
%449 = load i32, i32* %23
%450 = icmp ne i32 %449, 0
br i1 %450, label %451, label %459
451: ; preds = %448
%452 = load i8*, i8** %12
%453 = load i32, i32* %23
%454 = zext i32 %453 to i64
%455 = getelementptr inbounds i8, i8* %452, i64 %454
%456 = load i8, i8* %455
%457 = zext i8 %456 to i32
%458 = icmp eq i32 %457, 0
br label %459
459: ; preds = %451, %448
%460 = phi i1 [ false, %448 ], [ %458, %451 ]
br i1 %460, label %461, label %465
461: ; preds = %459
br label %462
462: ; preds = %461
%463 = load i32, i32* %23
%464 = add i32 %463, -1
store i32 %464, i32* %23
br label %448
465: ; preds = %459
%466 = load i32, i32* %23
%467 = trunc i32 %466 to i8
%468 = load i8*, i8** %12
store i8 %467, i8* %468
%469 = load i32, i32* %18
%470 = add nsw i32 %469, 1
%471 = trunc i32 %470 to i8
%472 = load i8*, i8** %13
store i8 %471, i8* %472
store i32 1, i32* %16
br label %473
473: ; preds = %482, %465
%474 = load i32, i32* %16
%475 = load i32, i32* %18
%476 = icmp sle i32 %474, %475
br i1 %476, label %477, label %485
477: ; preds = %473
%478 = load i8*, i8** %13
%479 = load i32, i32* %16
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds i8, i8* %478, i64 %480
store i8 0, i8* %481
br label %482
482: ; preds = %477
%483 = load i32, i32* %16
%484 = add nsw i32 %483, 1
store i32 %484, i32* %16
br label %473
485: ; preds = %473
%486 = load i32, i32* %21
%487 = trunc i32 %486 to i8
%488 = load i8*, i8** %13
%489 = load i32, i32* %16
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds i8, i8* %488, i64 %490
store i8 %487, i8* %491
%492 = load i8*, i8** %8
%493 = load i8*, i8** %13
%494 = call signext i8 @LInt_Add(i8* %492, i8* %493)
%495 = load i32, i32* %23
%496 = load i32, i32* %22
%497 = icmp uge i32 %495, %496
br i1 %497, label %498, label %499
498: ; preds = %485
store i8 0, i8* %15
br label %500
499: ; preds = %485
store i8 2, i8* %15
br label %500
500: ; preds = %499, %498
br label %501
501: ; preds = %500, %381
br label %502
502: ; preds = %501
%503 = load i8, i8* %15
%504 = zext i8 %503 to i32
%505 = icmp eq i32 %504, 1
br i1 %505, label %165, label %506
506: ; preds = %502
br label %507
507: ; preds = %506
%508 = load i8, i8* %15
%509 = zext i8 %508 to i32
%510 = icmp eq i32 %509, 0
br i1 %510, label %137, label %511
511: ; preds = %507
store i32 0, i32* %16
br label %512
512: ; preds = %526, %511
%513 = load i32, i32* %16
%514 = load i32, i32* %23
%515 = icmp ule i32 %513, %514
br i1 %515, label %516, label %529
516: ; preds = %512
%517 = load i8*, i8** %12
%518 = load i32, i32* %16
%519 = sext i32 %518 to i64
%520 = getelementptr inbounds i8, i8* %517, i64 %519
%521 = load i8, i8* %520
%522 = load i8*, i8** %9
%523 = load i32, i32* %16
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds i8, i8* %522, i64 %524
store i8 %521, i8* %525
br label %526
526: ; preds = %516
%527 = load i32, i32* %16
%528 = add nsw i32 %527, 1
store i32 %528, i32* %16
br label %512
529: ; preds = %512
store i8 0, i8* %5
br label %530
530: ; preds = %529, %133, %48
%531 = load i8, i8* %5
ret i8 %531
}

LLVM IR (-O2):
define signext i8 @LInt_Div2(i8* nocapture %0, i8* nocapture %1, i8* %2, i8* nocapture writeonly %3) {
%5 = alloca [256 x i8]
%6 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 0
%7 = alloca [256 x i8]
%8 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 0
%9 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%10 = load i8, i8* %1
%11 = icmp eq i8 %10, 0
br i1 %11, label %23, label %12
12: ; preds = %4
%13 = zext i8 %10 to i32
br label %14
14: ; preds = %12, %20
%15 = phi i32 [ %21, %20 ], [ %13, %12 ]
%16 = zext i32 %15 to i64
%17 = getelementptr inbounds i8, i8* %1, i64 %16
%18 = load i8, i8* %17
%19 = icmp eq i8 %18, 0
br i1 %19, label %20, label %24
20: ; preds = %14
%21 = add nsw i32 %15, -1
%22 = icmp eq i32 %21, 0
br i1 %22, label %23, label %14
23: ; preds = %20, %4
store i8 0, i8* %3
store i8 0, i8* %2
br label %592
24: ; preds = %14
%25 = zext i32 %15 to i64
%26 = getelementptr inbounds i8, i8* %1, i64 %25
%27 = load i8, i8* %0
%28 = icmp eq i8 %27, 0
br i1 %28, label %40, label %29
29: ; preds = %24
%30 = zext i8 %27 to i32
br label %31
31: ; preds = %29, %37
%32 = phi i32 [ %38, %37 ], [ %30, %29 ]
%33 = zext i32 %32 to i64
%34 = getelementptr inbounds i8, i8* %0, i64 %33
%35 = load i8, i8* %34
%36 = icmp eq i8 %35, 0
br i1 %36, label %37, label %41
37: ; preds = %31
%38 = add nsw i32 %32, -1
%39 = icmp eq i32 %38, 0
br i1 %39, label %40, label %31
40: ; preds = %37, %24
store i8 0, i8* %2
br label %198
41: ; preds = %31
store i8 0, i8* %2
%42 = icmp eq i32 %32, 0
br i1 %42, label %198, label %43
43: ; preds = %41
%44 = add nsw i32 %32, 1
%45 = zext i32 %44 to i64
%46 = add nsw i64 %45, -1
%47 = icmp ult i64 %46, 8
br i1 %47, label %160, label %48
48: ; preds = %43
%49 = getelementptr i8, i8* %3, i64 1
%50 = getelementptr i8, i8* %3, i64 %45
%51 = getelementptr i8, i8* %0, i64 1
%52 = getelementptr i8, i8* %0, i64 %45
%53 = icmp ult i8* %49, %52
%54 = icmp ult i8* %51, %50
%55 = and i1 %53, %54
br i1 %55, label %160, label %56
56: ; preds = %48
%57 = icmp ult i64 %46, 32
br i1 %57, label %143, label %58
58: ; preds = %56
%59 = and i64 %46, -32
%60 = add nsw i64 %59, -32
%61 = lshr exact i64 %60, 5
%62 = add nuw nsw i64 %61, 1
%63 = and i64 %62, 3
%64 = icmp ult i64 %60, 96
br i1 %64, label %117, label %65
65: ; preds = %58
%66 = and i64 %62, 1152921504606846972
br label %67
67: ; preds = %67, %65
%68 = phi i64 [ 0, %65 ], [ %114, %67 ]
%69 = phi i64 [ 0, %65 ], [ %115, %67 ]
%70 = or i64 %68, 1
%71 = getelementptr inbounds i8, i8* %0, i64 %70
%72 = bitcast i8* %71 to <16 x i8>*
%73 = load <16 x i8>, <16 x i8>* %72
%74 = getelementptr inbounds i8, i8* %71, i64 16
%75 = bitcast i8* %74 to <16 x i8>*
%76 = load <16 x i8>, <16 x i8>* %75
%77 = getelementptr inbounds i8, i8* %3, i64 %70
%78 = bitcast i8* %77 to <16 x i8>*
store <16 x i8> %73, <16 x i8>* %78
%79 = getelementptr inbounds i8, i8* %77, i64 16
%80 = bitcast i8* %79 to <16 x i8>*
store <16 x i8> %76, <16 x i8>* %80
%81 = or i64 %68, 33
%82 = getelementptr inbounds i8, i8* %0, i64 %81
%83 = bitcast i8* %82 to <16 x i8>*
%84 = load <16 x i8>, <16 x i8>* %83
%85 = getelementptr inbounds i8, i8* %82, i64 16
%86 = bitcast i8* %85 to <16 x i8>*
%87 = load <16 x i8>, <16 x i8>* %86
%88 = getelementptr inbounds i8, i8* %3, i64 %81
%89 = bitcast i8* %88 to <16 x i8>*
store <16 x i8> %84, <16 x i8>* %89
%90 = getelementptr inbounds i8, i8* %88, i64 16
%91 = bitcast i8* %90 to <16 x i8>*
store <16 x i8> %87, <16 x i8>* %91
%92 = or i64 %68, 65
%93 = getelementptr inbounds i8, i8* %0, i64 %92
%94 = bitcast i8* %93 to <16 x i8>*
%95 = load <16 x i8>, <16 x i8>* %94
%96 = getelementptr inbounds i8, i8* %93, i64 16
%97 = bitcast i8* %96 to <16 x i8>*
%98 = load <16 x i8>, <16 x i8>* %97
%99 = getelementptr inbounds i8, i8* %3, i64 %92
%100 = bitcast i8* %99 to <16 x i8>*
store <16 x i8> %95, <16 x i8>* %100
%101 = getelementptr inbounds i8, i8* %99, i64 16
%102 = bitcast i8* %101 to <16 x i8>*
store <16 x i8> %98, <16 x i8>* %102
%103 = or i64 %68, 97
%104 = getelementptr inbounds i8, i8* %0, i64 %103
%105 = bitcast i8* %104 to <16 x i8>*
%106 = load <16 x i8>, <16 x i8>* %105
%107 = getelementptr inbounds i8, i8* %104, i64 16
%108 = bitcast i8* %107 to <16 x i8>*
%109 = load <16 x i8>, <16 x i8>* %108
%110 = getelementptr inbounds i8, i8* %3, i64 %103
%111 = bitcast i8* %110 to <16 x i8>*
store <16 x i8> %106, <16 x i8>* %111
%112 = getelementptr inbounds i8, i8* %110, i64 16
%113 = bitcast i8* %112 to <16 x i8>*
store <16 x i8> %109, <16 x i8>* %113
%114 = add nuw i64 %68, 128
%115 = add i64 %69, 4
%116 = icmp eq i64 %115, %66
br i1 %116, label %117, label %67
117: ; preds = %67, %58
%118 = phi i64 [ 0, %58 ], [ %114, %67 ]
%119 = icmp eq i64 %63, 0
br i1 %119, label %137, label %120
120: ; preds = %117, %120
%121 = phi i64 [ %134, %120 ], [ %118, %117 ]
%122 = phi i64 [ %135, %120 ], [ 0, %117 ]
%123 = or i64 %121, 1
%124 = getelementptr inbounds i8, i8* %0, i64 %123
%125 = bitcast i8* %124 to <16 x i8>*
%126 = load <16 x i8>, <16 x i8>* %125
%127 = getelementptr inbounds i8, i8* %124, i64 16
%128 = bitcast i8* %127 to <16 x i8>*
%129 = load <16 x i8>, <16 x i8>* %128
%130 = getelementptr inbounds i8, i8* %3, i64 %123
%131 = bitcast i8* %130 to <16 x i8>*
store <16 x i8> %126, <16 x i8>* %131
%132 = getelementptr inbounds i8, i8* %130, i64 16
%133 = bitcast i8* %132 to <16 x i8>*
store <16 x i8> %129, <16 x i8>* %133
%134 = add nuw i64 %121, 32
%135 = add i64 %122, 1
%136 = icmp eq i64 %135, %63
br i1 %136, label %137, label %120
137: ; preds = %120, %117
%138 = icmp eq i64 %46, %59
br i1 %138, label %198, label %139
139: ; preds = %137
%140 = or i64 %59, 1
%141 = and i64 %46, 24
%142 = icmp eq i64 %141, 0
br i1 %142, label %160, label %143
143: ; preds = %56, %139
%144 = phi i64 [ %59, %139 ], [ 0, %56 ]
%145 = add nsw i64 %45, -1
%146 = and i64 %145, -8
%147 = or i64 %146, 1
br label %148
148: ; preds = %148, %143
%149 = phi i64 [ %144, %143 ], [ %156, %148 ]
%150 = or i64 %149, 1
%151 = getelementptr inbounds i8, i8* %0, i64 %150
%152 = bitcast i8* %151 to <8 x i8>*
%153 = load <8 x i8>, <8 x i8>* %152
%154 = getelementptr inbounds i8, i8* %3, i64 %150
%155 = bitcast i8* %154 to <8 x i8>*
store <8 x i8> %153, <8 x i8>* %155
%156 = add nuw i64 %149, 8
%157 = icmp eq i64 %156, %146
br i1 %157, label %158, label %148
158: ; preds = %148
%159 = icmp eq i64 %145, %146
br i1 %159, label %198, label %160
160: ; preds = %48, %43, %139, %158
%161 = phi i64 [ 1, %43 ], [ 1, %48 ], [ %140, %139 ], [ %147, %158 ]
%162 = sub nsw i64 %45, %161
%163 = xor i64 %161, -1
%164 = add nsw i64 %163, %45
%165 = and i64 %162, 3
%166 = icmp eq i64 %165, 0
br i1 %166, label %176, label %167
167: ; preds = %160, %167
%168 = phi i64 [ %173, %167 ], [ %161, %160 ]
%169 = phi i64 [ %174, %167 ], [ 0, %160 ]
%170 = getelementptr inbounds i8, i8* %0, i64 %168
%171 = load i8, i8* %170
%172 = getelementptr inbounds i8, i8* %3, i64 %168
store i8 %171, i8* %172
%173 = add nuw nsw i64 %168, 1
%174 = add i64 %169, 1
%175 = icmp eq i64 %174, %165
br i1 %175, label %176, label %167
176: ; preds = %167, %160
%177 = phi i64 [ %161, %160 ], [ %173, %167 ]
%178 = icmp ult i64 %164, 3
br i1 %178, label %198, label %179
179: ; preds = %176, %179
%180 = phi i64 [ %196, %179 ], [ %177, %176 ]
%181 = getelementptr inbounds i8, i8* %0, i64 %180
%182 = load i8, i8* %181
%183 = getelementptr inbounds i8, i8* %3, i64 %180
store i8 %182, i8* %183
%184 = add nuw nsw i64 %180, 1
%185 = getelementptr inbounds i8, i8* %0, i64 %184
%186 = load i8, i8* %185
%187 = getelementptr inbounds i8, i8* %3, i64 %184
store i8 %186, i8* %187
%188 = add nuw nsw i64 %180, 2
%189 = getelementptr inbounds i8, i8* %0, i64 %188
%190 = load i8, i8* %189
%191 = getelementptr inbounds i8, i8* %3, i64 %188
store i8 %190, i8* %191
%192 = add nuw nsw i64 %180, 3
%193 = getelementptr inbounds i8, i8* %0, i64 %192
%194 = load i8, i8* %193
%195 = getelementptr inbounds i8, i8* %3, i64 %192
store i8 %194, i8* %195
%196 = add nuw nsw i64 %180, 4
%197 = icmp eq i64 %196, %45
br i1 %197, label %198, label %179
198: ; preds = %176, %179, %137, %158, %40, %41
%199 = phi i32 [ 0, %40 ], [ 0, %41 ], [ %32, %158 ], [ %32, %137 ], [ %32, %179 ], [ %32, %176 ]
%200 = trunc i32 %199 to i8
store i8 %200, i8* %8
%201 = icmp ult i32 %199, %15
br i1 %201, label %209, label %202
202: ; preds = %198
%203 = icmp eq i32 %199, %15
br i1 %203, label %204, label %212
204: ; preds = %202
%205 = getelementptr inbounds i8, i8* %0, i64 %25
%206 = load i8, i8* %205
%207 = load i8, i8* %26
%208 = icmp ult i8 %206, %207
br i1 %208, label %209, label %212
209: ; preds = %204, %198
%210 = zext i32 %199 to i64
%211 = add nuw nsw i64 %210, 1
br label %592
212: ; preds = %204, %202
%213 = add i32 %15, -1
%214 = icmp sgt i32 %213, 0
%215 = xor i32 %15, -1
%216 = add i32 %15, 1
%217 = sext i32 %15 to i64
br label %218
218: ; preds = %438, %212
%219 = phi i8* [ %9, %212 ], [ %414, %438 ]
%220 = phi i8* [ %8, %212 ], [ %415, %438 ]
%221 = phi i32 [ %199, %212 ], [ %429, %438 ]
%222 = zext i32 %221 to i64
%223 = getelementptr inbounds i8, i8* %220, i64 %222
%224 = load i8, i8* %223
%225 = load i8, i8* %26
%226 = zext i8 %224 to i16
%227 = zext i8 %225 to i16
%228 = add nuw nsw i16 %227, 1
%229 = udiv i16 %226, %228
%230 = zext i16 %229 to i32
%231 = udiv i8 %224, %225
%232 = zext i8 %231 to i32
%233 = sub nsw i32 1, %230
%234 = sub i32 %221, %15
%235 = zext i32 %221 to i64
%236 = getelementptr inbounds i8, i8* %220, i64 %235
%237 = icmp eq i32 %221, %15
%238 = zext i32 %221 to i64
%239 = getelementptr inbounds i8, i8* %220, i64 -1
%240 = getelementptr inbounds i8, i8* %239, i64 %238
%241 = bitcast i8* %240 to i16*
%242 = add i32 %221, %215
%243 = getelementptr inbounds i8, i8* %219, i64 %238
%244 = getelementptr i8, i8* %219, i64 -1
%245 = getelementptr inbounds i8, i8* %219, i64 1
br label %246
246: ; preds = %368, %218
%247 = phi i32 [ %232, %218 ], [ %371, %368 ]
%248 = icmp eq i32 %247, 0
br i1 %248, label %257, label %249
249: ; preds = %246
%250 = load i8, i8* %236
%251 = zext i8 %250 to i32
%252 = load i8, i8* %26
%253 = zext i8 %252 to i32
%254 = mul i32 %247, %253
%255 = sub i32 %251, %254
%256 = shl i32 %255, 8
br label %273
257: ; preds = %246
br i1 %237, label %445, label %258
258: ; preds = %257
%259 = load i16, i16* %241
%260 = zext i16 %259 to i32
%261 = load i8, i8* %26
%262 = zext i8 %261 to i32
%263 = zext i8 %261 to i16
%264 = add nuw nsw i16 %263, 1
%265 = udiv i16 %259, %264
%266 = zext i16 %265 to i32
%267 = mul nuw nsw i32 %266, %262
%268 = sub nsw i32 %260, %267
%269 = lshr i32 %268, 8
%270 = trunc i32 %269 to i8
store i8 %270, i8* %243
%271 = shl i32 %268, 8
%272 = and i32 %271, 65280
br label %273
273: ; preds = %249, %258
%274 = phi i32 [ %247, %249 ], [ %266, %258 ]
%275 = phi i32 [ %256, %249 ], [ %272, %258 ]
%276 = phi i32 [ %234, %249 ], [ %242, %258 ]
br i1 %214, label %277, label %379
277: ; preds = %273
%278 = sext i32 %276 to i64
%279 = add i32 %276, 2
%280 = add i32 %216, %276
%281 = add i32 %15, %276
%282 = sub i32 -2, %281
%283 = getelementptr inbounds i8, i8* %220, i64 %278
%284 = getelementptr inbounds i8, i8* %245, i64 %278
br label %285
285: ; preds = %277, %372
%286 = phi i64 [ %217, %277 ], [ %292, %372 ]
%287 = phi i32 [ 0, %277 ], [ %378, %372 ]
%288 = phi i32 [ %280, %277 ], [ %377, %372 ]
%289 = phi i32 [ %275, %277 ], [ %375, %372 ]
%290 = sub i32 %280, %287
%291 = sext i32 %290 to i64
%292 = add nsw i64 %286, -1
%293 = add i32 %282, %287
%294 = getelementptr inbounds i8, i8* %283, i64 %292
%295 = load i8, i8* %294
%296 = zext i8 %295 to i32
%297 = add i32 %289, %296
%298 = getelementptr inbounds i8, i8* %1, i64 %292
%299 = load i8, i8* %298
%300 = zext i8 %299 to i32
%301 = mul i32 %274, %300
%302 = icmp ult i32 %297, %301
br i1 %302, label %308, label %303
303: ; preds = %285
%304 = sub i32 %297, %301
%305 = lshr i32 %304, 8
%306 = trunc i32 %305 to i8
%307 = getelementptr inbounds i8, i8* %284, i64 %292
store i8 %306, i8* %307
br label %372
308: ; preds = %285
%309 = trunc i64 %292 to i32
%310 = add i32 %279, %309
%311 = icmp ugt i32 %310, %221
br i1 %311, label %368, label %312
312: ; preds = %308
%313 = sext i32 %288 to i64
br label %314
314: ; preds = %312, %319
%315 = phi i64 [ %320, %319 ], [ %313, %312 ]
%316 = getelementptr inbounds i8, i8* %219, i64 %315
%317 = load i8, i8* %316
%318 = icmp eq i8 %317, 0
br i1 %318, label %319, label %323
319: ; preds = %314
%320 = add i64 %315, 1
%321 = trunc i64 %320 to i32
%322 = icmp ult i32 %221, %321
br i1 %322, label %368, label %314
323: ; preds = %314
%324 = getelementptr inbounds i8, i8* %219, i64 %315
%325 = trunc i64 %315 to i32
%326 = add i8 %317, -1
store i8 %326, i8* %324
%327 = add i64 %315, -1
%328 = icmp slt i32 %310, %325
br i1 %328, label %329, label %359
329: ; preds = %323
%330 = shl i64 %315, 32
%331 = ashr exact i64 %330, 32
%332 = add i32 %293, %325
%333 = zext i32 %332 to i64
%334 = sub nsw i64 %331, %333
%335 = getelementptr i8, i8* %244, i64 %334
%336 = add nuw nsw i64 %333, 1
%337 = add nsw i64 %331, -1
%338 = sext i32 %310 to i64
%339 = sub i64 %315, %291
%340 = xor i64 %291, -1
%341 = add nsw i64 %331, %340
%342 = and i64 %339, 7
%343 = icmp eq i64 %342, 0
br i1 %343, label %350, label %344
344: ; preds = %329, %344
%345 = phi i64 [ %347, %344 ], [ %337, %329 ]
%346 = phi i64 [ %348, %344 ], [ 0, %329 ]
%347 = add nsw i64 %345, -1
%348 = add i64 %346, 1
%349 = icmp eq i64 %348, %342
br i1 %349, label %350, label %344
350: ; preds = %344, %329
%351 = phi i64 [ %337, %329 ], [ %347, %344 ]
%352 = phi i64 [ undef, %329 ], [ %347, %344 ]
%353 = icmp ult i64 %341, 7
br i1 %353, label %359, label %354
354: ; preds = %350, %354
%355 = phi i64 [ %357, %354 ], [ %351, %350 ]
%356 = add nsw i64 %355, -7
%357 = add nsw i64 %355, -8
%358 = icmp sgt i64 %356, %338
br i1 %358, label %354, label %359
359: ; preds = %350, %354, %323
%360 = phi i64 [ %327, %323 ], [ %352, %350 ], [ %357, %354 ]
%361 = sub i32 65536, %301
%362 = add i32 %361, %297
%363 = lshr i32 %362, 8
%364 = trunc i32 %363 to i8
%365 = shl i64 %360, 32
%366 = ashr exact i64 %365, 32
%367 = getelementptr inbounds i8, i8* %219, i64 %366
store i8 %364, i8* %367
br label %372
368: ; preds = %308, %319
%369 = add i32 %233, %274
%370 = lshr i32 %369, 1
%371 = sub i32 %274, %370
br label %246
372: ; preds = %303, %359
%373 = phi i32 [ %304, %303 ], [ %362, %359 ]
%374 = shl i32 %373, 8
%375 = and i32 %374, 65280
%376 = icmp sgt i64 %286, 2
%377 = add i32 %288, -1
%378 = add nuw nsw i32 %287, 1
br i1 %376, label %285, label %379
379: ; preds = %273, %372
%380 = phi i32 [ %375, %372 ], [ %275, %273 ]
%381 = lshr i32 %380, 8
%382 = trunc i32 %381 to i8
%383 = sext i32 %276 to i64
%384 = getelementptr inbounds i8, i8* %219, i64 1
%385 = getelementptr inbounds i8, i8* %384, i64 %383
store i8 %382, i8* %385
%386 = ptrtoint i8* %220 to i64
%387 = trunc i64 %386 to i32
%388 = sub nsw i32 %387, %276
%389 = icmp sgt i32 %388, %276
br i1 %389, label %395, label %390
390: ; preds = %379
%391 = icmp sgt i32 %276, -1
br i1 %391, label %392, label %408
392: ; preds = %390
%393 = zext i32 %276 to i64
%394 = add nuw nsw i64 %393, 1
br label %408
395: ; preds = %379
%396 = load i8, i8* %220
%397 = zext i8 %396 to i32
%398 = icmp slt i32 %276, %397
br i1 %398, label %399, label %412
399: ; preds = %395
%400 = zext i8 %396 to i64
%401 = xor i32 %276, -1
%402 = add i32 %401, %397
%403 = zext i32 %402 to i64
%404 = sub nsw i64 %400, %403
%405 = getelementptr i8, i8* %220, i64 %404
%406 = getelementptr i8, i8* %219, i64 %404
%407 = add nuw nsw i64 %403, 1
br label %408
408: ; preds = %390, %399, %392
%409 = phi i8* [ %220, %392 ], [ %219, %399 ], [ %220, %390 ]
%410 = phi i8* [ %219, %392 ], [ %220, %399 ], [ %219, %390 ]
%411 = load i8, i8* %410
br label %412
412: ; preds = %408, %395
%413 = phi i8 [ %411, %408 ], [ %396, %395 ]
%414 = phi i8* [ %409, %408 ], [ %219, %395 ]
%415 = phi i8* [ %410, %408 ], [ %220, %395 ]
%416 = icmp eq i8 %413, 0
br i1 %416, label %428, label %417
417: ; preds = %412
%418 = zext i8 %413 to i32
br label %419
419: ; preds = %417, %425
%420 = phi i32 [ %426, %425 ], [ %418, %417 ]
%421 = zext i32 %420 to i64
%422 = getelementptr inbounds i8, i8* %415, i64 %421
%423 = load i8, i8* %422
%424 = icmp eq i8 %423, 0
br i1 %424, label %425, label %428
425: ; preds = %419
%426 = add nsw i32 %420, -1
%427 = icmp eq i32 %426, 0
br i1 %427, label %428, label %419
428: ; preds = %419, %425, %412
%429 = phi i32 [ 0, %412 ], [ 0, %425 ], [ %420, %419 ]
%430 = trunc i32 %429 to i8
store i8 %430, i8* %415
%431 = trunc i32 %276 to i8
%432 = add i8 %431, 1
store i8 %432, i8* %414
%433 = icmp slt i32 %276, 1
br i1 %433, label %438, label %434
434: ; preds = %428
%435 = getelementptr i8, i8* %414, i64 1
%436 = zext i32 %276 to i64
%437 = add nuw i32 %276, 1
br label %438
438: ; preds = %434, %428
%439 = phi i32 [ 1, %428 ], [ %437, %434 ]
%440 = trunc i32 %274 to i8
%441 = zext i32 %439 to i64
%442 = getelementptr inbounds i8, i8* %414, i64 %441
store i8 %440, i8* %442
%443 = call signext i8 @LInt_Add(i8* %2, i8* %414)
%444 = icmp ult i32 %429, %15
br i1 %444, label %445, label %218
445: ; preds = %438, %257
%446 = phi i32 [ %221, %257 ], [ %429, %438 ]
%447 = phi i8* [ %220, %257 ], [ %415, %438 ]
%448 = add i32 %446, 1
%449 = zext i32 %448 to i64
%450 = icmp ult i32 %448, 8
br i1 %450, label %555, label %451
451: ; preds = %445
%452 = getelementptr i8, i8* %3, i64 %449
%453 = getelementptr i8, i8* %447, i64 %449
%454 = icmp ugt i8* %453, %3
%455 = icmp ult i8* %447, %452
%456 = and i1 %454, %455
br i1 %456, label %555, label %457
457: ; preds = %451
%458 = icmp ult i32 %448, 32
br i1 %458, label %541, label %459
459: ; preds = %457
%460 = and i64 %449, 4294967264
%461 = add nsw i64 %460, -32
%462 = lshr exact i64 %461, 5
%463 = add nuw nsw i64 %462, 1
%464 = and i64 %463, 3
%465 = icmp ult i64 %461, 96
br i1 %465, label %517, label %466
466: ; preds = %459
%467 = and i64 %463, 1152921504606846972
br label %468
468: ; preds = %468, %466
%469 = phi i64 [ 0, %466 ], [ %514, %468 ]
%470 = phi i64 [ 0, %466 ], [ %515, %468 ]
%471 = getelementptr inbounds i8, i8* %447, i64 %469
%472 = bitcast i8* %471 to <16 x i8>*
%473 = load <16 x i8>, <16 x i8>* %472
%474 = getelementptr inbounds i8, i8* %471, i64 16
%475 = bitcast i8* %474 to <16 x i8>*
%476 = load <16 x i8>, <16 x i8>* %475
%477 = getelementptr inbounds i8, i8* %3, i64 %469
%478 = bitcast i8* %477 to <16 x i8>*
store <16 x i8> %473, <16 x i8>* %478
%479 = getelementptr inbounds i8, i8* %477, i64 16
%480 = bitcast i8* %479 to <16 x i8>*
store <16 x i8> %476, <16 x i8>* %480
%481 = or i64 %469, 32
%482 = getelementptr inbounds i8, i8* %447, i64 %481
%483 = bitcast i8* %482 to <16 x i8>*
%484 = load <16 x i8>, <16 x i8>* %483
%485 = getelementptr inbounds i8, i8* %482, i64 16
%486 = bitcast i8* %485 to <16 x i8>*
%487 = load <16 x i8>, <16 x i8>* %486
%488 = getelementptr inbounds i8, i8* %3, i64 %481
%489 = bitcast i8* %488 to <16 x i8>*
store <16 x i8> %484, <16 x i8>* %489
%490 = getelementptr inbounds i8, i8* %488, i64 16
%491 = bitcast i8* %490 to <16 x i8>*
store <16 x i8> %487, <16 x i8>* %491
%492 = or i64 %469, 64
%493 = getelementptr inbounds i8, i8* %447, i64 %492
%494 = bitcast i8* %493 to <16 x i8>*
%495 = load <16 x i8>, <16 x i8>* %494
%496 = getelementptr inbounds i8, i8* %493, i64 16
%497 = bitcast i8* %496 to <16 x i8>*
%498 = load <16 x i8>, <16 x i8>* %497
%499 = getelementptr inbounds i8, i8* %3, i64 %492
%500 = bitcast i8* %499 to <16 x i8>*
store <16 x i8> %495, <16 x i8>* %500
%501 = getelementptr inbounds i8, i8* %499, i64 16
%502 = bitcast i8* %501 to <16 x i8>*
store <16 x i8> %498, <16 x i8>* %502
%503 = or i64 %469, 96
%504 = getelementptr inbounds i8, i8* %447, i64 %503
%505 = bitcast i8* %504 to <16 x i8>*
%506 = load <16 x i8>, <16 x i8>* %505
%507 = getelementptr inbounds i8, i8* %504, i64 16
%508 = bitcast i8* %507 to <16 x i8>*
%509 = load <16 x i8>, <16 x i8>* %508
%510 = getelementptr inbounds i8, i8* %3, i64 %503
%511 = bitcast i8* %510 to <16 x i8>*
store <16 x i8> %506, <16 x i8>* %511
%512 = getelementptr inbounds i8, i8* %510, i64 16
%513 = bitcast i8* %512 to <16 x i8>*
store <16 x i8> %509, <16 x i8>* %513
%514 = add nuw i64 %469, 128
%515 = add i64 %470, 4
%516 = icmp eq i64 %515, %467
br i1 %516, label %517, label %468
517: ; preds = %468, %459
%518 = phi i64 [ 0, %459 ], [ %514, %468 ]
%519 = icmp eq i64 %464, 0
br i1 %519, label %536, label %520
520: ; preds = %517, %520
%521 = phi i64 [ %533, %520 ], [ %518, %517 ]
%522 = phi i64 [ %534, %520 ], [ 0, %517 ]
%523 = getelementptr inbounds i8, i8* %447, i64 %521
%524 = bitcast i8* %523 to <16 x i8>*
%525 = load <16 x i8>, <16 x i8>* %524
%526 = getelementptr inbounds i8, i8* %523, i64 16
%527 = bitcast i8* %526 to <16 x i8>*
%528 = load <16 x i8>, <16 x i8>* %527
%529 = getelementptr inbounds i8, i8* %3, i64 %521
%530 = bitcast i8* %529 to <16 x i8>*
store <16 x i8> %525, <16 x i8>* %530
%531 = getelementptr inbounds i8, i8* %529, i64 16
%532 = bitcast i8* %531 to <16 x i8>*
store <16 x i8> %528, <16 x i8>* %532
%533 = add nuw i64 %521, 32
%534 = add i64 %522, 1
%535 = icmp eq i64 %534, %464
br i1 %535, label %536, label %520
536: ; preds = %520, %517
%537 = icmp eq i64 %460, %449
br i1 %537, label %592, label %538
538: ; preds = %536
%539 = and i64 %449, 24
%540 = icmp eq i64 %539, 0
br i1 %540, label %555, label %541
541: ; preds = %457, %538
%542 = phi i64 [ %460, %538 ], [ 0, %457 ]
%543 = and i64 %449, 4294967288
br label %544
544: ; preds = %544, %541
%545 = phi i64 [ %542, %541 ], [ %551, %544 ]
%546 = getelementptr inbounds i8, i8* %447, i64 %545
%547 = bitcast i8* %546 to <8 x i8>*
%548 = load <8 x i8>, <8 x i8>* %547
%549 = getelementptr inbounds i8, i8* %3, i64 %545
%550 = bitcast i8* %549 to <8 x i8>*
store <8 x i8> %548, <8 x i8>* %550
%551 = add nuw i64 %545, 8
%552 = icmp eq i64 %551, %543
br i1 %552, label %553, label %544
553: ; preds = %544
%554 = icmp eq i64 %543, %449
br i1 %554, label %592, label %555
555: ; preds = %451, %445, %538, %553
%556 = phi i64 [ 0, %445 ], [ 0, %451 ], [ %460, %538 ], [ %543, %553 ]
%557 = xor i64 %556, -1
%558 = add nsw i64 %557, %449
%559 = and i64 %449, 3
%560 = icmp eq i64 %559, 0
br i1 %560, label %570, label %561
561: ; preds = %555, %561
%562 = phi i64 [ %567, %561 ], [ %556, %555 ]
%563 = phi i64 [ %568, %561 ], [ 0, %555 ]
%564 = getelementptr inbounds i8, i8* %447, i64 %562
%565 = load i8, i8* %564
%566 = getelementptr inbounds i8, i8* %3, i64 %562
store i8 %565, i8* %566
%567 = add nuw nsw i64 %562, 1
%568 = add i64 %563, 1
%569 = icmp eq i64 %568, %559
br i1 %569, label %570, label %561
570: ; preds = %561, %555
%571 = phi i64 [ %556, %555 ], [ %567, %561 ]
%572 = icmp ult i64 %558, 3
br i1 %572, label %592, label %573
573: ; preds = %570, %573
%574 = phi i64 [ %590, %573 ], [ %571, %570 ]
%575 = getelementptr inbounds i8, i8* %447, i64 %574
%576 = load i8, i8* %575
%577 = getelementptr inbounds i8, i8* %3, i64 %574
store i8 %576, i8* %577
%578 = add nuw nsw i64 %574, 1
%579 = getelementptr inbounds i8, i8* %447, i64 %578
%580 = load i8, i8* %579
%581 = getelementptr inbounds i8, i8* %3, i64 %578
store i8 %580, i8* %581
%582 = add nuw nsw i64 %574, 2
%583 = getelementptr inbounds i8, i8* %447, i64 %582
%584 = load i8, i8* %583
%585 = getelementptr inbounds i8, i8* %3, i64 %582
store i8 %584, i8* %585
%586 = add nuw nsw i64 %574, 3
%587 = getelementptr inbounds i8, i8* %447, i64 %586
%588 = load i8, i8* %587
%589 = getelementptr inbounds i8, i8* %3, i64 %586
store i8 %588, i8* %589
%590 = add nuw nsw i64 %574, 4
%591 = icmp eq i64 %590, %449
br i1 %591, label %592, label %573
592: ; preds = %570, %573, %536, %553, %209, %23
%593 = phi i8 [ 1, %23 ], [ 0, %209 ], [ 0, %553 ], [ 0, %536 ], [ 0, %573 ], [ 0, %570 ]
ret i8 %593
}