#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ line;
typedef int /*<<< orphan*/ bmpbdf;
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ *fgets(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ memset(unsigned char **, int /*<<< orphan*/, int);
int sscanf(char *, char *, ...);
scalar_t__ strncmp(char *, char *, int);
void convert(FILE *fp, unsigned char bmp60[16], int size_x_out, int size_y_out,
             int pixel_x, int pixel_y, int over_baseline,
             int code_is_ambiguous) {
  int i, j;
  int x, y;
  int size_x, size_y;
  int offset_x, offset_y;
  unsigned long long data;
  double ratio_x, ratio_y;
  char line[100];
  unsigned char bmpbdf[64][64];
  memset(bmpbdf, 0, sizeof(bmpbdf));
  do {
    if (fgets(line, sizeof(line), fp) == NULL)
      break;
  } while (sscanf(line, "BBX %d %d %d %d", &size_x, &size_y, &offset_x,
                  &offset_y) != 4);
  if (code_is_ambiguous && size_x + offset_x <= pixel_x / 2) {
    pixel_x /= 2;
  }
  if (pixel_x > size_x_out) {
    ratio_x = (double)pixel_x / size_x_out;
  } else {
    ratio_x = 1;
    offset_x += (size_x_out - pixel_x) / 2;
  }
  if (pixel_y > size_y_out) {
    ratio_y = (double)pixel_y / size_y_out;
  } else {
    ratio_y = 1;
    offset_y -= (size_y_out - pixel_y) / 2;
  }
  if (offset_x < 0) {
    offset_x = 0;
  }
  do {
    if (fgets(line, sizeof(line), fp) == NULL)
      break;
  } while (strncmp(line, "BITMAP", 6) != 0);
  for (i = 0; i < size_y; i++) {
    if (fgets(line, sizeof(line), fp) == NULL)
      break;
    while (sscanf(line, "%llx", &data) != 1) {
      ;
    }
    for (j = 0; j < size_x; j++) {
      x = j + offset_x;
      y = i + over_baseline - size_y - offset_y;
      if (0 <= x && x <= 64 && 0 <= y && y <= 64) {
        bmpbdf[x][y] = (data >> ((64 - size_x) % 8 + size_x - j - 1)) & 1;
      }
    }
  }
  if (size_y > 0) {
    for (i = 0; i < size_y_out; i++) {
      bmp60[i] = 0;
      for (j = 0; j < size_x_out; j++) {
        data = 0;
        for (x = j * ratio_x; x < (int)((j + 1) * ratio_x + .01) && x < 64;
             x++) {
          for (y = i * ratio_y; y < (int)((i + 1) * ratio_y + .01) && y < 64;
               y++) {
            data += bmpbdf[x][y];
          }
        }
        if ((double)data / (x - (int)(j * ratio_x)) * (y - (int)(i * ratio_y)) >
            0) {
          bmp60[i] |= 1 << (size_x_out - j - 1);
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<convert>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10e0,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
lea    -0x10c0(%rbp),%rdi
xor    %esi,%esi
mov    $0x1000,%edx
call   1040 <memset@plt>
lea    -0xc0(%rbp),%rdi
mov    -0x8(%rbp),%rdx
mov    $0x64,%esi
call   1050 <fgets@plt>
cmp    $0x0,%rax
jne    119e <convert+0x5e>
jmp    11d1 <convert+0x91>
jmp    11a3 <convert+0x63>
lea    -0xc0(%rbp),%rdi
lea    0xe7f(%rip),%rsi
lea    -0x34(%rbp),%rdx
lea    -0x38(%rbp),%rcx
lea    -0x3c(%rbp),%r8
lea    -0x40(%rbp),%r9
mov    $0x0,%al
call   1060 <sscanf@plt>
cmp    $0x4,%eax
jne    117a <convert+0x3a>
cmpl   $0x0,0x18(%rbp)
je     1210 <convert+0xd0>
mov    -0x34(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x10c4(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x10c4(%rbp),%eax
cmp    %ecx,%eax
jg     1210 <convert+0xd0>
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    1234 <convert+0xf4>
cvtsi2sdl -0x1c(%rbp),%xmm0
cvtsi2sdl -0x14(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1255 <convert+0x115>
movsd  0xdc4(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jle    1279 <convert+0x139>
cvtsi2sdl -0x20(%rbp),%xmm0
cvtsi2sdl -0x18(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    129e <convert+0x15e>
movsd  0xd7f(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%eax
sub    -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jge    12af <convert+0x16f>
movl   $0x0,-0x3c(%rbp)
jmp    12b4 <convert+0x174>
lea    -0xc0(%rbp),%rdi
mov    -0x8(%rbp),%rdx
mov    $0x64,%esi
call   1050 <fgets@plt>
cmp    $0x0,%rax
jne    12d8 <convert+0x198>
jmp    12ff <convert+0x1bf>
jmp    12dd <convert+0x19d>
lea    -0xc0(%rbp),%rdi
lea    0xd55(%rip),%rsi
mov    $0x6,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    12b4 <convert+0x174>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    142e <convert+0x2ee>
lea    -0xc0(%rbp),%rdi
mov    -0x8(%rbp),%rdx
mov    $0x64,%esi
call   1050 <fgets@plt>
cmp    $0x0,%rax
jne    1336 <convert+0x1f6>
jmp    142e <convert+0x2ee>
jmp    133b <convert+0x1fb>
lea    -0xc0(%rbp),%rdi
lea    0xcfe(%rip),%rsi
lea    -0x48(%rbp),%rdx
mov    $0x0,%al
call   1060 <sscanf@plt>
cmp    $0x1,%eax
je     1362 <convert+0x222>
jmp    133b <convert+0x1fb>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    141b <convert+0x2db>
mov    -0x28(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    0x10(%rbp),%eax
sub    -0x38(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x30(%rbp)
xor    %eax,%eax
cmp    -0x2c(%rbp),%eax
jg     1408 <convert+0x2c8>
cmpl   $0x40,-0x2c(%rbp)
jg     1408 <convert+0x2c8>
xor    %eax,%eax
cmp    -0x30(%rbp),%eax
jg     1408 <convert+0x2c8>
cmpl   $0x40,-0x30(%rbp)
jg     1408 <convert+0x2c8>
mov    -0x48(%rbp),%rax
mov    %rax,-0x10d0(%rbp)
mov    $0x40,%eax
sub    -0x34(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    -0x10d0(%rbp),%rax
mov    %edx,%ecx
add    -0x34(%rbp),%ecx
sub    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
shr    %cl,%rax
and    $0x1,%rax
mov    %al,%dl
movslq -0x2c(%rbp),%rcx
lea    -0x10c0(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    140d <convert+0x2cd>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1369 <convert+0x229>
jmp    1420 <convert+0x2e0>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1306 <convert+0x1c6>
cmpl   $0x0,-0x38(%rbp)
jle    1639 <convert+0x4f9>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1634 <convert+0x4f4>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1621 <convert+0x4e1>
movq   $0x0,-0x48(%rbp)
cvtsi2sdl -0x28(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xb67(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x10d1(%rbp)
jge    14c6 <convert+0x386>
cmpl   $0x40,-0x2c(%rbp)
setl   %al
mov    %al,-0x10d1(%rbp)
mov    -0x10d1(%rbp),%al
test   $0x1,%al
jne    14d9 <convert+0x399>
jmp    1583 <convert+0x443>
cvtsi2sdl -0x24(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%ecx
mov    -0x24(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xb00(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x10d2(%rbp)
jge    152d <convert+0x3ed>
cmpl   $0x40,-0x30(%rbp)
setl   %al
mov    %al,-0x10d2(%rbp)
mov    -0x10d2(%rbp),%al
test   $0x1,%al
jne    1540 <convert+0x400>
jmp    1570 <convert+0x430>
movslq -0x2c(%rbp),%rcx
lea    -0x10c0(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14ea <convert+0x3aa>
jmp    1575 <convert+0x435>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1483 <convert+0x343>
movaps 0xa86(%rip),%xmm1
movq   -0x48(%rbp),%xmm0
punpckldq %xmm1,%xmm0
movapd 0xa85(%rip),%xmm1
subpd  %xmm1,%xmm0
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x2c(%rbp),%eax
cvtsi2sdl -0x28(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
cvttsd2si %xmm1,%ecx
sub    %ecx,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0x30(%rbp),%eax
cvtsi2sdl -0x24(%rbp),%xmm1
mulsd  -0x58(%rbp),%xmm1
cvttsd2si %xmm1,%ecx
sub    %ecx,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    160e <convert+0x4ce>
mov    -0x14(%rbp),%ecx
sub    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x1,%esi
shl    %cl,%esi
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
jmp    1613 <convert+0x4d3>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    145e <convert+0x31e>
jmp    1626 <convert+0x4e6>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    143f <convert+0x2ff>
jmp    1639 <convert+0x4f9>
add    $0x10e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<convert>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1108,%rsp
mov    %r9d,0x18(%rsp)
mov    %r8d,0x8(%rsp)
mov    %ecx,0x28(%rsp)
mov    %edx,0x10(%rsp)
mov    %rsi,0x50(%rsp)
mov    %rdi,0x20(%rsp)
mov    0x1148(%rsp),%r13d
lea    0x100(%rsp),%rdi
xor    %esi,%esi
mov    $0x1000,%edx
call   1040 <memset@plt>
lea    0x90(%rsp),%rbx
lea    0x38(%rsp),%rbp
lea    0x14(%rsp),%r12
lea    0x4(%rsp),%r14
lea    0x34(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%rdi
mov    $0x64,%esi
mov    0x20(%rsp),%rdx
call   1050 <fgets@plt>
test   %rax,%rax
je     11e9 <convert+0xa9>
mov    %rbx,%rdi
lea    0xeaf(%rip),%rsi
mov    %rbp,%rdx
mov    %r12,%rcx
mov    %r14,%r8
mov    %r15,%r9
xor    %eax,%eax
call   1060 <sscanf@plt>
cmp    $0x4,%eax
jne    11b0 <convert+0x70>
test   %r13d,%r13d
je     1227 <convert+0xe7>
mov    0x4(%rsp),%eax
add    0x38(%rsp),%eax
mov    0x8(%rsp),%esi
mov    %esi,%ecx
shr    $0x1f,%ecx
add    %esi,%ecx
sar    %ecx
cmp    %ecx,%eax
cmovle %ecx,%esi
mov    0x10(%rsp),%eax
mov    0x28(%rsp),%edx
mov    0x20(%rsp),%r13
cmp    %eax,%esi
jle    123c <convert+0xfc>
cvtsi2sd %esi,%xmm1
cvtsi2sd %eax,%xmm0
divsd  %xmm0,%xmm1
jmp    1253 <convert+0x113>
mov    0x10(%rsp),%eax
mov    0x28(%rsp),%edx
mov    0x20(%rsp),%r13
mov    0x8(%rsp),%esi
cmp    %eax,%esi
jg     1219 <convert+0xd9>
sub    %esi,%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
add    %ecx,0x4(%rsp)
movsd  0xdad(%rip),%xmm1
mov    0x18(%rsp),%ecx
mov    %edx,%eax
sub    %ecx,%eax
jge    1274 <convert+0x134>
cvtsi2sd %ecx,%xmm2
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
divsd  %xmm0,%xmm2
movsd  %xmm2,0x48(%rsp)
jmp    128f <convert+0x14f>
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
sub    %ecx,0x34(%rsp)
movsd  0xd77(%rip),%xmm0
movsd  %xmm0,0x48(%rsp)
movsd  %xmm1,0x18(%rsp)
cmpl   $0x0,0x4(%rsp)
jns    12a4 <convert+0x164>
movl   $0x0,0x4(%rsp)
lea    0x90(%rsp),%rbx
lea    0xddd(%rip),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbx,%rdi
mov    $0x64,%esi
mov    %r13,%rdx
call   1050 <fgets@plt>
test   %rax,%rax
je     12ea <convert+0x1aa>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0x6,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
jne    12c0 <convert+0x180>
cmpl   $0x0,0x14(%rsp)
jle    1af2 <convert+0x9b2>
lea    0x90(%rsp),%r12
lea    0xd93(%rip),%r14
lea    0x88(%rsp),%r15
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    0x1140(%rsp),%ebp
jmp    1342 <convert+0x202>
nopl   0x0(%rax)
mov    0x14(%rsp),%r8d
movsd  0x18(%rsp),%xmm11
mov    0x8(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x8(%rsp)
cmp    %r8d,%eax
jge    16fe <convert+0x5be>
mov    %r12,%rdi
mov    $0x64,%esi
mov    %r13,%rdx
call   1050 <fgets@plt>
test   %rax,%rax
je     16f2 <convert+0x5b2>
nopl   0x0(%rax,%rax,1)
mov    %r12,%rdi
mov    %r14,%rsi
mov    %r15,%rdx
xor    %eax,%eax
call   1060 <sscanf@plt>
cmp    $0x1,%eax
jne    1360 <convert+0x220>
mov    0x38(%rsp),%esi
test   %esi,%esi
jle    1320 <convert+0x1e0>
mov    0x4(%rsp),%edi
mov    0x14(%rsp),%r8d
mov    0x8(%rsp),%rax
lea    (%rax,%rbp,1),%ebx
mov    0x34(%rsp),%eax
add    %r8d,%eax
sub    %eax,%ebx
mov    $0x40,%r10d
sub    %esi,%r10d
mov    $0x47,%eax
sub    %esi,%eax
test   %r10d,%r10d
cmovns %r10d,%eax
mov    0x88(%rsp),%r11
and    $0xfffffff8,%eax
sub    %eax,%r10d
cmp    $0x8,%esi
movsd  0x18(%rsp),%xmm11
movdqa 0xc61(%rip),%xmm10
movdqa 0xc68(%rip),%xmm12
movdqa 0xc6f(%rip),%xmm13
jb     1680 <convert+0x540>
lea    -0x1(%rsi),%rax
mov    %edi,%ecx
add    %eax,%ecx
jb     1680 <convert+0x540>
shr    $0x20,%rax
mov    $0x0,%r9d
jne    1683 <convert+0x543>
xor    %eax,%eax
cmp    $0x41,%ebx
setl   %al
xor    %ecx,%ecx
test   %ebx,%ebx
setns  %cl
mov    %esi,%r9d
and    $0xfffffff8,%r9d
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm8
movd   %ecx,%xmm1
pshuflw $0x0,%xmm1,%xmm1
pshufd $0x0,%xmm1,%xmm9
movd   %eax,%xmm2
pshuflw $0x0,%xmm2,%xmm2
pshufd $0x0,%xmm2,%xmm2
lea    (%rsi,%r10,1),%r13d
add    $0xffffffff,%r13d
xor    %ebp,%ebp
movdqa 0xbcc(%rip),%xmm3
movdqa 0xbb4(%rip),%xmm4
jmp    147b <convert+0x33b>
xchg   %ax,%ax
add    $0x8,%rbp
paddd  %xmm13,%xmm3
paddd  %xmm13,%xmm4
add    $0xfffffff8,%r13d
cmp    %rbp,%r9
je     16db <convert+0x59b>
movdqa %xmm8,%xmm5
paddd  %xmm4,%xmm5
movdqa %xmm8,%xmm0
paddd  %xmm3,%xmm0
movdqa %xmm0,%xmm7
pxor   %xmm10,%xmm7
movdqa %xmm12,%xmm6
pcmpgtd %xmm7,%xmm6
movdqa %xmm5,%xmm7
pxor   %xmm10,%xmm7
movdqa %xmm12,%xmm1
pcmpgtd %xmm7,%xmm1
packssdw %xmm1,%xmm6
pand   %xmm9,%xmm6
pand   %xmm2,%xmm6
movd   %xmm6,%edx
test   $0x1,%dl
je     14e7 <convert+0x3a7>
mov    %r11,%rax
mov    %r13d,%ecx
shr    %cl,%rax
and    $0x1,%al
movd   %xmm0,%ecx
shl    $0x6,%rcx
add    %rsp,%rcx
add    $0x100,%rcx
mov    %al,(%rbx,%rcx,1)
shr    $0x10,%edx
test   $0x1,%dl
je     151e <convert+0x3de>
mov    %ebp,%ecx
xor    $0xfe,%ecx
add    %esi,%ecx
add    %r10d,%ecx
mov    %r11,%rax
shr    %cl,%rax
and    $0x1,%al
pshufd $0x55,%xmm0,%xmm1
movd   %xmm1,%ecx
shl    $0x6,%rcx
add    %rsp,%rcx
add    $0x100,%rcx
mov    %al,(%rbx,%rcx,1)
pextrw $0x2,%xmm6,%eax
test   $0x1,%al
je     1556 <convert+0x416>
mov    %ebp,%ecx
xor    $0xfd,%ecx
add    %esi,%ecx
add    %r10d,%ecx
mov    %r11,%rax
shr    %cl,%rax
and    $0x1,%al
pshufd $0xee,%xmm0,%xmm1
movd   %xmm1,%ecx
shl    $0x6,%rcx
add    %rsp,%rcx
add    $0x100,%rcx
mov    %al,(%rbx,%rcx,1)
pextrw $0x3,%xmm6,%eax
test   $0x1,%al
je     158e <convert+0x44e>
mov    %ebp,%ecx
xor    $0xfc,%ecx
add    %esi,%ecx
add    %r10d,%ecx
mov    %r11,%rax
shr    %cl,%rax
and    $0x1,%al
pshufd $0xff,%xmm0,%xmm0
movd   %xmm0,%ecx
shl    $0x6,%rcx
add    %rsp,%rcx
add    $0x100,%rcx
mov    %al,(%rbx,%rcx,1)
pextrw $0x4,%xmm6,%eax
test   $0x1,%al
je     15c1 <convert+0x481>
mov    %ebp,%ecx
xor    $0xfb,%ecx
add    %esi,%ecx
add    %r10d,%ecx
mov    %r11,%rax
shr    %cl,%rax
and    $0x1,%al
movd   %xmm5,%ecx
shl    $0x6,%rcx
add    %rsp,%rcx
add    $0x100,%rcx
mov    %al,(%rbx,%rcx,1)
pextrw $0x5,%xmm6,%eax
test   $0x1,%al
je     15f9 <convert+0x4b9>
mov    %ebp,%ecx
xor    $0xfa,%ecx
add    %esi,%ecx
add    %r10d,%ecx
mov    %r11,%rax
shr    %cl,%rax
and    $0x1,%al
pshufd $0x55,%xmm5,%xmm0
movd   %xmm0,%ecx
shl    $0x6,%rcx
add    %rsp,%rcx
add    $0x100,%rcx
mov    %al,(%rbx,%rcx,1)
pextrw $0x6,%xmm6,%eax
test   $0x1,%al
je     1631 <convert+0x4f1>
mov    %ebp,%ecx
xor    $0xf9,%ecx
add    %esi,%ecx
add    %r10d,%ecx
mov    %r11,%rax
shr    %cl,%rax
and    $0x1,%al
pshufd $0xee,%xmm5,%xmm0
movd   %xmm0,%ecx
shl    $0x6,%rcx
add    %rsp,%rcx
add    $0x100,%rcx
mov    %al,(%rbx,%rcx,1)
pextrw $0x7,%xmm6,%eax
test   $0x1,%al
je     1460 <convert+0x320>
mov    %ebp,%ecx
xor    $0xf8,%ecx
add    %esi,%ecx
add    %r10d,%ecx
mov    %r11,%rax
shr    %cl,%rax
and    $0x1,%al
pshufd $0xff,%xmm5,%xmm0
movd   %xmm0,%ecx
shl    $0x6,%rcx
add    %rsp,%rcx
add    $0x100,%rcx
mov    %al,(%rbx,%rcx,1)
jmp    1460 <convert+0x320>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %r9d,%r9d
add    %r9d,%edi
add    %esi,%r10d
mov    %r9d,%ecx
not    %ecx
add    %r10d,%ecx
sub    %r9,%rsi
jmp    16b0 <convert+0x570>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%edi
add    $0xffffffff,%ecx
add    $0xffffffffffffffff,%rsi
je     132c <convert+0x1ec>
cmp    $0x40,%edi
ja     16a0 <convert+0x560>
test   %ebx,%ebx
js     16a0 <convert+0x560>
cmp    $0x40,%ebx
jg     16a0 <convert+0x560>
mov    %r11,%rax
shr    %cl,%rax
and    $0x1,%al
mov    %edi,%edx
shl    $0x6,%rdx
add    %rsp,%rdx
add    $0x100,%rdx
mov    %al,(%rbx,%rdx,1)
jmp    16a0 <convert+0x560>
cmp    %rsi,%r9
mov    0x20(%rsp),%r13
mov    0x1140(%rsp),%ebp
je     132c <convert+0x1ec>
jmp    1683 <convert+0x543>
mov    0x14(%rsp),%r8d
movsd  0x18(%rsp),%xmm11
test   %r8d,%r8d
mov    0x10(%rsp),%r9d
mov    0x28(%rsp),%eax
jle    1af2 <convert+0x9b2>
test   %eax,%eax
jle    1af2 <convert+0x9b2>
mov    %eax,%eax
mov    %rax,0x58(%rsp)
xor    %r15d,%r15d
movsd  0x8de(%rip),%xmm0
movsd  0x8cd(%rip),%xmm8
xorpd  %xmm2,%xmm2
movdqa 0x920(%rip),%xmm9
movapd 0x927(%rip),%xmm10
pxor   %xmm5,%xmm5
jmp    1763 <convert+0x623>
nop
mov    0x60(%rsp),%rax
mov    %rax,%r15
cmp    0x58(%rsp),%rax
je     1af2 <convert+0x9b2>
mov    0x50(%rsp),%rax
movb   $0x0,(%rax,%r15,1)
test   %r9d,%r9d
jle    1ae0 <convert+0x9a0>
xorps  %xmm1,%xmm1
cvtsi2sd %r15d,%xmm1
movsd  0x48(%rsp),%xmm3
mulsd  %xmm3,%xmm1
cvttsd2si %xmm1,%r10d
lea    0x1(%r15),%rax
mov    %rax,0x60(%rsp)
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%eax
cmp    %eax,%r10d
setl   %cl
cmp    $0x40,%r10d
setl   %r8b
and    %cl,%r8b
movslq %r10d,%rcx
movslq %eax,%rdi
mov    %rcx,%rax
not    %rax
add    %rdi,%rax
mov    $0x3f,%ebp
sub    %rcx,%rbp
cmp    %rbp,%rax
cmovb  %rax,%rbp
lea    0x1(%rbp),%r11
add    $0xfffffffffffffffd,%rbp
mov    %rbp,0x20(%rsp)
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %r11,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x28(%rsp)
add    %rcx,%rax
mov    %rax,0x68(%rsp)
mov    %rbp,%rax
mov    %rbp,0x18(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0x80(%rsp)
lea    0x106(%rsp),%rax
mov    %rcx,0x8(%rsp)
add    %rcx,%rax
mov    %rax,0x70(%rsp)
xor    %r12d,%r12d
pxor   %xmm6,%xmm6
xor    %ecx,%ecx
mov    %r15,0x78(%rsp)
jmp    184b <convert+0x70b>
nopw   0x0(%rax,%rax,1)
mov    %esi,%ecx
cmp    %r9d,%esi
je     1750 <convert+0x610>
movapd %xmm11,%xmm1
mulsd  %xmm6,%xmm1
cvttsd2si %xmm1,%edx
addsd  %xmm8,%xmm6
lea    0x1(%rcx),%esi
xorps  %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
mulsd  %xmm11,%xmm1
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%ebp
cmp    %ebp,%edx
jge    1a70 <convert+0x930>
mov    $0x0,%r14d
mov    %edx,%eax
cmp    $0x3f,%edx
jg     1a75 <convert+0x935>
mov    %esi,0x40(%rsp)
mov    %r12d,0x44(%rsp)
mov    %edx,0x3c(%rsp)
movslq %edx,%r9
movslq %ebp,%r13
mov    %r9,%rax
shl    $0x6,%rax
mov    0x70(%rsp),%rbx
lea    (%rbx,%rax,1),%r12
lea    (%rsp,%rax,1),%r15
add    $0x100,%r15
xor    %r14d,%r14d
mov    0x68(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r8b,%r8b
je     18f0 <convert+0x7b0>
cmp    $0x4,%r11
jae    1900 <convert+0x7c0>
mov    0x8(%rsp),%rax
jmp    1a10 <convert+0x8d0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r10d,%ebx
jmp    1a30 <convert+0x8f0>
nopl   0x0(%rax,%rax,1)
movq   %r14,%xmm7
cmpq   $0x4,0x20(%rsp)
jae    1918 <convert+0x7d8>
xorpd  %xmm1,%xmm1
xor    %ebx,%ebx
jmp    19a1 <convert+0x861>
xorpd  %xmm1,%xmm1
mov    0x80(%rsp),%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movzwl -0x6(%r12,%rbx,1),%ebp
movd   %ebp,%xmm4
movzwl -0x4(%r12,%rbx,1),%ebp
movd   %ebp,%xmm3
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
punpckldq %xmm2,%xmm4
paddq  %xmm7,%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
punpckldq %xmm2,%xmm3
paddq  %xmm1,%xmm3
movzwl -0x2(%r12,%rbx,1),%ebp
movd   %ebp,%xmm7
movzwl (%r12,%rbx,1),%ebp
movd   %ebp,%xmm1
punpcklbw %xmm2,%xmm7
punpcklwd %xmm2,%xmm7
punpckldq %xmm2,%xmm7
paddq  %xmm4,%xmm7
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
punpckldq %xmm2,%xmm1
paddq  %xmm3,%xmm1
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rax
jne    1930 <convert+0x7f0>
testb  $0x1,0x18(%rsp)
je     19ee <convert+0x8ae>
add    0x8(%rsp),%rbx
mov    %r9,%rax
shl    $0x6,%rax
add    %rsp,%rax
add    $0x100,%rax
movzwl (%rax,%rbx,1),%ebp
movd   %ebp,%xmm3
movzwl 0x2(%rax,%rbx,1),%eax
movd   %eax,%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
punpckldq %xmm2,%xmm3
paddq  %xmm3,%xmm7
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
punpckldq %xmm2,%xmm4
paddq  %xmm4,%xmm1
paddq  %xmm1,%xmm7
pshufd $0xee,%xmm7,%xmm1
paddq  %xmm7,%xmm1
movq   %xmm1,%r14
mov    %rdx,%rax
mov    %rdx,%rbx
cmp    0x28(%rsp),%r11
je     1a30 <convert+0x8f0>
nopl   (%rax)
mov    %r14,%rbx
movzbl (%r15,%rax,1),%r14d
add    %rbx,%r14
lea    0x1(%rax),%rbx
cmp    %rdi,%rbx
jge    1a30 <convert+0x8f0>
cmp    $0x3f,%rax
mov    %rbx,%rax
jl     1a10 <convert+0x8d0>
nopl   (%rax)
lea    0x1(%r9),%rax
cmp    %r13,%rax
jge    1a4e <convert+0x90e>
add    $0x40,%r12
add    $0x40,%r15
cmp    $0x3f,%r9
mov    %rax,%r9
jl     18d0 <convert+0x790>
mov    0x10(%rsp),%r9d
mov    0x78(%rsp),%r15
mov    0x44(%rsp),%r12d
mov    0x40(%rsp),%esi
mov    0x3c(%rsp),%edx
jmp    1a75 <convert+0x935>
nopw   0x0(%rax,%rax,1)
xor    %r14d,%r14d
mov    %edx,%eax
movq   %r14,%xmm1
punpckldq %xmm9,%xmm1
subpd  %xmm10,%xmm1
movapd %xmm1,%xmm3
unpckhpd %xmm1,%xmm3
sub    %edx,%eax
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
addsd  %xmm1,%xmm3
mov    %ebx,%eax
sub    %r10d,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
divsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
ucomisd %xmm5,%xmm1
jbe    1840 <convert+0x700>
not    %ecx
add    %r9d,%ecx
mov    $0x1,%eax
shl    %cl,%eax
or     %al,%r12b
mov    0x50(%rsp),%rax
mov    %r12b,(%rax,%r15,1)
jmp    1840 <convert+0x700>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r15
mov    %r15,%rax
cmp    0x58(%rsp),%rax
jne    1763 <convert+0x623>
add    $0x1108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [16 x i8] c"BBX %d %d %d %d\00"
@.str.1 = [7 x i8] c"BITMAP\00"
@.str.2 = [5 x i8] c"%llx\00"
define void @convert(i32* %0, i8* %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i32 %7) {
%9 = alloca i32*
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%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
%25 = alloca i64
%26 = alloca double
%27 = alloca double
%28 = alloca [100 x i8]
%29 = alloca [64 x [64 x i8]]
store i32* %0, i32** %9
store i8* %1, i8** %10
store i32 %2, i32* %11
store i32 %3, i32* %12
store i32 %4, i32* %13
store i32 %5, i32* %14
store i32 %6, i32* %15
store i32 %7, i32* %16
%30 = getelementptr inbounds [64 x [64 x i8]], [64 x [64 x i8]]* %29, i64 0, i64 0
%31 = bitcast [64 x i8]* %30 to i8**
%32 = call i32 @memset(i8** %31, i32 0, i32 4096)
br label %33
33: ; preds = %40, %8
%34 = getelementptr inbounds [100 x i8], [100 x i8]* %28, i64 0, i64 0
%35 = load i32*, i32** %9
%36 = call i32* @fgets(i8* %34, i32 100, i32* %35)
%37 = icmp eq i32* %36, null
br i1 %37, label %38, label %39
38: ; preds = %33
br label %44
39: ; preds = %33
br label %40
40: ; preds = %39
%41 = getelementptr inbounds [100 x i8], [100 x i8]* %28, i64 0, i64 0
%42 = call i32 (i8*, i8*, ...) @sscanf(i8* %41, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0), i32* %21, i32* %22, i32* %23, i32* %24)
%43 = icmp ne i32 %42, 4
br i1 %43, label %33, label %44
44: ; preds = %40, %38
%45 = load i32, i32* %16
%46 = icmp ne i32 %45, 0
br i1 %46, label %47, label %57
47: ; preds = %44
%48 = load i32, i32* %21
%49 = load i32, i32* %23
%50 = add nsw i32 %48, %49
%51 = load i32, i32* %13
%52 = sdiv i32 %51, 2
%53 = icmp sle i32 %50, %52
br i1 %53, label %54, label %57
54: ; preds = %47
%55 = load i32, i32* %13
%56 = sdiv i32 %55, 2
store i32 %56, i32* %13
br label %57
57: ; preds = %54, %47, %44
%58 = load i32, i32* %13
%59 = load i32, i32* %11
%60 = icmp sgt i32 %58, %59
br i1 %60, label %61, label %67
61: ; preds = %57
%62 = load i32, i32* %13
%63 = sitofp i32 %62 to double
%64 = load i32, i32* %11
%65 = sitofp i32 %64 to double
%66 = fdiv double %63, %65
store double %66, double* %26
br label %74
67: ; preds = %57
store double 1.000000e+00, double* %26
%68 = load i32, i32* %11
%69 = load i32, i32* %13
%70 = sub nsw i32 %68, %69
%71 = sdiv i32 %70, 2
%72 = load i32, i32* %23
%73 = add nsw i32 %72, %71
store i32 %73, i32* %23
br label %74
74: ; preds = %67, %61
%75 = load i32, i32* %14
%76 = load i32, i32* %12
%77 = icmp sgt i32 %75, %76
br i1 %77, label %78, label %84
78: ; preds = %74
%79 = load i32, i32* %14
%80 = sitofp i32 %79 to double
%81 = load i32, i32* %12
%82 = sitofp i32 %81 to double
%83 = fdiv double %80, %82
store double %83, double* %27
br label %91
84: ; preds = %74
store double 1.000000e+00, double* %27
%85 = load i32, i32* %12
%86 = load i32, i32* %14
%87 = sub nsw i32 %85, %86
%88 = sdiv i32 %87, 2
%89 = load i32, i32* %24
%90 = sub nsw i32 %89, %88
store i32 %90, i32* %24
br label %91
91: ; preds = %84, %78
%92 = load i32, i32* %23
%93 = icmp slt i32 %92, 0
br i1 %93, label %94, label %95
94: ; preds = %91
store i32 0, i32* %23
br label %95
95: ; preds = %94, %91
br label %96
96: ; preds = %103, %95
%97 = getelementptr inbounds [100 x i8], [100 x i8]* %28, i64 0, i64 0
%98 = load i32*, i32** %9
%99 = call i32* @fgets(i8* %97, i32 100, i32* %98)
%100 = icmp eq i32* %99, null
br i1 %100, label %101, label %102
101: ; preds = %96
br label %107
102: ; preds = %96
br label %103
103: ; preds = %102
%104 = getelementptr inbounds [100 x i8], [100 x i8]* %28, i64 0, i64 0
%105 = call i64 @strncmp(i8* %104, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 6)
%106 = icmp ne i64 %105, 0
br i1 %106, label %96, label %107
107: ; preds = %103, %101
store i32 0, i32* %17
br label %108
108: ; preds = %176, %107
%109 = load i32, i32* %17
%110 = load i32, i32* %22
%111 = icmp slt i32 %109, %110
br i1 %111, label %112, label %179
112: ; preds = %108
%113 = getelementptr inbounds [100 x i8], [100 x i8]* %28, i64 0, i64 0
%114 = load i32*, i32** %9
%115 = call i32* @fgets(i8* %113, i32 100, i32* %114)
%116 = icmp eq i32* %115, null
br i1 %116, label %117, label %118
117: ; preds = %112
br label %179
118: ; preds = %112
br label %119
119: ; preds = %123, %118
%120 = getelementptr inbounds [100 x i8], [100 x i8]* %28, i64 0, i64 0
%121 = call i32 (i8*, i8*, ...) @sscanf(i8* %120, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i64* %25)
%122 = icmp ne i32 %121, 1
br i1 %122, label %123, label %124
123: ; preds = %119
br label %119
124: ; preds = %119
store i32 0, i32* %18
br label %125
125: ; preds = %172, %124
%126 = load i32, i32* %18
%127 = load i32, i32* %21
%128 = icmp slt i32 %126, %127
br i1 %128, label %129, label %175
129: ; preds = %125
%130 = load i32, i32* %18
%131 = load i32, i32* %23
%132 = add nsw i32 %130, %131
store i32 %132, i32* %19
%133 = load i32, i32* %17
%134 = load i32, i32* %15
%135 = add nsw i32 %133, %134
%136 = load i32, i32* %22
%137 = sub nsw i32 %135, %136
%138 = load i32, i32* %24
%139 = sub nsw i32 %137, %138
store i32 %139, i32* %20
%140 = load i32, i32* %19
%141 = icmp sle i32 0, %140
br i1 %141, label %142, label %171
142: ; preds = %129
%143 = load i32, i32* %19
%144 = icmp sle i32 %143, 64
br i1 %144, label %145, label %171
145: ; preds = %142
%146 = load i32, i32* %20
%147 = icmp sle i32 0, %146
br i1 %147, label %148, label %171
148: ; preds = %145
%149 = load i32, i32* %20
%150 = icmp sle i32 %149, 64
br i1 %150, label %151, label %171
151: ; preds = %148
%152 = load i64, i64* %25
%153 = load i32, i32* %21
%154 = sub nsw i32 64, %153
%155 = srem i32 %154, 8
%156 = load i32, i32* %21
%157 = add nsw i32 %155, %156
%158 = load i32, i32* %18
%159 = sub nsw i32 %157, %158
%160 = sub nsw i32 %159, 1
%161 = zext i32 %160 to i64
%162 = lshr i64 %152, %161
%163 = and i64 %162, 1
%164 = trunc i64 %163 to i8
%165 = load i32, i32* %19
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds [64 x [64 x i8]], [64 x [64 x i8]]* %29, i64 0, i64 %166
%168 = load i32, i32* %20
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds [64 x i8], [64 x i8]* %167, i64 0, i64 %169
store i8 %164, i8* %170
br label %171
171: ; preds = %151, %148, %145, %142, %129
br label %172
172: ; preds = %171
%173 = load i32, i32* %18
%174 = add nsw i32 %173, 1
store i32 %174, i32* %18
br label %125
175: ; preds = %125
br label %176
176: ; preds = %175
%177 = load i32, i32* %17
%178 = add nsw i32 %177, 1
store i32 %178, i32* %17
br label %108
179: ; preds = %117, %108
%180 = load i32, i32* %22
%181 = icmp sgt i32 %180, 0
br i1 %181, label %182, label %299
182: ; preds = %179
store i32 0, i32* %17
br label %183
183: ; preds = %295, %182
%184 = load i32, i32* %17
%185 = load i32, i32* %12
%186 = icmp slt i32 %184, %185
br i1 %186, label %187, label %298
187: ; preds = %183
%188 = load i8*, i8** %10
%189 = load i32, i32* %17
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i8, i8* %188, i64 %190
store i8 0, i8* %191
store i32 0, i32* %18
br label %192
192: ; preds = %291, %187
%193 = load i32, i32* %18
%194 = load i32, i32* %11
%195 = icmp slt i32 %193, %194
br i1 %195, label %196, label %294
196: ; preds = %192
store i64 0, i64* %25
%197 = load i32, i32* %18
%198 = sitofp i32 %197 to double
%199 = load double, double* %26
%200 = fmul double %198, %199
%201 = fptosi double %200 to i32
store i32 %201, i32* %19
br label %202
202: ; preds = %251, %196
%203 = load i32, i32* %19
%204 = load i32, i32* %18
%205 = add nsw i32 %204, 1
%206 = sitofp i32 %205 to double
%207 = load double, double* %26
%208 = call double @llvm.fmuladd.f64(double %206, double %207, double 1.000000e-02)
%209 = fptosi double %208 to i32
%210 = icmp slt i32 %203, %209
br i1 %210, label %211, label %214
211: ; preds = %202
%212 = load i32, i32* %19
%213 = icmp slt i32 %212, 64
br label %214
214: ; preds = %211, %202
%215 = phi i1 [ false, %202 ], [ %213, %211 ]
br i1 %215, label %216, label %254
216: ; preds = %214
%217 = load i32, i32* %17
%218 = sitofp i32 %217 to double
%219 = load double, double* %27
%220 = fmul double %218, %219
%221 = fptosi double %220 to i32
store i32 %221, i32* %20
br label %222
222: ; preds = %247, %216
%223 = load i32, i32* %20
%224 = load i32, i32* %17
%225 = add nsw i32 %224, 1
%226 = sitofp i32 %225 to double
%227 = load double, double* %27
%228 = call double @llvm.fmuladd.f64(double %226, double %227, double 1.000000e-02)
%229 = fptosi double %228 to i32
%230 = icmp slt i32 %223, %229
br i1 %230, label %231, label %234
231: ; preds = %222
%232 = load i32, i32* %20
%233 = icmp slt i32 %232, 64
br label %234
234: ; preds = %231, %222
%235 = phi i1 [ false, %222 ], [ %233, %231 ]
br i1 %235, label %236, label %250
236: ; preds = %234
%237 = load i32, i32* %19
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds [64 x [64 x i8]], [64 x [64 x i8]]* %29, i64 0, i64 %238
%240 = load i32, i32* %20
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds [64 x i8], [64 x i8]* %239, i64 0, i64 %241
%243 = load i8, i8* %242
%244 = zext i8 %243 to i64
%245 = load i64, i64* %25
%246 = add i64 %245, %244
store i64 %246, i64* %25
br label %247
247: ; preds = %236
%248 = load i32, i32* %20
%249 = add nsw i32 %248, 1
store i32 %249, i32* %20
br label %222
250: ; preds = %234
br label %251
251: ; preds = %250
%252 = load i32, i32* %19
%253 = add nsw i32 %252, 1
store i32 %253, i32* %19
br label %202
254: ; preds = %214
%255 = load i64, i64* %25
%256 = uitofp i64 %255 to double
%257 = load i32, i32* %19
%258 = load i32, i32* %18
%259 = sitofp i32 %258 to double
%260 = load double, double* %26
%261 = fmul double %259, %260
%262 = fptosi double %261 to i32
%263 = sub nsw i32 %257, %262
%264 = sitofp i32 %263 to double
%265 = fdiv double %256, %264
%266 = load i32, i32* %20
%267 = load i32, i32* %17
%268 = sitofp i32 %267 to double
%269 = load double, double* %27
%270 = fmul double %268, %269
%271 = fptosi double %270 to i32
%272 = sub nsw i32 %266, %271
%273 = sitofp i32 %272 to double
%274 = fmul double %265, %273
%275 = fcmp ogt double %274, 0.000000e+00
br i1 %275, label %276, label %290
276: ; preds = %254
%277 = load i32, i32* %11
%278 = load i32, i32* %18
%279 = sub nsw i32 %277, %278
%280 = sub nsw i32 %279, 1
%281 = shl i32 1, %280
%282 = load i8*, i8** %10
%283 = load i32, i32* %17
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds i8, i8* %282, i64 %284
%286 = load i8, i8* %285
%287 = zext i8 %286 to i32
%288 = or i32 %287, %281
%289 = trunc i32 %288 to i8
store i8 %289, i8* %285
br label %290
290: ; preds = %276, %254
br label %291
291: ; preds = %290
%292 = load i32, i32* %18
%293 = add nsw i32 %292, 1
store i32 %293, i32* %18
br label %192
294: ; preds = %192
br label %295
295: ; preds = %294
%296 = load i32, i32* %17
%297 = add nsw i32 %296, 1
store i32 %297, i32* %17
br label %183
298: ; preds = %183
br label %299
299: ; preds = %298, %179
ret void
}

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