void main() {
  int N, N1, Cnt, Cnt1, Cnt2, Bit;
  long Buf;
  unsigned char X[201], Sqr[501], Out[501];
  for (Cnt = 1; Cnt <= 200; Cnt++)
    X[Cnt] = '\0';
  for (Cnt = 1; Cnt <= 400; Cnt++)
    Sqr[Cnt] = '\0';
  X[0] = (char)2;
  Sqr[0] = (char)4;
  for (Cnt = 1; Cnt <= 200; Cnt++) {
    for (Bit = 0; Bit <= 7; Bit++) {
      Buf = ((unsigned char)1 << (2 * (7 - Bit)));
      for (Cnt1 = (Cnt * 2); Buf > 0; Cnt1--) {
        Buf += (long)Sqr[Cnt1];
        Out[Cnt1] = (unsigned char)Buf & (unsigned char)0xff;
        Buf >>= 8;
      }
      for (; Cnt1 >= 0; Cnt1--)
        Out[Cnt1] = Sqr[Cnt1];
      for (Cnt1 = (Cnt * 2 + 1); Cnt1 <= (Cnt + 200); Cnt1++)
        Out[Cnt1] = Sqr[Cnt1];
      Buf = 0;
      for (Cnt1 = 200; Cnt1 >= 0; Cnt1--) {
        Buf += (long)X[Cnt1] << (8 - Bit);
        Buf += (long)Out[Cnt1 + Cnt];
        Out[Cnt1 + Cnt] = (unsigned char)Buf & (unsigned char)0xff;
        Buf >>= 8;
      }
      for (Cnt1 = (Cnt - 1); Buf > 0; Cnt1--) {
        Buf += (long)Out[Cnt1];
        Out[Cnt1] = (unsigned char)Buf & (unsigned char)0xff;
        Buf >>= 8;
      }
      if (Out[0] < (char)5) {
        X[Cnt] += ((unsigned char)0x80 >> Bit);
        for (Cnt1 = 0; Cnt1 <= (Cnt + 200); Cnt1++)
          Sqr[Cnt1] = Out[Cnt1];
      }
    }
  }
  X[0] += 1;
  Buf = 0;
  for (Cnt = 0; Cnt <= 200; Cnt++) {
    Buf += X[Cnt];
    X[Cnt] = (unsigned char)(Buf >> 1);
    Buf = (Buf & (long)1) << 8;
  }
  printf("Input the digits in byte (1 to 180): ");
  scanf("%d", &N);
  if (N > 180)
    N = 180;
  else if (N < 1)
    N = 1;
  printf("phi =%2x.", (int)X[0]);
  for (Cnt = 1; Cnt <= N; Cnt++) {
    printf("%1X", ((int)X[Cnt]) / 0x10);
    printf("%1X", ((int)X[Cnt]) % 0x10);
    if ((Cnt % 5) == 0)
      printf(" ");
    if ((Cnt % 25) == 0)
      printf("\n        ");
  }
  printf("\n");
  N1 = (int)((float)N * 8. / 10. * 3.);
  for (Cnt = 0; Cnt <= 500; Cnt++) {
    Sqr[Cnt] = (unsigned char)0;
    Out[Cnt] = (unsigned char)0;
  }
  Out[0] = X[0] + 48;
  Sqr[1] = (unsigned char)10;
  for (Cnt = 1; Cnt <= (N + 20); Cnt++) {
    for (Cnt1 = 0; Cnt1 <= 7; Cnt1++) {
      Buf = 0;
      for (Cnt2 = 1; Cnt2 <= (N1 + 68); Cnt2++) {
        Sqr[Cnt2] = (char)((int)Sqr[Cnt2] + Buf);
        Buf = ((int)Sqr[Cnt2] % 2) * 10;
        Sqr[Cnt2] = (char)((int)Sqr[Cnt2] / 2);
      }
      if ((X[Cnt] & ((unsigned char)0x80 >> Cnt1)) != '\0') {
        Buf = 0;
        for (Cnt2 = (N1 + 68); Cnt2 >= 1; Cnt2--) {
          Buf += (int)Sqr[Cnt2] + (int)Out[Cnt2];
          Out[Cnt2] = (char)(Buf % 10);
          Buf /= 10;
        }
      }
    }
  }
  for (Cnt = 1; Cnt <= N1; Cnt++)
    Out[Cnt] += 48;
  printf("phi = %c.", Out[0]);
  for (Cnt = 1; Cnt <= N1; Cnt++) {
    printf("%c", Out[Cnt]);
    if ((Cnt % 10) == 0)
      printf(" ");
    if ((Cnt % 50) == 0)
      printf("\n        ");
  }
  printf("\n");
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4f0,%rsp
movl   $0x1,-0xc(%rbp)
cmpl   $0xc8,-0xc(%rbp)
jg     1159 <main+0x39>
movslq -0xc(%rbp),%rax
movb   $0x0,-0xf0(%rbp,%rax,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1132 <main+0x12>
movl   $0x1,-0xc(%rbp)
cmpl   $0x190,-0xc(%rbp)
jg     1187 <main+0x67>
movslq -0xc(%rbp),%rax
movb   $0x0,-0x2f0(%rbp,%rax,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1160 <main+0x40>
movb   $0x2,-0xf0(%rbp)
movb   $0x4,-0x2f0(%rbp)
movl   $0x1,-0xc(%rbp)
cmpl   $0xc8,-0xc(%rbp)
jg     1421 <main+0x301>
movl   $0x0,-0x18(%rbp)
cmpl   $0x7,-0x18(%rbp)
jg     140e <main+0x2ee>
mov    $0x7,%ecx
sub    -0x18(%rbp),%ecx
shl    $0x1,%ecx
mov    $0x1,%eax
shl    %cl,%eax
cltq
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x10(%rbp)
cmpq   $0x0,-0x20(%rbp)
jle    122d <main+0x10d>
movslq -0x10(%rbp),%rax
movzbl -0x2f0(%rbp,%rax,1),%eax
ff
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movzbl %al,%eax
and    $0xff,%eax
mov    %al,%cl
movslq -0x10(%rbp),%rax
mov    %cl,-0x4f0(%rbp,%rax,1)
mov    -0x20(%rbp),%rax
sar    $0x8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    11db <main+0xbb>
jmp    1232 <main+0x112>
cmpl   $0x0,-0x10(%rbp)
jl     1260 <main+0x140>
movslq -0x10(%rbp),%rax
mov    -0x2f0(%rbp,%rax,1),%cl
movslq -0x10(%rbp),%rax
mov    %cl,-0x4f0(%rbp,%rax,1)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1232 <main+0x112>
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0xc8,%ecx
cmp    %ecx,%eax
jg     12a4 <main+0x184>
movslq -0x10(%rbp),%rax
mov    -0x2f0(%rbp,%rax,1),%cl
movslq -0x10(%rbp),%rax
mov    %cl,-0x4f0(%rbp,%rax,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    126c <main+0x14c>
movq   $0x0,-0x20(%rbp)
movl   $0xc8,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
jl     132d <main+0x20d>
movslq -0x10(%rbp),%rax
movzbl -0xf0(%rbp,%rax,1),%eax
ff
mov    $0x8,%ecx
sub    -0x18(%rbp),%ecx
mov    %ecx,%ecx
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%eax
add    -0xc(%rbp),%eax
cltq
movzbl -0x4f0(%rbp,%rax,1),%eax
ff
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movzbl %al,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x10(%rbp),%eax
add    -0xc(%rbp),%eax
cltq
mov    %cl,-0x4f0(%rbp,%rax,1)
mov    -0x20(%rbp),%rax
sar    $0x8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    12b3 <main+0x193>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x10(%rbp)
cmpq   $0x0,-0x20(%rbp)
jle    1388 <main+0x268>
movslq -0x10(%rbp),%rax
movzbl -0x4f0(%rbp,%rax,1),%eax
ff
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movzbl %al,%eax
and    $0xff,%eax
mov    %al,%cl
movslq -0x10(%rbp),%rax
mov    %cl,-0x4f0(%rbp,%rax,1)
mov    -0x20(%rbp),%rax
sar    $0x8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1336 <main+0x216>
movzbl -0x4f0(%rbp),%eax
cmp    $0x5,%eax
jge    13fb <main+0x2db>
mov    -0x18(%rbp),%ecx
mov    $0x80,%edx
sar    %cl,%edx
movslq -0xc(%rbp),%rax
movzbl -0xf0(%rbp,%rax,1),%ecx
ff
add    %edx,%ecx
mov    %cl,-0xf0(%rbp,%rax,1)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0xc8,%ecx
cmp    %ecx,%eax
jg     13f6 <main+0x2d6>
movslq -0x10(%rbp),%rax
mov    -0x4f0(%rbp,%rax,1),%cl
movslq -0x10(%rbp),%rax
mov    %cl,-0x2f0(%rbp,%rax,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13be <main+0x29e>
jmp    13fb <main+0x2db>
jmp    1400 <main+0x2e0>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11b0 <main+0x90>
jmp    1413 <main+0x2f3>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    119c <main+0x7c>
movzbl -0xf0(%rbp),%eax
add    $0x1,%eax
mov    %al,-0xf0(%rbp)
movq   $0x0,-0x20(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0xc8,-0xc(%rbp)
jg     1494 <main+0x374>
movslq -0xc(%rbp),%rax
movzbl -0xf0(%rbp,%rax,1),%eax
ff
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
sar    $0x1,%rax
mov    %al,%cl
movslq -0xc(%rbp),%rax
mov    %cl,-0xf0(%rbp,%rax,1)
mov    -0x20(%rbp),%rax
and    $0x1,%rax
shl    $0x8,%rax
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1440 <main+0x320>
lea    0xb7d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xb95(%rip),%rdi
lea    -0x4(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
cmpl   $0xb4,-0x4(%rbp)
jle    14cd <main+0x3ad>
movl   $0xb4,-0x4(%rbp)
jmp    14e3 <main+0x3c3>
cmpl   $0x1,-0x4(%rbp)
jge    14de <main+0x3be>
movl   $0x1,-0x4(%rbp)
jmp    14e3 <main+0x3c3>
movzbl -0xf0(%rbp),%esi
lea    0xb50(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     15aa <main+0x48a>
movslq -0xc(%rbp),%rax
movzbl -0xf0(%rbp,%rax,1),%eax
ff
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
lea    0xb23(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movslq -0xc(%rbp),%rax
movzbl -0xf0(%rbp,%rax,1),%eax
ff
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %edx,%esi
lea    0xaff(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1575 <main+0x455>
lea    0xae9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
mov    $0x19,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1597 <main+0x477>
lea    0xabf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    159c <main+0x47c>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    14ff <main+0x3df>
lea    0xaa8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cvtsi2ssl -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa47(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xa33(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  0xa1f(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x1f4,-0xc(%rbp)
jg     1626 <main+0x506>
movslq -0xc(%rbp),%rax
movb   $0x0,-0x2f0(%rbp,%rax,1)
movslq -0xc(%rbp),%rax
movb   $0x0,-0x4f0(%rbp,%rax,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    15f3 <main+0x4d3>
movzbl -0xf0(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x4f0(%rbp)
movb   $0xa,-0x2ef(%rbp)
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x14,%ecx
cmp    %ecx,%eax
jg     17b9 <main+0x699>
movl   $0x0,-0x10(%rbp)
cmpl   $0x7,-0x10(%rbp)
jg     17a6 <main+0x686>
movq   $0x0,-0x20(%rbp)
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x44,%ecx
cmp    %ecx,%eax
jg     16f1 <main+0x5d1>
movslq -0x14(%rbp),%rax
movzbl -0x2f0(%rbp,%rax,1),%eax
ff
cltq
add    -0x20(%rbp),%rax
mov    %al,%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x2f0(%rbp,%rax,1)
movslq -0x14(%rbp),%rax
movzbl -0x2f0(%rbp,%rax,1),%eax
ff
mov    $0x2,%ecx
cltd
idiv   %ecx
imul   $0xa,%edx,%eax
cltq
mov    %rax,-0x20(%rbp)
movslq -0x14(%rbp),%rax
movzbl -0x2f0(%rbp,%rax,1),%eax
ff
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %al,%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x2f0(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1675 <main+0x555>
movslq -0xc(%rbp),%rax
movzbl -0xf0(%rbp,%rax,1),%eax
ff
mov    -0x10(%rbp),%ecx
mov    $0x80,%edx
sar    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1793 <main+0x673>
movq   $0x0,-0x20(%rbp)
mov    -0x8(%rbp),%eax
add    $0x44,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x1,-0x14(%rbp)
jl     178e <main+0x66e>
movslq -0x14(%rbp),%rax
movzbl -0x2f0(%rbp,%rax,1),%eax
ff
movslq -0x14(%rbp),%rcx
movzbl -0x4f0(%rbp,%rcx,1),%ecx
ff
add    %ecx,%eax
cltq
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    $0xa,%ecx
cqto
idiv   %rcx
mov    %dl,%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x4f0(%rbp,%rax,1)
mov    -0x20(%rbp),%rax
mov    $0xa,%ecx
cqto
idiv   %rcx
mov    %rax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1725 <main+0x605>
jmp    1793 <main+0x673>
jmp    1798 <main+0x678>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    165c <main+0x53c>
jmp    17ab <main+0x68b>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1644 <main+0x524>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     17f0 <main+0x6d0>
movslq -0xc(%rbp),%rax
movzbl -0x4f0(%rbp,%rax,1),%ecx
ff
add    $0x30,%ecx
mov    %cl,-0x4f0(%rbp,%rax,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    17c0 <main+0x6a0>
movzbl -0x4f0(%rbp),%esi
lea    0x85d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1889 <main+0x769>
movslq -0xc(%rbp),%rax
movzbl -0x4f0(%rbp,%rax,1),%esi
ff
lea    0x83a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1854 <main+0x734>
lea    0x80a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
mov    $0x32,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1876 <main+0x756>
lea    0x7e0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    187b <main+0x75b>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    180c <main+0x6ec>
lea    0x7c9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
add    $0x4f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x508,%rsp
pxor   %xmm0,%xmm0
movdqu %xmm0,0x41(%rsp)
movdqu %xmm0,0x51(%rsp)
movdqu %xmm0,0x61(%rsp)
movdqu %xmm0,0x71(%rsp)
movdqu %xmm0,0x81(%rsp)
movdqu %xmm0,0x91(%rsp)
movdqu %xmm0,0xa1(%rsp)
movdqu %xmm0,0xb1(%rsp)
movdqu %xmm0,0xc1(%rsp)
movdqu %xmm0,0xd1(%rsp)
movdqu %xmm0,0xe1(%rsp)
movdqu %xmm0,0xf1(%rsp)
movq   $0x0,0x101(%rsp)
lea    0x311(%rsp),%rdi
mov    $0x190,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movb   $0x2,0x40(%rsp)
movb   $0x4,0x310(%rsp)
04
mov    $0x1,%ecx
mov    $0x2,%r12d
lea    0x110(%rsp),%r13
xor    %ebp,%ebp
xor    %edx,%edx
jmp    123b <main+0xeb>
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rcx
add    $0x1,%rcx
mov    0x28(%rsp),%rdx
add    $0x1,%rdx
add    $0x2,%rbp
add    $0x2,%r12d
add    $0x1,%r13
cmp    $0xc8,%rdx
je     142c <main+0x2dc>
lea    0xca(%rdx),%rax
mov    %rax,0x20(%rsp)
lea    (%rdx,%rdx,1),%rsi
add    $0x3,%rsi
lea    (%rsp,%rdx,2),%rax
add    $0x113,%rax
mov    %rax,0x38(%rsp)
lea    0xc9(%rdx),%eax
cmp    %esi,%eax
cmova  %eax,%esi
lea    0x313(%rsp,%rdx,2),%rax
mov    %rax,0x30(%rsp)
mov    %rdx,0x28(%rsp)
sub    %edx,%esi
sub    %edx,%esi
add    $0xfffffffd,%esi
add    $0x1,%rsi
mov    %rsi,0x10(%rsp)
lea    (%rcx,%rcx,1),%r15
add    $0x1,%r15
mov    %rcx,0x18(%rsp)
lea    0xc8(%rcx),%rbx
xor    %r14d,%r14d
jmp    12be <main+0x16e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r14
cmp    $0x8,%r14
je     1210 <main+0xc0>
lea    (%r14,%r14,1),%eax
mov    $0xe,%cl
sub    %al,%cl
mov    $0x1,%esi
shl    %cl,%esi
mov    %r12d,%eax
mov    %rbp,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x312(%rsp,%rdx,1),%ecx
add    %rsi,%rcx
mov    %cl,0x112(%rsp,%rdx,1)
mov    %rcx,%rsi
shr    $0x8,%rsi
add    $0xffffffffffffffff,%rdx
add    $0xffffffff,%eax
cmp    $0x100,%rcx
jae    12e0 <main+0x190>
lea    0x3(%rdx),%ecx
test   %ecx,%ecx
jle    1347 <main+0x1f7>
lea    0x2(%rdx),%rcx
mov    %ecx,%ecx
test   %eax,%eax
mov    $0x0,%esi
cmovns %esi,%eax
sub    %eax,%edx
add    $0x2,%edx
sub    %rdx,%rcx
lea    (%rsp,%rcx,1),%rdi
add    $0x110,%rdi
lea    (%rsp,%rcx,1),%rsi
add    $0x310,%rsi
add    $0x1,%rdx
call   1060 <memcpy@plt>
cmp    %rbx,%r15
ja     1360 <main+0x210>
mov    0x38(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x10(%rsp),%rdx
call   1060 <memcpy@plt>
mov    $0x8,%ecx
sub    %r14,%rcx
mov    $0xc8,%eax
xor    %edx,%edx
nop
movzbl 0x40(%rsp,%rax,1),%edi
shl    %cl,%rdi
add    %rdx,%rdi
movzbl 0x1(%r13,%rax,1),%esi
add    %rdi,%rsi
mov    %sil,0x1(%r13,%rax,1)
mov    %rsi,%rdx
sar    $0x8,%rdx
test   %rax,%rax
je     13c0 <main+0x270>
movzbl 0x3f(%rsp,%rax,1),%esi
shl    %cl,%rsi
add    %rdx,%rsi
movzbl 0x0(%r13,%rax,1),%edx
add    %rsi,%rdx
mov    %dl,0x0(%r13,%rax,1)
sar    $0x8,%rdx
add    $0xfffffffffffffffe,%rax
jmp    1370 <main+0x220>
nopl   0x0(%rax,%rax,1)
mov    %r13,%rax
cmp    $0x100,%rsi
jl     13ec <main+0x29c>
nopl   0x0(%rax)
movzbl (%rax),%ecx
add    %rdx,%rcx
mov    %cl,(%rax)
mov    %rcx,%rdx
shr    $0x8,%rdx
add    $0xffffffffffffffff,%rax
cmp    $0xff,%rcx
ja     13d0 <main+0x280>
cmpb   $0x4,0x110(%rsp)
04
ja     12b0 <main+0x160>
mov    $0x80,%eax
mov    %r14d,%ecx
shr    %cl,%eax
mov    0x18(%rsp),%rcx
add    %al,0x40(%rsp,%rcx,1)
lea    0x310(%rsp),%rdi
lea    0x110(%rsp),%rsi
mov    0x20(%rsp),%rdx
call   1060 <memcpy@plt>
jmp    12b0 <main+0x160>
movb   $0x1,0x40(%rsp)
movaps 0xbc8(%rip),%xmm3
mov    $0x1,%eax
pxor   %xmm9,%xmm9
movdqa 0xbc5(%rip),%xmm8
nopl   0x0(%rax,%rax,1)
movaps %xmm3,%xmm2
movdqu 0x40(%rsp,%rax,1),%xmm4
movdqa %xmm4,%xmm5
punpcklbw %xmm9,%xmm5
movdqa %xmm5,%xmm6
punpcklwd %xmm9,%xmm6
movdqa %xmm6,%xmm10
punpckldq %xmm9,%xmm10
punpckhdq %xmm9,%xmm6
punpckhwd %xmm9,%xmm5
movdqa %xmm5,%xmm1
punpckldq %xmm9,%xmm1
punpckhdq %xmm9,%xmm5
punpckhbw %xmm9,%xmm4
movdqa %xmm4,%xmm0
punpcklwd %xmm9,%xmm0
movdqa %xmm0,%xmm7
punpckldq %xmm9,%xmm7
punpckhdq %xmm9,%xmm0
punpckhwd %xmm9,%xmm4
movdqa %xmm4,%xmm3
punpckhdq %xmm9,%xmm3
punpckldq %xmm9,%xmm4
shufps $0x4e,%xmm10,%xmm2
psllq  $0x8,%xmm2
por    %xmm10,%xmm2
shufps $0x4e,%xmm6,%xmm10
psllq  $0x8,%xmm10
por    %xmm6,%xmm10
shufps $0x4e,%xmm1,%xmm6
psllq  $0x8,%xmm6
por    %xmm1,%xmm6
shufps $0x4e,%xmm5,%xmm1
psllq  $0x8,%xmm1
por    %xmm5,%xmm1
shufps $0x4e,%xmm7,%xmm5
psllq  $0x8,%xmm5
por    %xmm7,%xmm5
shufps $0x4e,%xmm0,%xmm7
psllq  $0x8,%xmm7
por    %xmm0,%xmm7
shufps $0x4e,%xmm4,%xmm0
psllq  $0x8,%xmm0
por    %xmm4,%xmm0
shufps $0x4e,%xmm3,%xmm4
psllq  $0x8,%xmm4
por    %xmm3,%xmm4
psrlq  $0x1,%xmm0
psrlq  $0x1,%xmm4
pand   %xmm8,%xmm4
pand   %xmm8,%xmm0
packuswb %xmm4,%xmm0
psrlq  $0x1,%xmm5
psrlq  $0x1,%xmm7
pand   %xmm8,%xmm7
pand   %xmm8,%xmm5
packuswb %xmm7,%xmm5
packuswb %xmm0,%xmm5
psrlq  $0x1,%xmm6
psrlq  $0x1,%xmm1
pand   %xmm8,%xmm1
pand   %xmm8,%xmm6
packuswb %xmm1,%xmm6
psrlq  $0x1,%xmm2
psrlq  $0x1,%xmm10
pand   %xmm8,%xmm10
pand   %xmm8,%xmm2
packuswb %xmm10,%xmm2
packuswb %xmm6,%xmm2
packuswb %xmm5,%xmm2
movdqu %xmm2,0x40(%rsp,%rax,1)
add    $0x10,%rax
cmp    $0xc1,%rax
jne    1450 <main+0x300>
pshufd $0xee,%xmm3,%xmm0
movd   %xmm0,%eax
shl    $0x8,%eax
movzbl 0x101(%rsp),%ecx
or     %ecx,%eax
shr    %eax
mov    %al,0x101(%rsp)
shl    $0x8,%ecx
movzbl 0x102(%rsp),%eax
or     %eax,%ecx
shr    %ecx
mov    %cl,0x102(%rsp)
shl    $0x8,%eax
movzbl 0x103(%rsp),%ecx
or     %ecx,%eax
shr    %eax
mov    %al,0x103(%rsp)
shl    $0x8,%ecx
movzbl 0x104(%rsp),%eax
or     %eax,%ecx
shr    %ecx
mov    %cl,0x104(%rsp)
shl    $0x8,%eax
movzbl 0x105(%rsp),%ecx
or     %ecx,%eax
shr    %eax
mov    %al,0x105(%rsp)
shl    $0x8,%ecx
movzbl 0x106(%rsp),%eax
or     %eax,%ecx
shr    %ecx
mov    %cl,0x106(%rsp)
shl    $0x8,%eax
movzbl 0x107(%rsp),%ecx
or     %ecx,%eax
shr    %eax
mov    %al,0x107(%rsp)
shl    $0x8,%ecx
movzbl 0x108(%rsp),%eax
or     %ecx,%eax
shr    %eax
mov    %al,0x108(%rsp)
lea    0x9eb(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xa03(%rip),%rdi
lea    0xc(%rsp),%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
mov    0xc(%rsp),%eax
cmp    $0xb5,%eax
jl     169c <main+0x54c>
movl   $0xb4,0xc(%rsp)
jmp    16a8 <main+0x558>
test   %eax,%eax
jg     16a8 <main+0x558>
movl   $0x1,0xc(%rsp)
mov    0x40(%rsp),%al
mov    %al,0x10(%rsp)
movzbl %al,%esi
lea    0x9c7(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
cmpl   $0x0,0xc(%rsp)
jle    1768 <main+0x618>
mov    $0x1,%r13d
lea    0x9b2(%rip),%r15
xor    %ebx,%ebx
jmp    16f2 <main+0x5a2>
nopl   (%rax)
movslq 0xc(%rsp),%rax
add    $0x1,%rbx
add    $0x1,%r13d
cmp    %rax,%rbx
jge    1768 <main+0x618>
mov    %r13d,%eax
imul   $0x51eb851f,%rax,%r14
shr    $0x23,%r14
mov    $0xcccccccd,%ecx
imul   %rcx,%rax
shr    $0x22,%rax
lea    (%rax,%rax,4),%r12d
add    $0xffffffff,%r12d
movzbl 0x41(%rsp,%rbx,1),%ebp
mov    %ebp,%esi
shr    $0x4,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
and    $0xf,%ebp
mov    %r15,%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cmp    %ebx,%r12d
jne    1747 <main+0x5f7>
mov    $0x20,%edi
call   1030 <putchar@plt>
lea    (%r14,%r14,4),%eax
lea    (%rax,%rax,4),%eax
add    $0xffffffff,%eax
cmp    %ebx,%eax
jne    16e0 <main+0x590>
lea    0x933(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    16e0 <main+0x590>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0xc(%rsp),%ebx
cvtsi2ss %ebx,%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0x8ba(%rip),%xmm0
divsd  0x8ba(%rip),%xmm0
mulsd  0x8ba(%rip),%xmm0
movsd  %xmm0,0x18(%rsp)
lea    0x310(%rsp),%rdi
mov    $0x1f5,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x110(%rsp),%rdi
mov    $0x1f5,%edx
xor    %esi,%esi
call   1050 <memset@plt>
cvttsd2si 0x18(%rsp),%r14d
mov    0x10(%rsp),%al
add    $0x30,%al
mov    %al,0x10(%rsp)
mov    %al,0x110(%rsp)
movb   $0xa,0x311(%rsp)
0a
cmp    $0xffffffed,%ebx
jge    1819 <main+0x6c9>
test   %r14d,%r14d
jle    19a3 <main+0x853>
mov    %r14d,%r15d
lea    0x1(%r15),%rax
mov    $0x1,%edx
cmp    $0x8,%r14d
jb     1af0 <main+0x9a0>
cmp    $0x20,%r15d
jae    19bb <main+0x86b>
xor    %ecx,%ecx
jmp    1a97 <main+0x947>
add    $0x14,%ebx
lea    0x44(%r14),%r9d
cmp    $0x2,%r9d
mov    $0x1,%r10d
cmovge %r9d,%r10d
mov    $0x1,%eax
cmp    $0x2,%ebx
cmovge %ebx,%eax
add    $0x1,%eax
mov    %rax,0x20(%rsp)
mov    %r10d,%r11d
and    $0x7ffffffe,%r11d
neg    %r11
lea    0x45(%r14),%edi
lea    (%rsp,%r9,1),%r12
add    $0x110,%r12
lea    (%rsp,%r9,1),%rbp
add    $0x310,%rbp
mov    $0x1,%eax
movabs $0x6666666666666667,%r13
66 66 66
jmp    1894 <main+0x744>
nopl   0x0(%rax)
mov    0x18(%rsp),%rax
add    $0x1,%rax
cmp    0x20(%rsp),%rax
je     17e9 <main+0x699>
mov    %rax,0x18(%rsp)
movzbl 0x40(%rsp,%rax,1),%r15d
xor    %ecx,%ecx
jmp    18b8 <main+0x768>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%ecx
cmp    $0x8,%ecx
je     1880 <main+0x730>
cmp    $0xffffffbd,%r14d
jl     18b0 <main+0x760>
mov    $0x1,%eax
xor    %edx,%edx
cmp    $0x2,%r9d
jl     191f <main+0x7cf>
nopl   0x0(%rax,%rax,1)
add    0x310(%rsp,%rax,1),%dl
mov    %edx,%ebx
and    $0x1,%bl
movzbl %bl,%esi
add    %esi,%esi
lea    (%rsi,%rsi,4),%esi
shr    %dl
mov    %dl,0x310(%rsp,%rax,1)
add    0x311(%rsp,%rax,1),%sil
mov    %esi,%edx
and    $0x1,%dl
movzbl %dl,%edx
add    %edx,%edx
lea    (%rdx,%rdx,4),%edx
shr    %sil
mov    %sil,0x311(%rsp,%rax,1)
lea    (%r11,%rax,1),%rsi
add    $0x2,%rsi
add    $0x2,%rax
cmp    $0x1,%rsi
jne    18d0 <main+0x780>
test   $0x1,%r10b
je     1935 <main+0x7e5>
add    0x310(%rsp,%rax,1),%dl
shr    %dl
mov    %dl,0x310(%rsp,%rax,1)
mov    %r15d,%eax
shl    %cl,%eax
test   $0x80,%al
je     18b0 <main+0x760>
cmp    $0xffffffbd,%r14d
jl     18b0 <main+0x760>
xor    %r8d,%r8d
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%rbp,%r8,1),%eax
add    %rdx,%rax
movzbl (%r12,%r8,1),%esi
add    %rax,%rsi
mov    %rsi,%rax
imul   %r13
mov    %rdx,%rax
shr    $0x3f,%rax
sar    $0x2,%rdx
add    %rax,%rdx
lea    (%rdx,%rdx,1),%eax
lea    (%rax,%rax,4),%eax
sub    %eax,%esi
mov    %sil,(%r12,%r8,1)
add    $0xffffffffffffffff,%r8
lea    (%rdi,%r8,1),%eax
cmp    $0x1,%eax
jg     1960 <main+0x810>
jmp    18b0 <main+0x760>
movzbl 0x10(%rsp),%esi
lea    0x6ea(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    1b98 <main+0xa48>
mov    %r15d,%ecx
and    $0xffffffe0,%ecx
lea    -0x20(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1ad6 <main+0x986>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
mov    $0x1,%edx
movdqa 0x633(%rip),%xmm0
nopl   (%rax)
movdqu 0x110(%rsp,%rdx,1),%xmm1
movdqu 0x120(%rsp,%rdx,1),%xmm2
movdqu 0x130(%rsp,%rdx,1),%xmm3
movdqu 0x140(%rsp,%rdx,1),%xmm4
paddb  %xmm0,%xmm1
paddb  %xmm0,%xmm2
movdqu %xmm1,0x110(%rsp,%rdx,1)
movdqu %xmm2,0x120(%rsp,%rdx,1)
paddb  %xmm0,%xmm3
paddb  %xmm0,%xmm4
movdqu %xmm3,0x130(%rsp,%rdx,1)
movdqu %xmm4,0x140(%rsp,%rdx,1)
add    $0x40,%rdx
add    $0xfffffffffffffffe,%rdi
jne    19f0 <main+0x8a0>
test   $0x1,%sil
je     1a8c <main+0x93c>
movdqu 0x110(%rsp,%rdx,1),%xmm0
movdqu 0x120(%rsp,%rdx,1),%xmm1
movdqa 0x5ae(%rip),%xmm2
paddb  %xmm2,%xmm0
paddb  %xmm2,%xmm1
movdqu %xmm0,0x110(%rsp,%rdx,1)
movdqu %xmm1,0x120(%rsp,%rdx,1)
cmp    %rcx,%r15
je     1b01 <main+0x9b1>
test   $0x18,%r15b
je     1ae7 <main+0x997>
lea    -0x1(%rax),%rsi
mov    %rsi,%rdi
and    $0xfffffffffffffff8,%rdi
lea    0x1(%rdi),%rdx
movdqa 0x582(%rip),%xmm0
xchg   %ax,%ax
movq   0x111(%rsp,%rcx,1),%xmm1
paddb  %xmm0,%xmm1
movq   %xmm1,0x111(%rsp,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rdi
jne    1ab0 <main+0x960>
cmp    %rdi,%rsi
jne    1af0 <main+0x9a0>
jmp    1b01 <main+0x9b1>
mov    $0x1,%edx
test   $0x1,%sil
jne    1a58 <main+0x908>
jmp    1a8c <main+0x93c>
or     $0x1,%rcx
mov    %rcx,%rdx
xchg   %ax,%ax
addb   $0x30,0x110(%rsp,%rdx,1)
30
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1af0 <main+0x9a0>
movzbl 0x10(%rsp),%esi
lea    0x58c(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
test   %r14d,%r14d
jle    1b98 <main+0xa48>
mov    $0x1,%r13d
mov    $0xcccccccd,%r12d
xor    %ebp,%ebp
jmp    1b3d <main+0x9ed>
nopl   0x0(%rax)
add    $0x1,%rbp
add    $0x1,%r13d
cmp    %rbp,%r15
je     1b98 <main+0xa48>
mov    %r13d,%eax
imul   $0x51eb851f,%rax,%rcx
shr    $0x24,%rcx
imul   $0x32,%ecx,%ebx
add    $0xfffffffe,%ebx
or     $0x1,%rbx
imul   %r12,%rax
shr    $0x23,%rax
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,1),%r14d
add    $0xffffffff,%r14d
movzbl 0x111(%rsp,%rbp,1),%edi
call   1030 <putchar@plt>
cmp    %ebp,%r14d
jne    1b84 <main+0xa34>
mov    $0x20,%edi
call   1030 <putchar@plt>
cmp    %ebp,%ebx
jne    1b30 <main+0x9e0>
lea    0x500(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    1b30 <main+0x9e0>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x508,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [38 x i8] c"Input the digits in byte (1 to 180): \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [10 x i8] c"phi =%2x.\00"
@.str.3 = [4 x i8] c"%1X\00"
@.str.5 = [10 x i8] c"\0A \00"
@.str.7 = [10 x i8] c"phi = %c.\00"
define void @main() {
%1 = alloca i32
%2 = alloca [201 x i8]
%3 = alloca [501 x i8]
%4 = getelementptr inbounds [501 x i8], [501 x i8]* %3, i64 0, i64 0
%5 = alloca [501 x i8]
%6 = getelementptr inbounds [501 x i8], [501 x i8]* %5, i64 0, i64 0
%7 = bitcast i32* %1 to i8*
%8 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 0
%9 = getelementptr inbounds [501 x i8], [501 x i8]* %3, i64 0, i64 0
%10 = getelementptr inbounds [501 x i8], [501 x i8]* %5, i64 0, i64 0
%11 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 1
%12 = getelementptr inbounds [501 x i8], [501 x i8]* %3, i64 0, i64 1
store i8 2, i8* %8
store i8 4, i8* %9
br label %13
13: ; preds = %0, %129
%14 = phi i64 [ 1, %0 ], [ %130, %129 ]
%15 = phi i64 [ 0, %0 ], [ %132, %129 ]
%16 = phi i64 [ 2, %0 ], [ %131, %129 ]
%17 = add nuw nsw i64 %15, 202
%18 = shl nuw nsw i64 %15, 1
%19 = add nuw nsw i64 %18, 3
%20 = getelementptr [501 x i8], [501 x i8]* %5, i64 0, i64 %19
%21 = getelementptr [501 x i8], [501 x i8]* %3, i64 0, i64 %19
%22 = trunc i64 %15 to i32
%23 = add i32 %22, 201
%24 = trunc i64 %19 to i32
%25 = call i32 @llvm.umax.i32(i32 %23, i32 %24)
%26 = trunc i64 %15 to i32
%27 = mul i32 %26, -2
%28 = add i32 %27, -3
%29 = add i32 %25, %28
%30 = zext i32 %29 to i64
%31 = add nuw nsw i64 %30, 1
%32 = shl nuw nsw i64 %14, 1
%33 = or i64 %32, 1
%34 = add nuw nsw i64 %14, 200
%35 = icmp ugt i64 %33, %34
%36 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 %14
br label %37
37: ; preds = %13, %126
%38 = phi i64 [ 0, %13 ], [ %127, %126 ]
%39 = trunc i64 %38 to i32
%40 = mul i32 %39, -2
%41 = add i32 %40, 14
%42 = shl nuw nsw i32 1, %41
%43 = zext i32 %42 to i64
br label %57
44: ; preds = %57
%45 = trunc i64 %58 to i32
%46 = trunc i64 %67 to i32
%47 = icmp sgt i32 %45, 0
br i1 %47, label %48, label %69
48: ; preds = %44
%49 = and i64 %67, 4294967295
%50 = call i32 @llvm.smin.i32(i32 %46, i32 0)
%51 = sub i32 %46, %50
%52 = zext i32 %51 to i64
%53 = sub nsw i64 %49, %52
%54 = getelementptr [501 x i8], [501 x i8]* %5, i64 0, i64 %53
%55 = getelementptr [501 x i8], [501 x i8]* %3, i64 0, i64 %53
%56 = add nuw nsw i64 %52, 1
br label %69
57: ; preds = %37, %57
%58 = phi i64 [ %16, %37 ], [ %67, %57 ]
%59 = phi i64 [ %43, %37 ], [ %66, %57 ]
%60 = getelementptr inbounds [501 x i8], [501 x i8]* %3, i64 0, i64 %58
%61 = load i8, i8* %60
%62 = zext i8 %61 to i64
%63 = add nuw nsw i64 %59, %62
%64 = trunc i64 %63 to i8
%65 = getelementptr inbounds [501 x i8], [501 x i8]* %5, i64 0, i64 %58
store i8 %64, i8* %65
%66 = lshr i64 %63, 8
%67 = add i64 %58, -1
%68 = icmp ult i64 %63, 256
br i1 %68, label %44, label %57
69: ; preds = %48, %44
br i1 %35, label %71, label %70
70: ; preds = %69
br label %71
71: ; preds = %70, %69
%72 = sub nuw nsw i64 8, %38
br label %75
73: ; preds = %75
%74 = icmp sgt i64 %87, 255
br i1 %74, label %106, label %117
75: ; preds = %92, %71
%76 = phi i64 [ 200, %71 ], [ %105, %92 ]
%77 = phi i64 [ 0, %71 ], [ %104, %92 ]
%78 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 %76
%79 = load i8, i8* %78
%80 = zext i8 %79 to i64
%81 = shl i64 %80, %72
%82 = add nsw i64 %81, %77
%83 = add nuw nsw i64 %76, %14
%84 = getelementptr inbounds [501 x i8], [501 x i8]* %5, i64 0, i64 %83
%85 = load i8, i8* %84
%86 = zext i8 %85 to i64
%87 = add nsw i64 %82, %86
%88 = trunc i64 %87 to i8
store i8 %88, i8* %84
%89 = ashr i64 %87, 8
%90 = add nsw i64 %76, -1
%91 = icmp eq i64 %76, 0
br i1 %91, label %73, label %92
92: ; preds = %75
%93 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 %90
%94 = load i8, i8* %93
%95 = zext i8 %94 to i64
%96 = shl i64 %95, %72
%97 = add nsw i64 %96, %89
%98 = add nuw nsw i64 %90, %14
%99 = getelementptr inbounds [501 x i8], [501 x i8]* %5, i64 0, i64 %98
%100 = load i8, i8* %99
%101 = zext i8 %100 to i64
%102 = add nsw i64 %97, %101
%103 = trunc i64 %102 to i8
store i8 %103, i8* %99
%104 = ashr i64 %102, 8
%105 = add nsw i64 %76, -2
br label %75
106: ; preds = %73, %106
%107 = phi i64 [ %109, %106 ], [ %14, %73 ]
%108 = phi i64 [ %115, %106 ], [ %89, %73 ]
%109 = add nsw i64 %107, -1
%110 = getelementptr inbounds [501 x i8], [501 x i8]* %5, i64 0, i64 %109
%111 = load i8, i8* %110
%112 = zext i8 %111 to i64
%113 = add nuw nsw i64 %108, %112
%114 = trunc i64 %113 to i8
store i8 %114, i8* %110
%115 = lshr i64 %113, 8
%116 = icmp ult i64 %113, 256
br i1 %116, label %117, label %106
117: ; preds = %106, %73
%118 = load i8, i8* %10
%119 = icmp ult i8 %118, 5
br i1 %119, label %120, label %126
120: ; preds = %117
%121 = trunc i64 %38 to i32
%122 = lshr i32 128, %121
%123 = load i8, i8* %36
%124 = trunc i32 %122 to i8
%125 = add i8 %123, %124
store i8 %125, i8* %36
br label %126
126: ; preds = %120, %117
%127 = add nuw nsw i64 %38, 1
%128 = icmp eq i64 %127, 8
br i1 %128, label %129, label %37
129: ; preds = %126
%130 = add nuw nsw i64 %14, 1
%131 = add nuw nsw i64 %16, 2
%132 = add nuw nsw i64 %15, 1
%133 = icmp eq i64 %132, 200
br i1 %133, label %134, label %13
134: ; preds = %129
%135 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 0
store i8 1, i8* %135
br label %136
136: ; preds = %136, %134
%137 = phi i64 [ 0, %134 ], [ %150, %136 ]
%138 = phi <16 x i64> [ <i64 poison, i64 poison, i64 poison, i64 poison, i64 poison, i64 poison, i64 poison, i64 poison, i64 poison, i64 poison, i64 poison, i64 poison, i64 poison, i64 poison, i64 poison, i64 3>, %134 ], [ %143, %136 ]
%139 = or i64 %137, 1
%140 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 %139
%141 = bitcast i8* %140 to <16 x i8>*
%142 = load <16 x i8>, <16 x i8>* %141
%143 = zext <16 x i8> %142 to <16 x i64>
%144 = shufflevector <16 x i64> %138, <16 x i64> %143, <16 x i32> <i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30>
%145 = shl nuw nsw <16 x i64> %144, <i64 8, i64 8, i64 8, i64 8, i64 8, i64 8, i64 8, i64 8, i64 8, i64 8, i64 8, i64 8, i64 8, i64 8, i64 8, i64 8>
%146 = or <16 x i64> %145, %143
%147 = lshr <16 x i64> %146, <i64 1, i64 1, i64 1, i64 1, i64 1, i64 1, i64 1, i64 1, i64 1, i64 1, i64 1, i64 1, i64 1, i64 1, i64 1, i64 1>
%148 = trunc <16 x i64> %147 to <16 x i8>
%149 = bitcast i8* %140 to <16 x i8>*
store <16 x i8> %148, <16 x i8>* %149
%150 = add nuw i64 %137, 16
%151 = icmp eq i64 %150, 192
br i1 %151, label %152, label %136
152: ; preds = %136
%153 = extractelement <16 x i64> %143, i64 15
%154 = shl nuw nsw i64 %153, 8
%155 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 193
%156 = load i8, i8* %155
%157 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 193
%158 = zext i8 %156 to i64
%159 = or i64 %154, %158
%160 = lshr i64 %159, 1
%161 = trunc i64 %160 to i8
store i8 %161, i8* %157
%162 = shl nuw nsw i64 %158, 8
%163 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 194
%164 = load i8, i8* %163
%165 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 194
%166 = zext i8 %164 to i64
%167 = or i64 %162, %166
%168 = lshr i64 %167, 1
%169 = trunc i64 %168 to i8
store i8 %169, i8* %165
%170 = shl nuw nsw i64 %166, 8
%171 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 195
%172 = load i8, i8* %171
%173 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 195
%174 = zext i8 %172 to i64
%175 = or i64 %170, %174
%176 = lshr i64 %175, 1
%177 = trunc i64 %176 to i8
store i8 %177, i8* %173
%178 = shl nuw nsw i64 %174, 8
%179 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 196
%180 = load i8, i8* %179
%181 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 196
%182 = zext i8 %180 to i64
%183 = or i64 %178, %182
%184 = lshr i64 %183, 1
%185 = trunc i64 %184 to i8
store i8 %185, i8* %181
%186 = shl nuw nsw i64 %182, 8
%187 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 197
%188 = load i8, i8* %187
%189 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 197
%190 = zext i8 %188 to i64
%191 = or i64 %186, %190
%192 = lshr i64 %191, 1
%193 = trunc i64 %192 to i8
store i8 %193, i8* %189
%194 = shl nuw nsw i64 %190, 8
%195 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 198
%196 = load i8, i8* %195
%197 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 198
%198 = zext i8 %196 to i64
%199 = or i64 %194, %198
%200 = lshr i64 %199, 1
%201 = trunc i64 %200 to i8
store i8 %201, i8* %197
%202 = shl nuw nsw i64 %198, 8
%203 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 199
%204 = load i8, i8* %203
%205 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 199
%206 = zext i8 %204 to i64
%207 = or i64 %202, %206
%208 = lshr i64 %207, 1
%209 = trunc i64 %208 to i8
store i8 %209, i8* %205
%210 = shl nuw nsw i64 %206, 8
%211 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 200
%212 = load i8, i8* %211
%213 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 200
%214 = zext i8 %212 to i64
%215 = or i64 %210, %214
%216 = lshr i64 %215, 1
%217 = trunc i64 %216 to i8
store i8 %217, i8* %213
%218 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0))
%219 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %1)
%220 = load i32, i32* %1
%221 = icmp sgt i32 %220, 180
br i1 %221, label %222, label %223
222: ; preds = %152
store i32 180, i32* %1
br label %226
223: ; preds = %152
%224 = icmp slt i32 %220, 1
br i1 %224, label %225, label %226
225: ; preds = %223
store i32 1, i32* %1
br label %226
226: ; preds = %223, %225, %222
%227 = load i8, i8* %8
%228 = zext i8 %227 to i32
%229 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0), i32 %228)
%230 = load i32, i32* %1
%231 = icmp slt i32 %230, 1
br i1 %231, label %257, label %232
232: ; preds = %226, %252
%233 = phi i64 [ %253, %252 ], [ 1, %226 ]
%234 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 %233
%235 = load i8, i8* %234
%236 = lshr i8 %235, 4
%237 = zext i8 %236 to i32
%238 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %237)
%239 = and i8 %235, 15
%240 = zext i8 %239 to i32
%241 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %240)
%242 = trunc i64 %233 to i32
%243 = urem i32 %242, 5
%244 = icmp eq i32 %243, 0
br i1 %244, label %245, label %247
245: ; preds = %232
%246 = call i32 @putchar(i32 32)
br label %247
247: ; preds = %245, %232
%248 = urem i32 %242, 25
%249 = icmp eq i32 %248, 0
br i1 %249, label %250, label %252
250: ; preds = %247
%251 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.5, i64 0, i64 0))
br label %252
252: ; preds = %247, %250
%253 = add nuw nsw i64 %233, 1
%254 = load i32, i32* %1
%255 = sext i32 %254 to i64
%256 = icmp slt i64 %233, %255
br i1 %256, label %232, label %257
257: ; preds = %252, %226
%258 = call i32 @putchar(i32 10)
%259 = load i32, i32* %1
%260 = sitofp i32 %259 to float
%261 = fpext float %260 to double
%262 = fmul double %261, 8.000000e+00
%263 = fdiv double %262, 1.000000e+01
%264 = fmul double %263, 3.000000e+00
%265 = fptosi double %264 to i32
%266 = add i8 %227, 48
store i8 %266, i8* %10
store i8 10, i8* %12
%267 = icmp slt i32 %259, -19
br i1 %267, label %287, label %268
268: ; preds = %257
%269 = add i32 %259, 20
%270 = add i32 %265, 68
%271 = icmp slt i32 %265, -67
%272 = call i32 @llvm.smax.i32(i32 %270, i32 1)
%273 = zext i32 %270 to i64
%274 = call i32 @llvm.smax.i32(i32 %269, i32 1)
%275 = add nuw i32 %274, 1
%276 = zext i32 %275 to i64
%277 = zext i32 %272 to i64
%278 = and i64 %277, 1
%279 = icmp slt i32 %270, 2
%280 = and i64 %277, 2147483646
%281 = icmp eq i64 %278, 0
br label %282
282: ; preds = %268, %433
%283 = phi i64 [ 1, %268 ], [ %434, %433 ]
%284 = getelementptr inbounds [201 x i8], [201 x i8]* %2, i64 0, i64 %283
%285 = load i8, i8* %284
%286 = zext i8 %285 to i32
br label %377
287: ; preds = %433, %257
%288 = icmp slt i32 %265, 1
br i1 %288, label %289, label %292
289: ; preds = %287
%290 = zext i8 %266 to i32
%291 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i64 0, i64 0), i32 %290)
br label %468
292: ; preds = %287
%293 = add nuw i32 %265, 1
%294 = zext i32 %293 to i64
%295 = add nsw i64 %294, -1
%296 = icmp ult i64 %295, 8
br i1 %296, label %375, label %297
297: ; preds = %292
%298 = icmp ult i64 %295, 32
br i1 %298, label %358, label %299
299: ; preds = %297
%300 = and i64 %295, -32
%301 = add nsw i64 %300, -32
%302 = lshr exact i64 %301, 5
%303 = add nuw nsw i64 %302, 1
%304 = and i64 %303, 1
%305 = icmp eq i64 %301, 0
br i1 %305, label %338, label %306
306: ; preds = %299
%307 = and i64 %303, 1152921504606846974
br label %308
308: ; preds = %308, %306
%309 = phi i64 [ 0, %306 ], [ %333, %308 ]
%310 = phi i64 [ 0, %306 ], [ %334, %308 ]
%311 = or i64 %309, 1
%312 = getelementptr inbounds [501 x i8], [501 x i8]* %5, i64 0, i64 %311
%313 = bitcast i8* %312 to <16 x i8>*
%314 = load <16 x i8>, <16 x i8>* %313
%315 = getelementptr inbounds i8, i8* %312, i64 16
%316 = bitcast i8* %315 to <16 x i8>*
%317 = load <16 x i8>, <16 x i8>* %316
%318 = add <16 x i8> %314, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%319 = add <16 x i8> %317, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%320 = bitcast i8* %312 to <16 x i8>*
store <16 x i8> %318, <16 x i8>* %320
%321 = bitcast i8* %315 to <16 x i8>*
store <16 x i8> %319, <16 x i8>* %321
%322 = or i64 %309, 33
%323 = getelementptr inbounds [501 x i8], [501 x i8]* %5, i64 0, i64 %322
%324 = bitcast i8* %323 to <16 x i8>*
%325 = load <16 x i8>, <16 x i8>* %324
%326 = getelementptr inbounds i8, i8* %323, i64 16
%327 = bitcast i8* %326 to <16 x i8>*
%328 = load <16 x i8>, <16 x i8>* %327
%329 = add <16 x i8> %325, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%330 = add <16 x i8> %328, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%331 = bitcast i8* %323 to <16 x i8>*
store <16 x i8> %329, <16 x i8>* %331
%332 = bitcast i8* %326 to <16 x i8>*
store <16 x i8> %330, <16 x i8>* %332
%333 = add nuw i64 %309, 64
%334 = add i64 %310, 2
%335 = icmp eq i64 %334, %307
br i1 %335, label %336, label %308
336: ; preds = %308
%337 = or i64 %333, 1
br label %338
338: ; preds = %336, %299
%339 = phi i64 [ 1, %299 ], [ %337, %336 ]
%340 = icmp eq i64 %304, 0
br i1 %340, label %352, label %341
341: ; preds = %338
%342 = getelementptr inbounds [501 x i8], [501 x i8]* %5, i64 0, i64 %339
%343 = bitcast i8* %342 to <16 x i8>*
%344 = load <16 x i8>, <16 x i8>* %343
%345 = getelementptr inbounds i8, i8* %342, i64 16
%346 = bitcast i8* %345 to <16 x i8>*
%347 = load <16 x i8>, <16 x i8>* %346
%348 = add <16 x i8> %344, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%349 = add <16 x i8> %347, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%350 = bitcast i8* %342 to <16 x i8>*
store <16 x i8> %348, <16 x i8>* %350
%351 = bitcast i8* %345 to <16 x i8>*
store <16 x i8> %349, <16 x i8>* %351
br label %352
352: ; preds = %338, %341
%353 = icmp eq i64 %295, %300
br i1 %353, label %443, label %354
354: ; preds = %352
%355 = or i64 %300, 1
%356 = and i64 %295, 24
%357 = icmp eq i64 %356, 0
br i1 %357, label %375, label %358
358: ; preds = %297, %354
%359 = phi i64 [ %300, %354 ], [ 0, %297 ]
%360 = add nsw i64 %294, -1
%361 = and i64 %360, -8
%362 = or i64 %361, 1
br label %363
363: ; preds = %363, %358
%364 = phi i64 [ %359, %358 ], [ %371, %363 ]
%365 = or i64 %364, 1
%366 = getelementptr inbounds [501 x i8], [501 x i8]* %5, i64 0, i64 %365
%367 = bitcast i8* %366 to <8 x i8>*
%368 = load <8 x i8>, <8 x i8>* %367
%369 = add <8 x i8> %368, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%370 = bitcast i8* %366 to <8 x i8>*
store <8 x i8> %369, <8 x i8>* %370
%371 = add nuw i64 %364, 8
%372 = icmp eq i64 %371, %361
br i1 %372, label %373, label %363
373: ; preds = %363
%374 = icmp eq i64 %360, %361
br i1 %374, label %443, label %375
375: ; preds = %292, %354, %373
%376 = phi i64 [ 1, %292 ], [ %355, %354 ], [ %362, %373 ]
br label %436
377: ; preds = %282, %430
%378 = phi i32 [ 0, %282 ], [ %431, %430 ]
br i1 %271, label %430, label %379
379: ; preds = %377
br i1 %279, label %400, label %380
380: ; preds = %379, %380
%381 = phi i64 [ %397, %380 ], [ 1, %379 ]
%382 = phi i8 [ %395, %380 ], [ 0, %379 ]
%383 = phi i64 [ %398, %380 ], [ 0, %379 ]
%384 = getelementptr inbounds [501 x i8], [501 x i8]* %3, i64 0, i64 %381
%385 = load i8, i8* %384
%386 = add i8 %385, %382
%387 = and i8 %386, 1
%388 = mul nuw nsw i8 %387, 10
%389 = lshr i8 %386, 1
store i8 %389, i8* %384
%390 = add nuw nsw i64 %381, 1
%391 = getelementptr inbounds [501 x i8], [501 x i8]* %3, i64 0, i64 %390
%392 = load i8, i8* %391
%393 = add i8 %392, %388
%394 = and i8 %393, 1
%395 = mul nuw nsw i8 %394, 10
%396 = lshr i8 %393, 1
store i8 %396, i8* %391
%397 = add nuw nsw i64 %381, 2
%398 = add i64 %383, 2
%399 = icmp eq i64 %398, %280
br i1 %399, label %400, label %380
400: ; preds = %380, %379
%401 = phi i64 [ 1, %379 ], [ %397, %380 ]
%402 = phi i8 [ 0, %379 ], [ %395, %380 ]
br i1 %281, label %408, label %403
403: ; preds = %400
%404 = getelementptr inbounds [501 x i8], [501 x i8]* %3, i64 0, i64 %401
%405 = load i8, i8* %404
%406 = add i8 %405, %402
%407 = lshr i8 %406, 1
store i8 %407, i8* %404
br label %408
408: ; preds = %400, %403
%409 = lshr i32 128, %378
%410 = and i32 %409, %286
%411 = icmp eq i32 %410, 0
%412 = select i1 %411, i1 true, i1 %271
br i1 %412, label %430, label %413
413: ; preds = %408, %413
%414 = phi i64 [ %427, %413 ], [ %273, %408 ]
%415 = phi i64 [ %426, %413 ], [ 0, %408 ]
%416 = getelementptr inbounds [501 x i8], [501 x i8]* %3, i64 0, i64 %414
%417 = load i8, i8* %416
%418 = zext i8 %417 to i64
%419 = getelementptr inbounds [501 x i8], [501 x i8]* %5, i64 0, i64 %414
%420 = load i8, i8* %419
%421 = zext i8 %420 to i64
%422 = add nsw i64 %415, %418
%423 = add nsw i64 %422, %421
%424 = srem i64 %423, 10
%425 = trunc i64 %424 to i8
store i8 %425, i8* %419
%426 = sdiv i64 %423, 10
%427 = add nsw i64 %414, -1
%428 = trunc i64 %414 to i32
%429 = icmp sgt i32 %428, 1
br i1 %429, label %413, label %430
430: ; preds = %413, %377, %408
%431 = add nuw nsw i32 %378, 1
%432 = icmp eq i32 %431, 8
br i1 %432, label %433, label %377
433: ; preds = %430
%434 = add nuw nsw i64 %283, 1
%435 = icmp eq i64 %434, %276
br i1 %435, label %287, label %282
436: ; preds = %375, %436
%437 = phi i64 [ %441, %436 ], [ %376, %375 ]
%438 = getelementptr inbounds [501 x i8], [501 x i8]* %5, i64 0, i64 %437
%439 = load i8, i8* %438
%440 = add i8 %439, 48
store i8 %440, i8* %438
%441 = add nuw nsw i64 %437, 1
%442 = icmp eq i64 %441, %294
br i1 %442, label %443, label %436
443: ; preds = %436, %373, %352
%444 = zext i8 %266 to i32
%445 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i64 0, i64 0), i32 %444)
br i1 %288, label %468, label %446
446: ; preds = %443
%447 = add nuw i32 %265, 1
%448 = zext i32 %447 to i64
br label %449
449: ; preds = %446, %465
%450 = phi i64 [ 1, %446 ], [ %466, %465 ]
%451 = getelementptr inbounds [501 x i8], [501 x i8]* %5, i64 0, i64 %450
%452 = load i8, i8* %451
%453 = zext i8 %452 to i32
%454 = call i32 @putchar(i32 %453)
%455 = trunc i64 %450 to i32
%456 = urem i32 %455, 10
%457 = icmp eq i32 %456, 0
br i1 %457, label %458, label %460
458: ; preds = %449
%459 = call i32 @putchar(i32 32)
br label %460
460: ; preds = %458, %449
%461 = urem i32 %455, 50
%462 = icmp eq i32 %461, 0
br i1 %462, label %463, label %465
463: ; preds = %460
%464 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.5, i64 0, i64 0))
br label %465
465: ; preds = %460, %463
%466 = add nuw nsw i64 %450, 1
%467 = icmp eq i64 %466, %448
br i1 %467, label %468, label %449
468: ; preds = %465, %289, %443
%469 = call i32 @putchar(i32 10)
ret void
}