#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 uint8_t;

/* Variables and functions */
size_t strlen(char *);
char *number(char *dest, char *str_num, uint8_t flags, unsigned long width,
             long precision, bool negative, char specifier) {
  char *buf = dest;
  char sign = 0;
  if (flags & (0x4))
    sign = ' ';
  if (flags & (0x2))
    sign = '+';
  if (negative)
    sign = '-';
  char padding = ' ';
  if (flags & (0x10))
    padding = '0';
  char octal = 0;
  char hex[2];
  *hex = '\0';
  if (flags & (0x8)) {
    if (specifier == 'o')
      octal = '0';
    else if (specifier == 'x' || specifier == 'p') {
      hex[0] = '0';
      hex[1] = 'x';
    } else if (specifier == 'X') {
      hex[0] = '0';
      hex[1] = 'X';
    }
  }
  size_t len = strlen(str_num);
  size_t working_len = len;
  size_t precision_len = 0;
  if (sign != 0)
    ++working_len;
  if (octal != 0)
    ++working_len;
  if (*hex != '\0')
    working_len += 2;
  if (precision >= 0) {
    if (specifier == 's' && len > (unsigned int)precision) {
      working_len = len = precision;
    } else if (len < (unsigned int)precision) {
      precision_len = precision - len;
      working_len += precision_len;
    }
  }
  if ((flags & (0x1)) && padding == ' ') {
    if (sign != 0)
      *buf++ = sign;
    if (octal != 0)
      *buf++ = octal;
    if (*hex != '\0') {
      *buf++ = *hex;
      *buf++ = *(hex + 1);
    }
    for (unsigned int i = 0; i < precision_len; i++)
      *buf++ = '0';
    for (size_t i = 0; i < len; i++)
      *buf++ = str_num[i];
    for (; working_len < width; working_len++)
      *buf++ = padding;
  } else if (padding == '0') {
    if (sign != 0)
      *buf++ = sign;
    if (octal != 0)
      *buf++ = octal;
    if (*hex != '\0') {
      *buf++ = *hex;
      *buf++ = *(hex + 1);
    }
    for (unsigned int i = 0; i < precision_len; i++)
      *buf++ = '0';
    for (; working_len < width; working_len++)
      *buf++ = padding;
    for (size_t i = 0; i < len; i++)
      *buf++ = str_num[i];
  } else {
    for (; working_len < width; working_len++)
      *buf++ = padding;
    if (sign != 0)
      *buf++ = sign;
    if (octal != 0)
      *buf++ = octal;
    if (*hex != '\0') {
      *buf++ = *hex;
      *buf++ = *(hex + 1);
    }
    for (unsigned int i = 0; i < precision_len; i++)
      *buf++ = '0';
    for (size_t i = 0; i < len; i++)
      *buf++ = str_num[i];
  }
  *buf = '\0';
  return (buf);
}


x86 assembly (clang, -O0):
<number>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x10(%rbp),%al
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
movb   $0x0,-0x39(%rbp)
mov    -0x14(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     1154 <number+0x44>
movb   $0x20,-0x39(%rbp)
mov    -0x14(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     1167 <number+0x57>
movb   $0x2b,-0x39(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1175 <number+0x65>
movb   $0x2d,-0x39(%rbp)
movb   $0x20,-0x3a(%rbp)
mov    -0x14(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     118c <number+0x7c>
movb   $0x30,-0x3a(%rbp)
movb   $0x0,-0x3b(%rbp)
movb   $0x0,-0x3d(%rbp)
mov    -0x14(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     1204 <number+0xf4>
movsbl 0x10(%rbp),%eax
cmp    $0x6f,%eax
jne    11b9 <number+0xa9>
movb   $0x30,-0x3b(%rbp)
jmp    11ff <number+0xef>
movsbl 0x10(%rbp),%eax
cmp    $0x78,%eax
je     11d3 <number+0xc3>
movsbl 0x10(%rbp),%eax
cmp    $0x70,%eax
jne    11e0 <number+0xd0>
movb   $0x30,-0x3d(%rbp)
movb   $0x78,-0x3c(%rbp)
jmp    11fa <number+0xea>
movsbl 0x10(%rbp),%eax
cmp    $0x58,%eax
jne    11f5 <number+0xe5>
movb   $0x30,-0x3d(%rbp)
movb   $0x58,-0x3c(%rbp)
jmp    11fa <number+0xea>
jmp    11ff <number+0xef>
jmp    1204 <number+0xf4>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
movq   $0x0,-0x58(%rbp)
movsbl -0x39(%rbp),%eax
cmp    $0x0,%eax
je     123a <number+0x12a>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
movsbl -0x3b(%rbp),%eax
cmp    $0x0,%eax
je     1253 <number+0x143>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
movsbl -0x3d(%rbp),%eax
cmp    $0x0,%eax
je     126c <number+0x15c>
mov    -0x50(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x50(%rbp)
cmpq   $0x0,-0x28(%rbp)
jl     12dd <number+0x1cd>
movsbl 0x10(%rbp),%eax
cmp    $0x73,%eax
jne    12a8 <number+0x198>
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %ecx,%ecx
cmp    %rcx,%rax
jbe    12a8 <number+0x198>
mov    -0x28(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    %rax,-0x50(%rbp)
jmp    12d8 <number+0x1c8>
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %ecx,%ecx
cmp    %rcx,%rax
jae    12d3 <number+0x1c3>
mov    -0x28(%rbp),%rax
sub    -0x48(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    12d8 <number+0x1c8>
jmp    12dd <number+0x1cd>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1424 <number+0x314>
movsbl -0x3a(%rbp),%eax
cmp    $0x20,%eax
jne    1424 <number+0x314>
movsbl -0x39(%rbp),%eax
cmp    $0x0,%eax
je     131a <number+0x20a>
mov    -0x39(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
movsbl -0x3b(%rbp),%eax
cmp    $0x0,%eax
je     133b <number+0x22b>
mov    -0x3b(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
movsbl -0x3d(%rbp),%eax
cmp    $0x0,%eax
je     1370 <number+0x260>
mov    -0x3d(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x58(%rbp),%rax
jae    13a4 <number+0x294>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x30,(%rax)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1377 <number+0x267>
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    13e7 <number+0x2d7>
mov    -0x10(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    13ac <number+0x29c>
jmp    13ec <number+0x2dc>
mov    -0x50(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    141f <number+0x30f>
mov    -0x3a(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    13ec <number+0x2dc>
jmp    169b <number+0x58b>
movsbl -0x3a(%rbp),%eax
cmp    $0x30,%eax
jne    155c <number+0x44c>
movsbl -0x39(%rbp),%eax
cmp    $0x0,%eax
je     1452 <number+0x342>
mov    -0x39(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
movsbl -0x3b(%rbp),%eax
cmp    $0x0,%eax
je     1473 <number+0x363>
mov    -0x3b(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
movsbl -0x3d(%rbp),%eax
cmp    $0x0,%eax
je     14a8 <number+0x398>
mov    -0x3d(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x58(%rbp),%rax
jae    14dc <number+0x3cc>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x30,(%rax)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    14af <number+0x39f>
jmp    14e1 <number+0x3d1>
mov    -0x50(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1514 <number+0x404>
mov    -0x3a(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    14e1 <number+0x3d1>
movq   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1557 <number+0x447>
mov    -0x10(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    151c <number+0x40c>
jmp    1696 <number+0x586>
jmp    1561 <number+0x451>
mov    -0x50(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1594 <number+0x484>
mov    -0x3a(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1561 <number+0x451>
movsbl -0x39(%rbp),%eax
cmp    $0x0,%eax
je     15b5 <number+0x4a5>
mov    -0x39(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
movsbl -0x3b(%rbp),%eax
cmp    $0x0,%eax
je     15d6 <number+0x4c6>
mov    -0x3b(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
movsbl -0x3d(%rbp),%eax
cmp    $0x0,%eax
je     160b <number+0x4fb>
mov    -0x3d(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x58(%rbp),%rax
jae    163f <number+0x52f>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x30,(%rax)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1612 <number+0x502>
movq   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1691 <number+0x581>
mov    -0x10(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    164a <number+0x53a>
jmp    1696 <number+0x586>
jmp    169b <number+0x58b>
mov    -0x38(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x38(%rbp),%rax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<number>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8,%r15
mov    %rcx,0x20(%rsp)
mov    %rsi,%r14
mov    %rdi,%rbx
mov    0x60(%rsp),%sil
mov    %edx,%r13d
lea    0x0(,%r13,8),%eax
and    $0x20,%al
test   $0x2,%dl
movzbl %al,%eax
mov    $0x2b,%ecx
cmove  %eax,%ecx
test   %r9d,%r9d
mov    $0x2d,%r12d
cmove  %ecx,%r12d
test   $0x8,%dl
mov    %edx,0x1c(%rsp)
jne    1185 <number+0x65>
mov    $0x1,%al
mov    %eax,0x18(%rsp)
movl   $0x0,0x10(%rsp)
mov    $0x1,%bpl
jmp    119d <number+0x7d>
cmp    $0x6f,%sil
jne    121b <number+0xfb>
mov    $0x1,%al
mov    %eax,0x18(%rsp)
mov    $0x30,%al
mov    %eax,0x10(%rsp)
xor    %ebp,%ebp
movl   $0x0,0x14(%rsp)
and    $0x10,%r13b
mov    %r14,%rdi
call   1030 <strlen@plt>
mov    %rax,%r8
mov    %ebp,%eax
xor    $0x1,%al
movzbl %al,%r9d
cmp    $0x1,%r12b
sbb    $0xffffffffffffffff,%r9
lea    (%r9,%r8,1),%rax
add    $0x2,%rax
add    %r8,%r9
mov    0x18(%rsp),%ecx
test   %cl,%cl
cmove  %rax,%r9
test   %r15,%r15
mov    %ebp,%edx
js     1200 <number+0xe0>
mov    %r15d,%eax
cmpb   $0x73,0x60(%rsp)
mov    %r13,%r10
mov    0x1c(%rsp),%esi
jne    120b <number+0xeb>
cmp    %rax,%r8
jbe    120b <number+0xeb>
xor    %ebp,%ebp
mov    %r15,%r8
mov    %r15,%r9
jmp    1239 <number+0x119>
xor    %ebp,%ebp
mov    %r13,%r10
mov    0x1c(%rsp),%esi
jmp    1239 <number+0x119>
cmp    %rax,%r8
jae    1237 <number+0x117>
sub    %r8,%r15
add    %r15,%r9
mov    %r15,%rbp
jmp    1239 <number+0x119>
mov    %esi,%eax
and    $0xf7,%al
cmp    $0x70,%al
jne    1383 <number+0x263>
mov    $0x30,%al
mov    %eax,0x14(%rsp)
movb   $0x78,0xf(%rsp)
jmp    1398 <number+0x278>
xor    %ebp,%ebp
or     $0x20,%r10b
mov    %esi,%eax
and    $0x11,%eax
cmp    $0x1,%eax
mov    0x20(%rsp),%r15
jne    1272 <number+0x152>
test   %r12b,%r12b
je     1258 <number+0x138>
mov    %r12b,(%rbx)
add    $0x1,%rbx
test   %dl,%dl
je     12db <number+0x1bb>
test   %cl,%cl
je     12ed <number+0x1cd>
test   %rbp,%rbp
jne    1307 <number+0x1e7>
jmp    1581 <number+0x461>
test   $0x10,%sil
jne    1359 <number+0x239>
cmp    %r15,%r9
jae    12ad <number+0x18d>
sub    %r9,%r15
mov    %r15,0x20(%rsp)
movzbl %r10b,%esi
mov    %rbx,%rdi
mov    %edx,%r13d
mov    %r15,%rdx
mov    %r8,%r15
call   1040 <memset@plt>
mov    %r13d,%edx
mov    0x18(%rsp),%ecx
mov    %r15,%r8
add    0x20(%rsp),%rbx
mov    0xf(%rsp),%al
test   %r12b,%r12b
je     12bd <number+0x19d>
mov    %r12b,(%rbx)
add    $0x1,%rbx
test   %dl,%dl
je     13b0 <number+0x290>
test   %cl,%cl
je     13c2 <number+0x2a2>
test   %rbp,%rbp
jne    13d8 <number+0x2b8>
jmp    1821 <number+0x701>
mov    0x10(%rsp),%eax
mov    %al,(%rbx)
add    $0x1,%rbx
test   %cl,%cl
jne    1264 <number+0x144>
mov    0x14(%rsp),%eax
mov    %al,(%rbx)
mov    0xf(%rsp),%al
mov    %al,0x1(%rbx)
add    $0x2,%rbx
test   %rbp,%rbp
je     1581 <number+0x461>
xor    %eax,%eax
cmp    $0x20,%rbp
jb     156a <number+0x44a>
lea    -0x1(%rbp),%rcx
cmp    $0xffffffff,%ecx
je     156a <number+0x44a>
shr    $0x20,%rcx
jne    156a <number+0x44a>
mov    %rbp,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rsi
mov    %rsi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x7,%ecx
cmp    $0xe0,%rsi
jae    14a8 <number+0x388>
xor    %esi,%esi
jmp    1534 <number+0x414>
test   %r12b,%r12b
je     1365 <number+0x245>
mov    %r12b,(%rbx)
add    $0x1,%rbx
test   %dl,%dl
je     142a <number+0x30a>
test   %cl,%cl
je     143c <number+0x31c>
test   %rbp,%rbp
jne    1456 <number+0x336>
jmp    1ac1 <number+0x9a1>
cmp    $0x58,%sil
jne    1172 <number+0x52>
mov    $0x30,%al
mov    %eax,0x14(%rsp)
movb   $0x58,0xf(%rsp)
movl   $0x0,0x10(%rsp)
mov    $0x1,%bpl
movl   $0x0,0x18(%rsp)
jmp    11a5 <number+0x85>
mov    0x10(%rsp),%edx
mov    %dl,(%rbx)
add    $0x1,%rbx
test   %cl,%cl
jne    12cd <number+0x1ad>
mov    0x14(%rsp),%ecx
mov    %cl,(%rbx)
mov    %al,0x1(%rbx)
add    $0x2,%rbx
test   %rbp,%rbp
je     1821 <number+0x701>
xor    %eax,%eax
cmp    $0x20,%rbp
jb     180a <number+0x6ea>
lea    -0x1(%rbp),%rcx
cmp    $0xffffffff,%ecx
je     180a <number+0x6ea>
shr    $0x20,%rcx
jne    180a <number+0x6ea>
mov    %rbp,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rsi
mov    %rsi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x7,%ecx
cmp    $0xe0,%rsi
jae    174d <number+0x62d>
xor    %esi,%esi
jmp    17d4 <number+0x6b4>
mov    0x10(%rsp),%eax
mov    %al,(%rbx)
add    $0x1,%rbx
test   %cl,%cl
jne    1375 <number+0x255>
mov    0x14(%rsp),%eax
mov    %al,(%rbx)
mov    0xf(%rsp),%al
mov    %al,0x1(%rbx)
add    $0x2,%rbx
test   %rbp,%rbp
je     1ac1 <number+0x9a1>
xor    %eax,%eax
cmp    $0x20,%rbp
jb     1aaa <number+0x98a>
lea    -0x1(%rbp),%rcx
cmp    $0xffffffff,%ecx
je     1aaa <number+0x98a>
shr    $0x20,%rcx
jne    1aaa <number+0x98a>
mov    %rbp,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rsi
mov    %rsi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x7,%ecx
cmp    $0xe0,%rsi
jae    19ef <number+0x8cf>
xor    %esi,%esi
jmp    1a74 <number+0x954>
and    $0xfffffffffffffff8,%rdx
xor    %esi,%esi
movaps 0xb4b(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movups %xmm0,(%rbx,%rsi,1)
movups %xmm0,0x10(%rbx,%rsi,1)
movups %xmm0,0x20(%rbx,%rsi,1)
movups %xmm0,0x30(%rbx,%rsi,1)
movups %xmm0,0x40(%rbx,%rsi,1)
movups %xmm0,0x50(%rbx,%rsi,1)
movups %xmm0,0x60(%rbx,%rsi,1)
movups %xmm0,0x70(%rbx,%rsi,1)
movups %xmm0,0x80(%rbx,%rsi,1)
movups %xmm0,0x90(%rbx,%rsi,1)
movups %xmm0,0xa0(%rbx,%rsi,1)
movups %xmm0,0xb0(%rbx,%rsi,1)
movups %xmm0,0xc0(%rbx,%rsi,1)
movups %xmm0,0xd0(%rbx,%rsi,1)
movups %xmm0,0xe0(%rbx,%rsi,1)
movups %xmm0,0xf0(%rbx,%rsi,1)
add    $0x100,%rsi
add    $0xfffffffffffffff8,%rdx
jne    14c0 <number+0x3a0>
test   %rcx,%rcx
je     1562 <number+0x442>
lea    (%rsi,%rbx,1),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movaps 0xab2(%rip),%xmm0
xchg   %ax,%ax
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm0,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1550 <number+0x430>
add    %rax,%rbx
cmp    %rax,%rbp
je     1581 <number+0x461>
add    $0x1,%eax
nopl   (%rax)
movb   $0x30,(%rbx)
add    $0x1,%rbx
mov    %eax,%ecx
add    $0x1,%eax
cmp    %rcx,%rbp
ja     1570 <number+0x450>
test   %r8,%r8
je     1727 <number+0x607>
cmp    $0x20,%r8
jb     15aa <number+0x48a>
lea    (%r14,%r8,1),%rax
cmp    %rax,%rbx
jae    1647 <number+0x527>
lea    (%rbx,%r8,1),%rax
cmp    %r14,%rax
jbe    1647 <number+0x527>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %r8,%rsi
mov    %r8,%rdx
and    $0x7,%rdx
je     15d5 <number+0x4b5>
xchg   %ax,%ax
movzbl (%r14,%rax,1),%ecx
mov    %cl,(%rbx)
add    $0x1,%rbx
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    15c0 <number+0x4a0>
cmp    $0x7,%rsi
jb     1727 <number+0x607>
sub    %rax,%r8
lea    (%rax,%r14,1),%rcx
add    $0x7,%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movzbl -0x7(%rcx,%rax,1),%edx
mov    %dl,(%rbx,%rax,1)
movzbl -0x6(%rcx,%rax,1),%edx
mov    %dl,0x1(%rbx,%rax,1)
movzbl -0x5(%rcx,%rax,1),%edx
mov    %dl,0x2(%rbx,%rax,1)
movzbl -0x4(%rcx,%rax,1),%edx
mov    %dl,0x3(%rbx,%rax,1)
movzbl -0x3(%rcx,%rax,1),%edx
mov    %dl,0x4(%rbx,%rax,1)
movzbl -0x2(%rcx,%rax,1),%edx
mov    %dl,0x5(%rbx,%rax,1)
movzbl -0x1(%rcx,%rax,1),%edx
mov    %dl,0x6(%rbx,%rax,1)
movzbl (%rcx,%rax,1),%edx
mov    %dl,0x7(%rbx,%rax,1)
add    $0x8,%rax
cmp    %rax,%r8
jne    15f0 <number+0x4d0>
add    %rax,%rbx
jmp    1727 <number+0x607>
mov    %r8,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rsi
mov    %rsi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x60,%rsi
jae    166c <number+0x54c>
xor    %esi,%esi
jmp    16e0 <number+0x5c0>
movabs $0xffffffffffffff8,%rsi
ff ff 0f
or     $0x4,%rsi
and    %rsi,%rdx
xor    %esi,%esi
nop
movups (%r14,%rsi,1),%xmm0
movups 0x10(%r14,%rsi,1),%xmm1
movups %xmm0,(%rbx,%rsi,1)
movups %xmm1,0x10(%rbx,%rsi,1)
movups 0x20(%r14,%rsi,1),%xmm0
movups 0x30(%r14,%rsi,1),%xmm1
movups %xmm0,0x20(%rbx,%rsi,1)
movups %xmm1,0x30(%rbx,%rsi,1)
movups 0x40(%r14,%rsi,1),%xmm0
movups 0x50(%r14,%rsi,1),%xmm1
movups %xmm0,0x40(%rbx,%rsi,1)
movups %xmm1,0x50(%rbx,%rsi,1)
movups 0x60(%r14,%rsi,1),%xmm0
movups 0x70(%r14,%rsi,1),%xmm1
movups %xmm0,0x60(%rbx,%rsi,1)
movups %xmm1,0x70(%rbx,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1680 <number+0x560>
test   %rcx,%rcx
je     171b <number+0x5fb>
lea    (%r14,%rsi,1),%rdx
add    $0x10,%rdx
add    %rbx,%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1700 <number+0x5e0>
add    %rax,%rbx
cmp    %rax,%r8
jne    15ac <number+0x48c>
cmp    %r15,%r9
jae    18e2 <number+0x7c2>
sub    %r9,%r15
movzbl %r10b,%esi
mov    %rbx,%rdi
mov    %r15,%rdx
call   1040 <memset@plt>
add    %rbx,%r15
mov    %r15,%r13
jmp    18e5 <number+0x7c5>
and    $0xfffffffffffffff8,%rdx
xor    %esi,%esi
movaps 0x8a6(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movups %xmm0,(%rbx,%rsi,1)
movups %xmm0,0x10(%rbx,%rsi,1)
movups %xmm0,0x20(%rbx,%rsi,1)
movups %xmm0,0x30(%rbx,%rsi,1)
movups %xmm0,0x40(%rbx,%rsi,1)
movups %xmm0,0x50(%rbx,%rsi,1)
movups %xmm0,0x60(%rbx,%rsi,1)
movups %xmm0,0x70(%rbx,%rsi,1)
movups %xmm0,0x80(%rbx,%rsi,1)
movups %xmm0,0x90(%rbx,%rsi,1)
movups %xmm0,0xa0(%rbx,%rsi,1)
movups %xmm0,0xb0(%rbx,%rsi,1)
movups %xmm0,0xc0(%rbx,%rsi,1)
movups %xmm0,0xd0(%rbx,%rsi,1)
movups %xmm0,0xe0(%rbx,%rsi,1)
movups %xmm0,0xf0(%rbx,%rsi,1)
add    $0x100,%rsi
add    $0xfffffffffffffff8,%rdx
jne    1760 <number+0x640>
test   %rcx,%rcx
je     1802 <number+0x6e2>
lea    (%rsi,%rbx,1),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movaps 0x812(%rip),%xmm0
xchg   %ax,%ax
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm0,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    17f0 <number+0x6d0>
add    %rax,%rbx
cmp    %rax,%rbp
je     1821 <number+0x701>
add    $0x1,%eax
nopl   (%rax)
movb   $0x30,(%rbx)
add    $0x1,%rbx
mov    %eax,%ecx
add    $0x1,%eax
cmp    %rcx,%rbp
ja     1810 <number+0x6f0>
test   %r8,%r8
je     18e2 <number+0x7c2>
cmp    $0x20,%r8
jb     184a <number+0x72a>
lea    (%r14,%r8,1),%rax
cmp    %rax,%rbx
jae    18fc <number+0x7dc>
lea    (%rbx,%r8,1),%rax
cmp    %r14,%rax
jbe    18fc <number+0x7dc>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %r8,%rsi
mov    %r8,%rdx
and    $0x7,%rdx
je     1875 <number+0x755>
xchg   %ax,%ax
movzbl (%r14,%rax,1),%ecx
mov    %cl,(%rbx)
add    $0x1,%rbx
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1860 <number+0x740>
mov    %rbx,%r13
cmp    $0x7,%rsi
jb     18e5 <number+0x7c5>
sub    %rax,%r8
lea    (%rax,%r14,1),%rcx
add    $0x7,%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movzbl -0x7(%rcx,%rax,1),%edx
mov    %dl,(%rbx,%rax,1)
movzbl -0x6(%rcx,%rax,1),%edx
mov    %dl,0x1(%rbx,%rax,1)
movzbl -0x5(%rcx,%rax,1),%edx
mov    %dl,0x2(%rbx,%rax,1)
movzbl -0x4(%rcx,%rax,1),%edx
mov    %dl,0x3(%rbx,%rax,1)
movzbl -0x3(%rcx,%rax,1),%edx
mov    %dl,0x4(%rbx,%rax,1)
movzbl -0x2(%rcx,%rax,1),%edx
mov    %dl,0x5(%rbx,%rax,1)
movzbl -0x1(%rcx,%rax,1),%edx
mov    %dl,0x6(%rbx,%rax,1)
movzbl (%rcx,%rax,1),%edx
mov    %dl,0x7(%rbx,%rax,1)
add    $0x8,%rax
cmp    %rax,%r8
jne    1890 <number+0x770>
add    %rax,%rbx
mov    %rbx,%r13
movb   $0x0,0x0(%r13)
mov    %r13,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r8,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rsi
mov    %rsi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x60,%rsi
jae    1921 <number+0x801>
xor    %esi,%esi
jmp    19a0 <number+0x880>
movabs $0xffffffffffffff8,%rsi
ff ff 0f
or     $0x4,%rsi
and    %rsi,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%r14,%rsi,1),%xmm0
movups 0x10(%r14,%rsi,1),%xmm1
movups %xmm0,(%rbx,%rsi,1)
movups %xmm1,0x10(%rbx,%rsi,1)
movups 0x20(%r14,%rsi,1),%xmm0
movups 0x30(%r14,%rsi,1),%xmm1
movups %xmm0,0x20(%rbx,%rsi,1)
movups %xmm1,0x30(%rbx,%rsi,1)
movups 0x40(%r14,%rsi,1),%xmm0
movups 0x50(%r14,%rsi,1),%xmm1
movups %xmm0,0x40(%rbx,%rsi,1)
movups %xmm1,0x50(%rbx,%rsi,1)
movups 0x60(%r14,%rsi,1),%xmm0
movups 0x70(%r14,%rsi,1),%xmm1
movups %xmm0,0x60(%rbx,%rsi,1)
movups %xmm1,0x70(%rbx,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1940 <number+0x820>
test   %rcx,%rcx
je     19db <number+0x8bb>
lea    (%r14,%rsi,1),%rdx
add    $0x10,%rdx
add    %rbx,%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    19c0 <number+0x8a0>
add    %rax,%rbx
mov    %rbx,%r13
cmp    %rax,%r8
je     18e5 <number+0x7c5>
jmp    184c <number+0x72c>
and    $0xfffffffffffffff8,%rdx
xor    %esi,%esi
movaps 0x604(%rip),%xmm0
nopl   0x0(%rax)
movups %xmm0,(%rbx,%rsi,1)
movups %xmm0,0x10(%rbx,%rsi,1)
movups %xmm0,0x20(%rbx,%rsi,1)
movups %xmm0,0x30(%rbx,%rsi,1)
movups %xmm0,0x40(%rbx,%rsi,1)
movups %xmm0,0x50(%rbx,%rsi,1)
movups %xmm0,0x60(%rbx,%rsi,1)
movups %xmm0,0x70(%rbx,%rsi,1)
movups %xmm0,0x80(%rbx,%rsi,1)
movups %xmm0,0x90(%rbx,%rsi,1)
movups %xmm0,0xa0(%rbx,%rsi,1)
movups %xmm0,0xb0(%rbx,%rsi,1)
movups %xmm0,0xc0(%rbx,%rsi,1)
movups %xmm0,0xd0(%rbx,%rsi,1)
movups %xmm0,0xe0(%rbx,%rsi,1)
movups %xmm0,0xf0(%rbx,%rsi,1)
add    $0x100,%rsi
add    $0xfffffffffffffff8,%rdx
jne    1a00 <number+0x8e0>
test   %rcx,%rcx
je     1aa2 <number+0x982>
lea    (%rsi,%rbx,1),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movaps 0x572(%rip),%xmm0
xchg   %ax,%ax
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm0,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1a90 <number+0x970>
add    %rax,%rbx
cmp    %rax,%rbp
je     1ac1 <number+0x9a1>
add    $0x1,%eax
nopl   (%rax)
movb   $0x30,(%rbx)
add    $0x1,%rbx
mov    %eax,%ecx
add    $0x1,%eax
cmp    %rcx,%rbp
ja     1ab0 <number+0x990>
mov    %rbx,%r13
cmp    %r15,%r9
jae    1aed <number+0x9cd>
mov    %r15,%r13
sub    %r9,%r13
movzbl %r10b,%esi
mov    %rbx,%rdi
mov    %r13,%rdx
mov    %r8,%r12
mov    %r9,%rbp
call   1040 <memset@plt>
mov    %rbp,%r9
mov    %r12,%r8
add    %rbx,%r13
test   %r8,%r8
je     18e5 <number+0x7c5>
cmp    $0x20,%r8
jb     1b25 <number+0xa05>
cmp    %r15,%r9
mov    %r15,%rax
cmova  %r9,%rax
lea    (%r14,%r8,1),%rcx
cmp    %rcx,%r13
jae    1bd0 <number+0xab0>
add    %r8,%rax
sub    %r9,%rax
add    %rbx,%rax
cmp    %r14,%rax
jbe    1bd0 <number+0xab0>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r8,%rcx
mov    %r8,%rdx
and    $0x7,%rdx
je     1b57 <number+0xa37>
nopl   0x0(%rax)
movzbl (%r14,%rax,1),%ebx
mov    %bl,0x0(%r13)
add    $0x1,%r13
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1b40 <number+0xa20>
cmp    $0x7,%rcx
jb     18e5 <number+0x7c5>
sub    %rax,%r8
lea    (%rax,%r14,1),%rcx
add    $0x7,%rcx
xor    %eax,%eax
xchg   %ax,%ax
movzbl -0x7(%rcx,%rax,1),%edx
mov    %dl,0x0(%r13,%rax,1)
movzbl -0x6(%rcx,%rax,1),%edx
mov    %dl,0x1(%r13,%rax,1)
movzbl -0x5(%rcx,%rax,1),%edx
mov    %dl,0x2(%r13,%rax,1)
movzbl -0x4(%rcx,%rax,1),%edx
mov    %dl,0x3(%r13,%rax,1)
movzbl -0x3(%rcx,%rax,1),%edx
mov    %dl,0x4(%r13,%rax,1)
movzbl -0x2(%rcx,%rax,1),%edx
mov    %dl,0x5(%r13,%rax,1)
movzbl -0x1(%rcx,%rax,1),%edx
mov    %dl,0x6(%r13,%rax,1)
movzbl (%rcx,%rax,1),%edx
mov    %dl,0x7(%r13,%rax,1)
add    $0x8,%rax
cmp    %rax,%r8
jne    1b70 <number+0xa50>
add    %rax,%r13
jmp    18e5 <number+0x7c5>
mov    %r8,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rsi
mov    %rsi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x60,%rsi
jae    1bf8 <number+0xad8>
xor    %esi,%esi
jmp    1c80 <number+0xb60>
movabs $0xffffffffffffff8,%rsi
ff ff 0f
or     $0x4,%rsi
and    %rsi,%rdx
xor    %esi,%esi
mov    %r15,%rdi
sub    %r9,%rdi
cmovb  %rsi,%rdi
add    %rbx,%rdi
add    $0x70,%rdi
nopl   0x0(%rax)
movups (%r14,%rsi,1),%xmm0
movups 0x10(%r14,%rsi,1),%xmm1
movups %xmm0,-0x70(%rdi,%rsi,1)
movups %xmm1,-0x60(%rdi,%rsi,1)
movups 0x20(%r14,%rsi,1),%xmm0
movups 0x30(%r14,%rsi,1),%xmm1
movups %xmm0,-0x50(%rdi,%rsi,1)
movups %xmm1,-0x40(%rdi,%rsi,1)
movups 0x40(%r14,%rsi,1),%xmm0
movups 0x50(%r14,%rsi,1),%xmm1
movups %xmm0,-0x30(%rdi,%rsi,1)
movups %xmm1,-0x20(%rdi,%rsi,1)
movups 0x60(%r14,%rsi,1),%xmm0
movups 0x70(%r14,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdi,%rsi,1)
movups %xmm1,(%rdi,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1c20 <number+0xb00>
test   %rcx,%rcx
je     1ccb <number+0xbab>
lea    (%rsi,%r14,1),%rdx
add    $0x10,%rdx
cmp    %r15,%r9
cmova  %r9,%r15
add    %rsi,%r15
sub    %r9,%r15
lea    (%r15,%rbx,1),%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1cb0 <number+0xb90>
add    %rax,%r13
cmp    %rax,%r8
je     18e5 <number+0x7c5>
jmp    1b27 <number+0xa07>

LLVM IR (-O0):
define i8* @number(i8* %0, i8* %1, i32 %2, i64 %3, i64 %4, i32 %5, i8 signext %6) {
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i64
%12 = alloca i64
%13 = alloca i32
%14 = alloca i8
%15 = alloca i8*
%16 = alloca i8
%17 = alloca i8
%18 = alloca i8
%19 = alloca [2 x i8]
%20 = alloca i64
%21 = alloca i64
%22 = alloca i64
%23 = alloca i32
%24 = alloca i64
%25 = alloca i32
%26 = alloca i64
%27 = alloca i32
%28 = alloca i64
store i8* %0, i8** %8
store i8* %1, i8** %9
store i32 %2, i32* %10
store i64 %3, i64* %11
store i64 %4, i64* %12
store i32 %5, i32* %13
store i8 %6, i8* %14
%29 = load i8*, i8** %8
store i8* %29, i8** %15
store i8 0, i8* %16
%30 = load i32, i32* %10
%31 = and i32 %30, 4
%32 = icmp ne i32 %31, 0
br i1 %32, label %33, label %34
33: ; preds = %7
store i8 32, i8* %16
br label %34
34: ; preds = %33, %7
%35 = load i32, i32* %10
%36 = and i32 %35, 2
%37 = icmp ne i32 %36, 0
br i1 %37, label %38, label %39
38: ; preds = %34
store i8 43, i8* %16
br label %39
39: ; preds = %38, %34
%40 = load i32, i32* %13
%41 = icmp ne i32 %40, 0
br i1 %41, label %42, label %43
42: ; preds = %39
store i8 45, i8* %16
br label %43
43: ; preds = %42, %39
store i8 32, i8* %17
%44 = load i32, i32* %10
%45 = and i32 %44, 16
%46 = icmp ne i32 %45, 0
br i1 %46, label %47, label %48
47: ; preds = %43
store i8 48, i8* %17
br label %48
48: ; preds = %47, %43
store i8 0, i8* %18
%49 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
store i8 0, i8* %49
%50 = load i32, i32* %10
%51 = and i32 %50, 8
%52 = icmp ne i32 %51, 0
br i1 %52, label %53, label %79
53: ; preds = %48
%54 = load i8, i8* %14
%55 = sext i8 %54 to i32
%56 = icmp eq i32 %55, 111
br i1 %56, label %57, label %58
57: ; preds = %53
store i8 48, i8* %18
br label %78
58: ; preds = %53
%59 = load i8, i8* %14
%60 = sext i8 %59 to i32
%61 = icmp eq i32 %60, 120
br i1 %61, label %66, label %62
62: ; preds = %58
%63 = load i8, i8* %14
%64 = sext i8 %63 to i32
%65 = icmp eq i32 %64, 112
br i1 %65, label %66, label %69
66: ; preds = %62, %58
%67 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
store i8 48, i8* %67
%68 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 1
store i8 120, i8* %68
br label %77
69: ; preds = %62
%70 = load i8, i8* %14
%71 = sext i8 %70 to i32
%72 = icmp eq i32 %71, 88
br i1 %72, label %73, label %76
73: ; preds = %69
%74 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
store i8 48, i8* %74
%75 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 1
store i8 88, i8* %75
br label %76
76: ; preds = %73, %69
br label %77
77: ; preds = %76, %66
br label %78
78: ; preds = %77, %57
br label %79
79: ; preds = %78, %48
%80 = load i8*, i8** %9
%81 = call i64 @strlen(i8* %80)
store i64 %81, i64* %20
%82 = load i64, i64* %20
store i64 %82, i64* %21
store i64 0, i64* %22
%83 = load i8, i8* %16
%84 = sext i8 %83 to i32
%85 = icmp ne i32 %84, 0
br i1 %85, label %86, label %89
86: ; preds = %79
%87 = load i64, i64* %21
%88 = add i64 %87, 1
store i64 %88, i64* %21
br label %89
89: ; preds = %86, %79
%90 = load i8, i8* %18
%91 = sext i8 %90 to i32
%92 = icmp ne i32 %91, 0
br i1 %92, label %93, label %96
93: ; preds = %89
%94 = load i64, i64* %21
%95 = add i64 %94, 1
store i64 %95, i64* %21
br label %96
96: ; preds = %93, %89
%97 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%98 = load i8, i8* %97
%99 = sext i8 %98 to i32
%100 = icmp ne i32 %99, 0
br i1 %100, label %101, label %104
101: ; preds = %96
%102 = load i64, i64* %21
%103 = add i64 %102, 2
store i64 %103, i64* %21
br label %104
104: ; preds = %101, %96
%105 = load i64, i64* %12
%106 = icmp sge i64 %105, 0
br i1 %106, label %107, label %134
107: ; preds = %104
%108 = load i8, i8* %14
%109 = sext i8 %108 to i32
%110 = icmp eq i32 %109, 115
br i1 %110, label %111, label %119
111: ; preds = %107
%112 = load i64, i64* %20
%113 = load i64, i64* %12
%114 = trunc i64 %113 to i32
%115 = zext i32 %114 to i64
%116 = icmp ugt i64 %112, %115
br i1 %116, label %117, label %119
117: ; preds = %111
%118 = load i64, i64* %12
store i64 %118, i64* %20
store i64 %118, i64* %21
br label %133
119: ; preds = %111, %107
%120 = load i64, i64* %20
%121 = load i64, i64* %12
%122 = trunc i64 %121 to i32
%123 = zext i32 %122 to i64
%124 = icmp ult i64 %120, %123
br i1 %124, label %125, label %132
125: ; preds = %119
%126 = load i64, i64* %12
%127 = load i64, i64* %20
%128 = sub i64 %126, %127
store i64 %128, i64* %22
%129 = load i64, i64* %22
%130 = load i64, i64* %21
%131 = add i64 %130, %129
store i64 %131, i64* %21
br label %132
132: ; preds = %125, %119
br label %133
133: ; preds = %132, %117
br label %134
134: ; preds = %133, %104
%135 = load i32, i32* %10
%136 = and i32 %135, 1
%137 = icmp ne i32 %136, 0
br i1 %137, label %138, label %213
138: ; preds = %134
%139 = load i8, i8* %17
%140 = sext i8 %139 to i32
%141 = icmp eq i32 %140, 32
br i1 %141, label %142, label %213
142: ; preds = %138
%143 = load i8, i8* %16
%144 = sext i8 %143 to i32
%145 = icmp ne i32 %144, 0
br i1 %145, label %146, label %150
146: ; preds = %142
%147 = load i8, i8* %16
%148 = load i8*, i8** %15
%149 = getelementptr inbounds i8, i8* %148, i32 1
store i8* %149, i8** %15
store i8 %147, i8* %148
br label %150
150: ; preds = %146, %142
%151 = load i8, i8* %18
%152 = sext i8 %151 to i32
%153 = icmp ne i32 %152, 0
br i1 %153, label %154, label %158
154: ; preds = %150
%155 = load i8, i8* %18
%156 = load i8*, i8** %15
%157 = getelementptr inbounds i8, i8* %156, i32 1
store i8* %157, i8** %15
store i8 %155, i8* %156
br label %158
158: ; preds = %154, %150
%159 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%160 = load i8, i8* %159
%161 = sext i8 %160 to i32
%162 = icmp ne i32 %161, 0
br i1 %162, label %163, label %173
163: ; preds = %158
%164 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%165 = load i8, i8* %164
%166 = load i8*, i8** %15
%167 = getelementptr inbounds i8, i8* %166, i32 1
store i8* %167, i8** %15
store i8 %165, i8* %166
%168 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%169 = getelementptr inbounds i8, i8* %168, i64 1
%170 = load i8, i8* %169
%171 = load i8*, i8** %15
%172 = getelementptr inbounds i8, i8* %171, i32 1
store i8* %172, i8** %15
store i8 %170, i8* %171
br label %173
173: ; preds = %163, %158
store i32 0, i32* %23
br label %174
174: ; preds = %182, %173
%175 = load i32, i32* %23
%176 = zext i32 %175 to i64
%177 = load i64, i64* %22
%178 = icmp ult i64 %176, %177
br i1 %178, label %179, label %185
179: ; preds = %174
%180 = load i8*, i8** %15
%181 = getelementptr inbounds i8, i8* %180, i32 1
store i8* %181, i8** %15
store i8 48, i8* %180
br label %182
182: ; preds = %179
%183 = load i32, i32* %23
%184 = add i32 %183, 1
store i32 %184, i32* %23
br label %174
185: ; preds = %174
store i64 0, i64* %24
br label %186
186: ; preds = %197, %185
%187 = load i64, i64* %24
%188 = load i64, i64* %20
%189 = icmp ult i64 %187, %188
br i1 %189, label %190, label %200
190: ; preds = %186
%191 = load i8*, i8** %9
%192 = load i64, i64* %24
%193 = getelementptr inbounds i8, i8* %191, i64 %192
%194 = load i8, i8* %193
%195 = load i8*, i8** %15
%196 = getelementptr inbounds i8, i8* %195, i32 1
store i8* %196, i8** %15
store i8 %194, i8* %195
br label %197
197: ; preds = %190
%198 = load i64, i64* %24
%199 = add i64 %198, 1
store i64 %199, i64* %24
br label %186
200: ; preds = %186
br label %201
201: ; preds = %209, %200
%202 = load i64, i64* %21
%203 = load i64, i64* %11
%204 = icmp ult i64 %202, %203
br i1 %204, label %205, label %212
205: ; preds = %201
%206 = load i8, i8* %17
%207 = load i8*, i8** %15
%208 = getelementptr inbounds i8, i8* %207, i32 1
store i8* %208, i8** %15
store i8 %206, i8* %207
br label %209
209: ; preds = %205
%210 = load i64, i64* %21
%211 = add i64 %210, 1
store i64 %211, i64* %21
br label %201
212: ; preds = %201
br label %360
213: ; preds = %138, %134
%214 = load i8, i8* %17
%215 = sext i8 %214 to i32
%216 = icmp eq i32 %215, 48
br i1 %216, label %217, label %288
217: ; preds = %213
%218 = load i8, i8* %16
%219 = sext i8 %218 to i32
%220 = icmp ne i32 %219, 0
br i1 %220, label %221, label %225
221: ; preds = %217
%222 = load i8, i8* %16
%223 = load i8*, i8** %15
%224 = getelementptr inbounds i8, i8* %223, i32 1
store i8* %224, i8** %15
store i8 %222, i8* %223
br label %225
225: ; preds = %221, %217
%226 = load i8, i8* %18
%227 = sext i8 %226 to i32
%228 = icmp ne i32 %227, 0
br i1 %228, label %229, label %233
229: ; preds = %225
%230 = load i8, i8* %18
%231 = load i8*, i8** %15
%232 = getelementptr inbounds i8, i8* %231, i32 1
store i8* %232, i8** %15
store i8 %230, i8* %231
br label %233
233: ; preds = %229, %225
%234 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%235 = load i8, i8* %234
%236 = sext i8 %235 to i32
%237 = icmp ne i32 %236, 0
br i1 %237, label %238, label %248
238: ; preds = %233
%239 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%240 = load i8, i8* %239
%241 = load i8*, i8** %15
%242 = getelementptr inbounds i8, i8* %241, i32 1
store i8* %242, i8** %15
store i8 %240, i8* %241
%243 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%244 = getelementptr inbounds i8, i8* %243, i64 1
%245 = load i8, i8* %244
%246 = load i8*, i8** %15
%247 = getelementptr inbounds i8, i8* %246, i32 1
store i8* %247, i8** %15
store i8 %245, i8* %246
br label %248
248: ; preds = %238, %233
store i32 0, i32* %25
br label %249
249: ; preds = %257, %248
%250 = load i32, i32* %25
%251 = zext i32 %250 to i64
%252 = load i64, i64* %22
%253 = icmp ult i64 %251, %252
br i1 %253, label %254, label %260
254: ; preds = %249
%255 = load i8*, i8** %15
%256 = getelementptr inbounds i8, i8* %255, i32 1
store i8* %256, i8** %15
store i8 48, i8* %255
br label %257
257: ; preds = %254
%258 = load i32, i32* %25
%259 = add i32 %258, 1
store i32 %259, i32* %25
br label %249
260: ; preds = %249
br label %261
261: ; preds = %269, %260
%262 = load i64, i64* %21
%263 = load i64, i64* %11
%264 = icmp ult i64 %262, %263
br i1 %264, label %265, label %272
265: ; preds = %261
%266 = load i8, i8* %17
%267 = load i8*, i8** %15
%268 = getelementptr inbounds i8, i8* %267, i32 1
store i8* %268, i8** %15
store i8 %266, i8* %267
br label %269
269: ; preds = %265
%270 = load i64, i64* %21
%271 = add i64 %270, 1
store i64 %271, i64* %21
br label %261
272: ; preds = %261
store i64 0, i64* %26
br label %273
273: ; preds = %284, %272
%274 = load i64, i64* %26
%275 = load i64, i64* %20
%276 = icmp ult i64 %274, %275
br i1 %276, label %277, label %287
277: ; preds = %273
%278 = load i8*, i8** %9
%279 = load i64, i64* %26
%280 = getelementptr inbounds i8, i8* %278, i64 %279
%281 = load i8, i8* %280
%282 = load i8*, i8** %15
%283 = getelementptr inbounds i8, i8* %282, i32 1
store i8* %283, i8** %15
store i8 %281, i8* %282
br label %284
284: ; preds = %277
%285 = load i64, i64* %26
%286 = add i64 %285, 1
store i64 %286, i64* %26
br label %273
287: ; preds = %273
br label %359
288: ; preds = %213
br label %289
289: ; preds = %297, %288
%290 = load i64, i64* %21
%291 = load i64, i64* %11
%292 = icmp ult i64 %290, %291
br i1 %292, label %293, label %300
293: ; preds = %289
%294 = load i8, i8* %17
%295 = load i8*, i8** %15
%296 = getelementptr inbounds i8, i8* %295, i32 1
store i8* %296, i8** %15
store i8 %294, i8* %295
br label %297
297: ; preds = %293
%298 = load i64, i64* %21
%299 = add i64 %298, 1
store i64 %299, i64* %21
br label %289
300: ; preds = %289
%301 = load i8, i8* %16
%302 = sext i8 %301 to i32
%303 = icmp ne i32 %302, 0
br i1 %303, label %304, label %308
304: ; preds = %300
%305 = load i8, i8* %16
%306 = load i8*, i8** %15
%307 = getelementptr inbounds i8, i8* %306, i32 1
store i8* %307, i8** %15
store i8 %305, i8* %306
br label %308
308: ; preds = %304, %300
%309 = load i8, i8* %18
%310 = sext i8 %309 to i32
%311 = icmp ne i32 %310, 0
br i1 %311, label %312, label %316
312: ; preds = %308
%313 = load i8, i8* %18
%314 = load i8*, i8** %15
%315 = getelementptr inbounds i8, i8* %314, i32 1
store i8* %315, i8** %15
store i8 %313, i8* %314
br label %316
316: ; preds = %312, %308
%317 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%318 = load i8, i8* %317
%319 = sext i8 %318 to i32
%320 = icmp ne i32 %319, 0
br i1 %320, label %321, label %331
321: ; preds = %316
%322 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%323 = load i8, i8* %322
%324 = load i8*, i8** %15
%325 = getelementptr inbounds i8, i8* %324, i32 1
store i8* %325, i8** %15
store i8 %323, i8* %324
%326 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%327 = getelementptr inbounds i8, i8* %326, i64 1
%328 = load i8, i8* %327
%329 = load i8*, i8** %15
%330 = getelementptr inbounds i8, i8* %329, i32 1
store i8* %330, i8** %15
store i8 %328, i8* %329
br label %331
331: ; preds = %321, %316
store i32 0, i32* %27
br label %332
332: ; preds = %340, %331
%333 = load i32, i32* %27
%334 = zext i32 %333 to i64
%335 = load i64, i64* %22
%336 = icmp ult i64 %334, %335
br i1 %336, label %337, label %343
337: ; preds = %332
%338 = load i8*, i8** %15
%339 = getelementptr inbounds i8, i8* %338, i32 1
store i8* %339, i8** %15
store i8 48, i8* %338
br label %340
340: ; preds = %337
%341 = load i32, i32* %27
%342 = add i32 %341, 1
store i32 %342, i32* %27
br label %332
343: ; preds = %332
store i64 0, i64* %28
br label %344
344: ; preds = %355, %343
%345 = load i64, i64* %28
%346 = load i64, i64* %20
%347 = icmp ult i64 %345, %346
br i1 %347, label %348, label %358
348: ; preds = %344
%349 = load i8*, i8** %9
%350 = load i64, i64* %28
%351 = getelementptr inbounds i8, i8* %349, i64 %350
%352 = load i8, i8* %351
%353 = load i8*, i8** %15
%354 = getelementptr inbounds i8, i8* %353, i32 1
store i8* %354, i8** %15
store i8 %352, i8* %353
br label %355
355: ; preds = %348
%356 = load i64, i64* %28
%357 = add i64 %356, 1
store i64 %357, i64* %28
br label %344
358: ; preds = %344
br label %359
359: ; preds = %358, %287
br label %360
360: ; preds = %359, %212
%361 = load i8*, i8** %15
store i8 0, i8* %361
%362 = load i8*, i8** %15
ret i8* %362
}

LLVM IR (-O2):
define i8* @number(i8* writeonly %0, i8* nocapture %1, i32 %2, i64 %3, i64 %4, i32 %5, i8 signext %6) {
%8 = trunc i32 %2 to i8
%9 = shl i8 %8, 3
%10 = and i8 %9, 32
%11 = and i32 %2, 2
%12 = icmp eq i32 %11, 0
%13 = select i1 %12, i8 %10, i8 43
%14 = icmp eq i32 %5, 0
%15 = select i1 %14, i8 %13, i8 45
%16 = and i32 %2, 16
%17 = icmp eq i32 %16, 0
%18 = select i1 %17, i8 32, i8 48
%19 = and i32 %2, 8
%20 = icmp eq i32 %19, 0
br i1 %20, label %29, label %21
21: ; preds = %7
%22 = icmp eq i8 %6, 111
br i1 %22, label %29, label %23
23: ; preds = %21
%24 = and i8 %6, -9
%25 = icmp eq i8 %24, 112
br i1 %25, label %29, label %26
26: ; preds = %23
%27 = icmp eq i8 %6, 88
br i1 %27, label %28, label %29
28: ; preds = %26
br label %29
29: ; preds = %23, %21, %26, %28, %7
%30 = phi i1 [ true, %26 ], [ true, %28 ], [ true, %7 ], [ false, %21 ], [ true, %23 ]
%31 = phi i8 [ 0, %26 ], [ 0, %28 ], [ 0, %7 ], [ 48, %21 ], [ 0, %23 ]
%32 = phi i8 [ undef, %26 ], [ 88, %28 ], [ undef, %7 ], [ undef, %21 ], [ 120, %23 ]
%33 = phi i1 [ true, %26 ], [ false, %28 ], [ true, %7 ], [ true, %21 ], [ false, %23 ]
%34 = phi i8 [ 0, %26 ], [ 48, %28 ], [ 0, %7 ], [ 0, %21 ], [ 48, %23 ]
%35 = tail call i64 @strlen(i8* dereferenceable(1) %1)
%36 = icmp eq i8 %15, 0
%37 = xor i1 %36, true
%38 = zext i1 %37 to i64
%39 = xor i1 %30, true
%40 = zext i1 %39 to i64
%41 = add nuw nsw i64 %40, %38
%42 = add i64 %41, %35
%43 = add i64 %42, 2
%44 = select i1 %33, i64 %42, i64 %43
%45 = icmp sgt i64 %4, -1
br i1 %45, label %46, label %56
46: ; preds = %29
%47 = icmp eq i8 %6, 115
%48 = and i64 %4, 4294967295
%49 = icmp ugt i64 %35, %48
%50 = select i1 %47, i1 %49, i1 false
br i1 %50, label %56, label %51
51: ; preds = %46
%52 = icmp ult i64 %35, %48
br i1 %52, label %53, label %56
53: ; preds = %51
%54 = sub i64 %4, %35
%55 = add i64 %44, %54
br label %56
56: ; preds = %46, %53, %51, %29
%57 = phi i64 [ %35, %53 ], [ %35, %51 ], [ %35, %29 ], [ %4, %46 ]
%58 = phi i64 [ %55, %53 ], [ %44, %51 ], [ %44, %29 ], [ %4, %46 ]
%59 = phi i64 [ %54, %53 ], [ 0, %51 ], [ 0, %29 ], [ 0, %46 ]
%60 = and i32 %2, 17
%61 = icmp eq i32 %60, 1
br i1 %61, label %62, label %321
62: ; preds = %56
br i1 %36, label %65, label %63
63: ; preds = %62
%64 = getelementptr inbounds i8, i8* %0, i64 1
store i8 %15, i8* %0
br label %65
65: ; preds = %63, %62
%66 = phi i8* [ %64, %63 ], [ %0, %62 ]
br i1 %30, label %69, label %67
67: ; preds = %65
%68 = getelementptr inbounds i8, i8* %66, i64 1
store i8 %31, i8* %66
br label %69
69: ; preds = %67, %65
%70 = phi i8* [ %68, %67 ], [ %66, %65 ]
br i1 %33, label %74, label %71
71: ; preds = %69
%72 = getelementptr inbounds i8, i8* %70, i64 1
store i8 %34, i8* %70
%73 = getelementptr inbounds i8, i8* %70, i64 2
store i8 %32, i8* %72
br label %74
74: ; preds = %71, %69
%75 = phi i8* [ %73, %71 ], [ %70, %69 ]
%76 = icmp eq i64 %59, 0
br i1 %76, label %159, label %77
77: ; preds = %74
%78 = icmp ult i64 %59, 32
br i1 %78, label %156, label %79
79: ; preds = %77
%80 = add i64 %59, -1
%81 = trunc i64 %80 to i32
%82 = icmp eq i32 %81, -1
%83 = icmp ugt i64 %80, 4294967295
%84 = or i1 %82, %83
br i1 %84, label %156, label %85
85: ; preds = %79
%86 = and i64 %59, -32
%87 = trunc i64 %86 to i32
%88 = getelementptr i8, i8* %75, i64 %86
%89 = add i64 %86, -32
%90 = lshr exact i64 %89, 5
%91 = add nuw nsw i64 %90, 1
%92 = and i64 %91, 7
%93 = icmp ult i64 %89, 224
br i1 %93, label %141, label %94
94: ; preds = %85
%95 = and i64 %91, 1152921504606846968
br label %96
96: ; preds = %96, %94
%97 = phi i64 [ 0, %94 ], [ %138, %96 ]
%98 = phi i64 [ 0, %94 ], [ %139, %96 ]
%99 = getelementptr i8, i8* %75, i64 %97
%100 = bitcast i8* %99 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %100
%101 = getelementptr i8, i8* %99, i64 16
%102 = bitcast i8* %101 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %102
%103 = or i64 %97, 32
%104 = getelementptr i8, i8* %75, i64 %103
%105 = bitcast i8* %104 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %105
%106 = getelementptr i8, i8* %104, i64 16
%107 = bitcast i8* %106 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %107
%108 = or i64 %97, 64
%109 = getelementptr i8, i8* %75, i64 %108
%110 = bitcast i8* %109 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %110
%111 = getelementptr i8, i8* %109, i64 16
%112 = bitcast i8* %111 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %112
%113 = or i64 %97, 96
%114 = getelementptr i8, i8* %75, i64 %113
%115 = bitcast i8* %114 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %115
%116 = getelementptr i8, i8* %114, i64 16
%117 = bitcast i8* %116 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %117
%118 = or i64 %97, 128
%119 = getelementptr i8, i8* %75, i64 %118
%120 = bitcast i8* %119 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %120
%121 = getelementptr i8, i8* %119, i64 16
%122 = bitcast i8* %121 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %122
%123 = or i64 %97, 160
%124 = getelementptr i8, i8* %75, i64 %123
%125 = bitcast i8* %124 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %125
%126 = getelementptr i8, i8* %124, i64 16
%127 = bitcast i8* %126 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %127
%128 = or i64 %97, 192
%129 = getelementptr i8, i8* %75, i64 %128
%130 = bitcast i8* %129 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %130
%131 = getelementptr i8, i8* %129, i64 16
%132 = bitcast i8* %131 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %132
%133 = or i64 %97, 224
%134 = getelementptr i8, i8* %75, i64 %133
%135 = bitcast i8* %134 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %135
%136 = getelementptr i8, i8* %134, i64 16
%137 = bitcast i8* %136 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %137
%138 = add nuw i64 %97, 256
%139 = add i64 %98, 8
%140 = icmp eq i64 %139, %95
br i1 %140, label %141, label %96
141: ; preds = %96, %85
%142 = phi i64 [ 0, %85 ], [ %138, %96 ]
%143 = icmp eq i64 %92, 0
br i1 %143, label %154, label %144
144: ; preds = %141, %144
%145 = phi i64 [ %151, %144 ], [ %142, %141 ]
%146 = phi i64 [ %152, %144 ], [ 0, %141 ]
%147 = getelementptr i8, i8* %75, i64 %145
%148 = bitcast i8* %147 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %148
%149 = getelementptr i8, i8* %147, i64 16
%150 = bitcast i8* %149 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %150
%151 = add nuw i64 %145, 32
%152 = add i64 %146, 1
%153 = icmp eq i64 %152, %92
br i1 %153, label %154, label %144
154: ; preds = %144, %141
%155 = icmp eq i64 %59, %86
br i1 %155, label %159, label %156
156: ; preds = %79, %77, %154
%157 = phi i32 [ 0, %79 ], [ 0, %77 ], [ %87, %154 ]
%158 = phi i8* [ %75, %79 ], [ %75, %77 ], [ %88, %154 ]
br label %272
159: ; preds = %272, %154, %74
%160 = phi i8* [ %75, %74 ], [ %88, %154 ], [ %275, %272 ]
%161 = icmp eq i64 %57, 0
br i1 %161, label %279, label %162
162: ; preds = %159
%163 = icmp ult i64 %57, 32
br i1 %163, label %250, label %164
164: ; preds = %162
%165 = getelementptr i8, i8* %160, i64 %57
%166 = getelementptr i8, i8* %1, i64 %57
%167 = icmp ult i8* %160, %166
%168 = icmp ugt i8* %165, %1
%169 = and i1 %167, %168
br i1 %169, label %250, label %170
170: ; preds = %164
%171 = and i64 %57, -32
%172 = getelementptr i8, i8* %160, i64 %171
%173 = add i64 %171, -32
%174 = lshr exact i64 %173, 5
%175 = add nuw nsw i64 %174, 1
%176 = and i64 %175, 3
%177 = icmp ult i64 %173, 96
br i1 %177, label %229, label %178
178: ; preds = %170
%179 = and i64 %175, 1152921504606846972
br label %180
180: ; preds = %180, %178
%181 = phi i64 [ 0, %178 ], [ %226, %180 ]
%182 = phi i64 [ 0, %178 ], [ %227, %180 ]
%183 = getelementptr i8, i8* %160, i64 %181
%184 = getelementptr inbounds i8, i8* %1, i64 %181
%185 = bitcast i8* %184 to <16 x i8>*
%186 = load <16 x i8>, <16 x i8>* %185
%187 = getelementptr inbounds i8, i8* %184, i64 16
%188 = bitcast i8* %187 to <16 x i8>*
%189 = load <16 x i8>, <16 x i8>* %188
%190 = bitcast i8* %183 to <16 x i8>*
store <16 x i8> %186, <16 x i8>* %190
%191 = getelementptr i8, i8* %183, i64 16
%192 = bitcast i8* %191 to <16 x i8>*
store <16 x i8> %189, <16 x i8>* %192
%193 = or i64 %181, 32
%194 = getelementptr i8, i8* %160, i64 %193
%195 = getelementptr inbounds i8, i8* %1, i64 %193
%196 = bitcast i8* %195 to <16 x i8>*
%197 = load <16 x i8>, <16 x i8>* %196
%198 = getelementptr inbounds i8, i8* %195, i64 16
%199 = bitcast i8* %198 to <16 x i8>*
%200 = load <16 x i8>, <16 x i8>* %199
%201 = bitcast i8* %194 to <16 x i8>*
store <16 x i8> %197, <16 x i8>* %201
%202 = getelementptr i8, i8* %194, i64 16
%203 = bitcast i8* %202 to <16 x i8>*
store <16 x i8> %200, <16 x i8>* %203
%204 = or i64 %181, 64
%205 = getelementptr i8, i8* %160, i64 %204
%206 = getelementptr inbounds i8, i8* %1, i64 %204
%207 = bitcast i8* %206 to <16 x i8>*
%208 = load <16 x i8>, <16 x i8>* %207
%209 = getelementptr inbounds i8, i8* %206, i64 16
%210 = bitcast i8* %209 to <16 x i8>*
%211 = load <16 x i8>, <16 x i8>* %210
%212 = bitcast i8* %205 to <16 x i8>*
store <16 x i8> %208, <16 x i8>* %212
%213 = getelementptr i8, i8* %205, i64 16
%214 = bitcast i8* %213 to <16 x i8>*
store <16 x i8> %211, <16 x i8>* %214
%215 = or i64 %181, 96
%216 = getelementptr i8, i8* %160, i64 %215
%217 = getelementptr inbounds i8, i8* %1, i64 %215
%218 = bitcast i8* %217 to <16 x i8>*
%219 = load <16 x i8>, <16 x i8>* %218
%220 = getelementptr inbounds i8, i8* %217, i64 16
%221 = bitcast i8* %220 to <16 x i8>*
%222 = load <16 x i8>, <16 x i8>* %221
%223 = bitcast i8* %216 to <16 x i8>*
store <16 x i8> %219, <16 x i8>* %223
%224 = getelementptr i8, i8* %216, i64 16
%225 = bitcast i8* %224 to <16 x i8>*
store <16 x i8> %222, <16 x i8>* %225
%226 = add nuw i64 %181, 128
%227 = add i64 %182, 4
%228 = icmp eq i64 %227, %179
br i1 %228, label %229, label %180
229: ; preds = %180, %170
%230 = phi i64 [ 0, %170 ], [ %226, %180 ]
%231 = icmp eq i64 %176, 0
br i1 %231, label %248, label %232
232: ; preds = %229, %232
%233 = phi i64 [ %245, %232 ], [ %230, %229 ]
%234 = phi i64 [ %246, %232 ], [ 0, %229 ]
%235 = getelementptr i8, i8* %160, i64 %233
%236 = getelementptr inbounds i8, i8* %1, i64 %233
%237 = bitcast i8* %236 to <16 x i8>*
%238 = load <16 x i8>, <16 x i8>* %237
%239 = getelementptr inbounds i8, i8* %236, i64 16
%240 = bitcast i8* %239 to <16 x i8>*
%241 = load <16 x i8>, <16 x i8>* %240
%242 = bitcast i8* %235 to <16 x i8>*
store <16 x i8> %238, <16 x i8>* %242
%243 = getelementptr i8, i8* %235, i64 16
%244 = bitcast i8* %243 to <16 x i8>*
store <16 x i8> %241, <16 x i8>* %244
%245 = add nuw i64 %233, 32
%246 = add i64 %234, 1
%247 = icmp eq i64 %246, %176
br i1 %247, label %248, label %232
248: ; preds = %232, %229
%249 = icmp eq i64 %57, %171
br i1 %249, label %279, label %250
250: ; preds = %164, %162, %248
%251 = phi i64 [ 0, %164 ], [ 0, %162 ], [ %171, %248 ]
%252 = phi i8* [ %160, %164 ], [ %160, %162 ], [ %172, %248 ]
%253 = xor i64 %251, -1
%254 = add i64 %57, %253
%255 = and i64 %57, 7
%256 = icmp eq i64 %255, 0
br i1 %256, label %267, label %257
257: ; preds = %250, %257
%258 = phi i64 [ %264, %257 ], [ %251, %250 ]
%259 = phi i8* [ %263, %257 ], [ %252, %250 ]
%260 = phi i64 [ %265, %257 ], [ 0, %250 ]
%261 = getelementptr inbounds i8, i8* %1, i64 %258
%262 = load i8, i8* %261
%263 = getelementptr inbounds i8, i8* %259, i64 1
store i8 %262, i8* %259
%264 = add nuw i64 %258, 1
%265 = add i64 %260, 1
%266 = icmp eq i64 %265, %255
br i1 %266, label %267, label %257
267: ; preds = %257, %250
%268 = phi i8* [ undef, %250 ], [ %263, %257 ]
%269 = phi i64 [ %251, %250 ], [ %264, %257 ]
%270 = phi i8* [ %252, %250 ], [ %263, %257 ]
%271 = icmp ult i64 %254, 7
br i1 %271, label %279, label %285
272: ; preds = %156, %272
%273 = phi i32 [ %276, %272 ], [ %157, %156 ]
%274 = phi i8* [ %275, %272 ], [ %158, %156 ]
%275 = getelementptr inbounds i8, i8* %274, i64 1
store i8 48, i8* %274
%276 = add i32 %273, 1
%277 = zext i32 %276 to i64
%278 = icmp ugt i64 %59, %277
br i1 %278, label %272, label %159
279: ; preds = %267, %285, %248, %159
%280 = phi i8* [ %160, %159 ], [ %172, %248 ], [ %268, %267 ], [ %318, %285 ]
%281 = icmp ult i64 %58, %3
br i1 %281, label %282, label %843
282: ; preds = %279
%283 = sub i64 %3, %58
%284 = getelementptr i8, i8* %280, i64 %283
br label %843
285: ; preds = %267, %285
%286 = phi i64 [ %319, %285 ], [ %269, %267 ]
%287 = phi i8* [ %318, %285 ], [ %270, %267 ]
%288 = getelementptr inbounds i8, i8* %1, i64 %286
%289 = load i8, i8* %288
%290 = getelementptr inbounds i8, i8* %287, i64 1
store i8 %289, i8* %287
%291 = add nuw i64 %286, 1
%292 = getelementptr inbounds i8, i8* %1, i64 %291
%293 = load i8, i8* %292
%294 = getelementptr inbounds i8, i8* %287, i64 2
store i8 %293, i8* %290
%295 = add nuw i64 %286, 2
%296 = getelementptr inbounds i8, i8* %1, i64 %295
%297 = load i8, i8* %296
%298 = getelementptr inbounds i8, i8* %287, i64 3
store i8 %297, i8* %294
%299 = add nuw i64 %286, 3
%300 = getelementptr inbounds i8, i8* %1, i64 %299
%301 = load i8, i8* %300
%302 = getelementptr inbounds i8, i8* %287, i64 4
store i8 %301, i8* %298
%303 = add nuw i64 %286, 4
%304 = getelementptr inbounds i8, i8* %1, i64 %303
%305 = load i8, i8* %304
%306 = getelementptr inbounds i8, i8* %287, i64 5
store i8 %305, i8* %302
%307 = add nuw i64 %286, 5
%308 = getelementptr inbounds i8, i8* %1, i64 %307
%309 = load i8, i8* %308
%310 = getelementptr inbounds i8, i8* %287, i64 6
store i8 %309, i8* %306
%311 = add nuw i64 %286, 6
%312 = getelementptr inbounds i8, i8* %1, i64 %311
%313 = load i8, i8* %312
%314 = getelementptr inbounds i8, i8* %287, i64 7
store i8 %313, i8* %310
%315 = add nuw i64 %286, 7
%316 = getelementptr inbounds i8, i8* %1, i64 %315
%317 = load i8, i8* %316
%318 = getelementptr inbounds i8, i8* %287, i64 8
store i8 %317, i8* %314
%319 = add nuw i64 %286, 8
%320 = icmp eq i64 %319, %57
br i1 %320, label %279, label %285
321: ; preds = %56
br i1 %17, label %322, label %327
322: ; preds = %321
%323 = icmp ult i64 %58, %3
br i1 %323, label %324, label %589
324: ; preds = %322
%325 = sub i64 %3, %58
%326 = getelementptr i8, i8* %0, i64 %325
br label %589
327: ; preds = %321
br i1 %36, label %330, label %328
328: ; preds = %327
%329 = getelementptr inbounds i8, i8* %0, i64 1
store i8 %15, i8* %0
br label %330
330: ; preds = %328, %327
%331 = phi i8* [ %329, %328 ], [ %0, %327 ]
br i1 %30, label %334, label %332
332: ; preds = %330
%333 = getelementptr inbounds i8, i8* %331, i64 1
store i8 %31, i8* %331
br label %334
334: ; preds = %332, %330
%335 = phi i8* [ %333, %332 ], [ %331, %330 ]
br i1 %33, label %339, label %336
336: ; preds = %334
%337 = getelementptr inbounds i8, i8* %335, i64 1
store i8 %34, i8* %335
%338 = getelementptr inbounds i8, i8* %335, i64 2
store i8 %32, i8* %337
br label %339
339: ; preds = %336, %334
%340 = phi i8* [ %338, %336 ], [ %335, %334 ]
%341 = icmp eq i64 %59, 0
br i1 %341, label %424, label %342
342: ; preds = %339
%343 = icmp ult i64 %59, 32
br i1 %343, label %421, label %344
344: ; preds = %342
%345 = add i64 %59, -1
%346 = trunc i64 %345 to i32
%347 = icmp eq i32 %346, -1
%348 = icmp ugt i64 %345, 4294967295
%349 = or i1 %347, %348
br i1 %349, label %421, label %350
350: ; preds = %344
%351 = and i64 %59, -32
%352 = trunc i64 %351 to i32
%353 = getelementptr i8, i8* %340, i64 %351
%354 = add i64 %351, -32
%355 = lshr exact i64 %354, 5
%356 = add nuw nsw i64 %355, 1
%357 = and i64 %356, 7
%358 = icmp ult i64 %354, 224
br i1 %358, label %406, label %359
359: ; preds = %350
%360 = and i64 %356, 1152921504606846968
br label %361
361: ; preds = %361, %359
%362 = phi i64 [ 0, %359 ], [ %403, %361 ]
%363 = phi i64 [ 0, %359 ], [ %404, %361 ]
%364 = getelementptr i8, i8* %340, i64 %362
%365 = bitcast i8* %364 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %365
%366 = getelementptr i8, i8* %364, i64 16
%367 = bitcast i8* %366 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %367
%368 = or i64 %362, 32
%369 = getelementptr i8, i8* %340, i64 %368
%370 = bitcast i8* %369 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %370
%371 = getelementptr i8, i8* %369, i64 16
%372 = bitcast i8* %371 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %372
%373 = or i64 %362, 64
%374 = getelementptr i8, i8* %340, i64 %373
%375 = bitcast i8* %374 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %375
%376 = getelementptr i8, i8* %374, i64 16
%377 = bitcast i8* %376 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %377
%378 = or i64 %362, 96
%379 = getelementptr i8, i8* %340, i64 %378
%380 = bitcast i8* %379 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %380
%381 = getelementptr i8, i8* %379, i64 16
%382 = bitcast i8* %381 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %382
%383 = or i64 %362, 128
%384 = getelementptr i8, i8* %340, i64 %383
%385 = bitcast i8* %384 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %385
%386 = getelementptr i8, i8* %384, i64 16
%387 = bitcast i8* %386 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %387
%388 = or i64 %362, 160
%389 = getelementptr i8, i8* %340, i64 %388
%390 = bitcast i8* %389 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %390
%391 = getelementptr i8, i8* %389, i64 16
%392 = bitcast i8* %391 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %392
%393 = or i64 %362, 192
%394 = getelementptr i8, i8* %340, i64 %393
%395 = bitcast i8* %394 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %395
%396 = getelementptr i8, i8* %394, i64 16
%397 = bitcast i8* %396 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %397
%398 = or i64 %362, 224
%399 = getelementptr i8, i8* %340, i64 %398
%400 = bitcast i8* %399 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %400
%401 = getelementptr i8, i8* %399, i64 16
%402 = bitcast i8* %401 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %402
%403 = add nuw i64 %362, 256
%404 = add i64 %363, 8
%405 = icmp eq i64 %404, %360
br i1 %405, label %406, label %361
406: ; preds = %361, %350
%407 = phi i64 [ 0, %350 ], [ %403, %361 ]
%408 = icmp eq i64 %357, 0
br i1 %408, label %419, label %409
409: ; preds = %406, %409
%410 = phi i64 [ %416, %409 ], [ %407, %406 ]
%411 = phi i64 [ %417, %409 ], [ 0, %406 ]
%412 = getelementptr i8, i8* %340, i64 %410
%413 = bitcast i8* %412 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %413
%414 = getelementptr i8, i8* %412, i64 16
%415 = bitcast i8* %414 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %415
%416 = add nuw i64 %410, 32
%417 = add i64 %411, 1
%418 = icmp eq i64 %417, %357
br i1 %418, label %419, label %409
419: ; preds = %409, %406
%420 = icmp eq i64 %59, %351
br i1 %420, label %424, label %421
421: ; preds = %344, %342, %419
%422 = phi i32 [ 0, %344 ], [ 0, %342 ], [ %352, %419 ]
%423 = phi i8* [ %340, %344 ], [ %340, %342 ], [ %353, %419 ]
br label %430
424: ; preds = %430, %419, %339
%425 = phi i8* [ %340, %339 ], [ %353, %419 ], [ %433, %430 ]
%426 = icmp ult i64 %58, %3
br i1 %426, label %427, label %437
427: ; preds = %424
%428 = sub i64 %3, %58
%429 = getelementptr i8, i8* %425, i64 %428
br label %437
430: ; preds = %421, %430
%431 = phi i32 [ %434, %430 ], [ %422, %421 ]
%432 = phi i8* [ %433, %430 ], [ %423, %421 ]
%433 = getelementptr inbounds i8, i8* %432, i64 1
store i8 48, i8* %432
%434 = add i32 %431, 1
%435 = zext i32 %434 to i64
%436 = icmp ugt i64 %59, %435
br i1 %436, label %430, label %424
437: ; preds = %427, %424
%438 = phi i8* [ %425, %424 ], [ %429, %427 ]
%439 = icmp eq i64 %57, 0
br i1 %439, label %843, label %440
440: ; preds = %437
%441 = icmp ult i64 %57, 32
br i1 %441, label %531, label %442
442: ; preds = %440
%443 = call i64 @llvm.umax.i64(i64 %58, i64 %3)
%444 = add i64 %57, %443
%445 = sub i64 %444, %58
%446 = getelementptr i8, i8* %425, i64 %445
%447 = getelementptr i8, i8* %1, i64 %57
%448 = icmp ult i8* %438, %447
%449 = icmp ugt i8* %446, %1
%450 = and i1 %448, %449
br i1 %450, label %531, label %451
451: ; preds = %442
%452 = and i64 %57, -32
%453 = getelementptr i8, i8* %438, i64 %452
%454 = add i64 %452, -32
%455 = lshr exact i64 %454, 5
%456 = add nuw nsw i64 %455, 1
%457 = and i64 %456, 3
%458 = icmp ult i64 %454, 96
br i1 %458, label %510, label %459
459: ; preds = %451
%460 = and i64 %456, 1152921504606846972
br label %461
461: ; preds = %461, %459
%462 = phi i64 [ 0, %459 ], [ %507, %461 ]
%463 = phi i64 [ 0, %459 ], [ %508, %461 ]
%464 = getelementptr i8, i8* %438, i64 %462
%465 = getelementptr inbounds i8, i8* %1, i64 %462
%466 = bitcast i8* %465 to <16 x i8>*
%467 = load <16 x i8>, <16 x i8>* %466
%468 = getelementptr inbounds i8, i8* %465, i64 16
%469 = bitcast i8* %468 to <16 x i8>*
%470 = load <16 x i8>, <16 x i8>* %469
%471 = bitcast i8* %464 to <16 x i8>*
store <16 x i8> %467, <16 x i8>* %471
%472 = getelementptr i8, i8* %464, i64 16
%473 = bitcast i8* %472 to <16 x i8>*
store <16 x i8> %470, <16 x i8>* %473
%474 = or i64 %462, 32
%475 = getelementptr i8, i8* %438, i64 %474
%476 = getelementptr inbounds i8, i8* %1, i64 %474
%477 = bitcast i8* %476 to <16 x i8>*
%478 = load <16 x i8>, <16 x i8>* %477
%479 = getelementptr inbounds i8, i8* %476, i64 16
%480 = bitcast i8* %479 to <16 x i8>*
%481 = load <16 x i8>, <16 x i8>* %480
%482 = bitcast i8* %475 to <16 x i8>*
store <16 x i8> %478, <16 x i8>* %482
%483 = getelementptr i8, i8* %475, i64 16
%484 = bitcast i8* %483 to <16 x i8>*
store <16 x i8> %481, <16 x i8>* %484
%485 = or i64 %462, 64
%486 = getelementptr i8, i8* %438, i64 %485
%487 = getelementptr inbounds i8, i8* %1, i64 %485
%488 = bitcast i8* %487 to <16 x i8>*
%489 = load <16 x i8>, <16 x i8>* %488
%490 = getelementptr inbounds i8, i8* %487, i64 16
%491 = bitcast i8* %490 to <16 x i8>*
%492 = load <16 x i8>, <16 x i8>* %491
%493 = bitcast i8* %486 to <16 x i8>*
store <16 x i8> %489, <16 x i8>* %493
%494 = getelementptr i8, i8* %486, i64 16
%495 = bitcast i8* %494 to <16 x i8>*
store <16 x i8> %492, <16 x i8>* %495
%496 = or i64 %462, 96
%497 = getelementptr i8, i8* %438, i64 %496
%498 = getelementptr inbounds i8, i8* %1, i64 %496
%499 = bitcast i8* %498 to <16 x i8>*
%500 = load <16 x i8>, <16 x i8>* %499
%501 = getelementptr inbounds i8, i8* %498, i64 16
%502 = bitcast i8* %501 to <16 x i8>*
%503 = load <16 x i8>, <16 x i8>* %502
%504 = bitcast i8* %497 to <16 x i8>*
store <16 x i8> %500, <16 x i8>* %504
%505 = getelementptr i8, i8* %497, i64 16
%506 = bitcast i8* %505 to <16 x i8>*
store <16 x i8> %503, <16 x i8>* %506
%507 = add nuw i64 %462, 128
%508 = add i64 %463, 4
%509 = icmp eq i64 %508, %460
br i1 %509, label %510, label %461
510: ; preds = %461, %451
%511 = phi i64 [ 0, %451 ], [ %507, %461 ]
%512 = icmp eq i64 %457, 0
br i1 %512, label %529, label %513
513: ; preds = %510, %513
%514 = phi i64 [ %526, %513 ], [ %511, %510 ]
%515 = phi i64 [ %527, %513 ], [ 0, %510 ]
%516 = getelementptr i8, i8* %438, i64 %514
%517 = getelementptr inbounds i8, i8* %1, i64 %514
%518 = bitcast i8* %517 to <16 x i8>*
%519 = load <16 x i8>, <16 x i8>* %518
%520 = getelementptr inbounds i8, i8* %517, i64 16
%521 = bitcast i8* %520 to <16 x i8>*
%522 = load <16 x i8>, <16 x i8>* %521
%523 = bitcast i8* %516 to <16 x i8>*
store <16 x i8> %519, <16 x i8>* %523
%524 = getelementptr i8, i8* %516, i64 16
%525 = bitcast i8* %524 to <16 x i8>*
store <16 x i8> %522, <16 x i8>* %525
%526 = add nuw i64 %514, 32
%527 = add i64 %515, 1
%528 = icmp eq i64 %527, %457
br i1 %528, label %529, label %513
529: ; preds = %513, %510
%530 = icmp eq i64 %57, %452
br i1 %530, label %843, label %531
531: ; preds = %442, %440, %529
%532 = phi i64 [ 0, %442 ], [ 0, %440 ], [ %452, %529 ]
%533 = phi i8* [ %438, %442 ], [ %438, %440 ], [ %453, %529 ]
%534 = xor i64 %532, -1
%535 = add i64 %57, %534
%536 = and i64 %57, 7
%537 = icmp eq i64 %536, 0
br i1 %537, label %548, label %538
538: ; preds = %531, %538
%539 = phi i64 [ %545, %538 ], [ %532, %531 ]
%540 = phi i8* [ %544, %538 ], [ %533, %531 ]
%541 = phi i64 [ %546, %538 ], [ 0, %531 ]
%542 = getelementptr inbounds i8, i8* %1, i64 %539
%543 = load i8, i8* %542
%544 = getelementptr inbounds i8, i8* %540, i64 1
store i8 %543, i8* %540
%545 = add nuw i64 %539, 1
%546 = add i64 %541, 1
%547 = icmp eq i64 %546, %536
br i1 %547, label %548, label %538
548: ; preds = %538, %531
%549 = phi i8* [ undef, %531 ], [ %544, %538 ]
%550 = phi i64 [ %532, %531 ], [ %545, %538 ]
%551 = phi i8* [ %533, %531 ], [ %544, %538 ]
%552 = icmp ult i64 %535, 7
br i1 %552, label %843, label %553
553: ; preds = %548, %553
%554 = phi i64 [ %587, %553 ], [ %550, %548 ]
%555 = phi i8* [ %586, %553 ], [ %551, %548 ]
%556 = getelementptr inbounds i8, i8* %1, i64 %554
%557 = load i8, i8* %556
%558 = getelementptr inbounds i8, i8* %555, i64 1
store i8 %557, i8* %555
%559 = add nuw i64 %554, 1
%560 = getelementptr inbounds i8, i8* %1, i64 %559
%561 = load i8, i8* %560
%562 = getelementptr inbounds i8, i8* %555, i64 2
store i8 %561, i8* %558
%563 = add nuw i64 %554, 2
%564 = getelementptr inbounds i8, i8* %1, i64 %563
%565 = load i8, i8* %564
%566 = getelementptr inbounds i8, i8* %555, i64 3
store i8 %565, i8* %562
%567 = add nuw i64 %554, 3
%568 = getelementptr inbounds i8, i8* %1, i64 %567
%569 = load i8, i8* %568
%570 = getelementptr inbounds i8, i8* %555, i64 4
store i8 %569, i8* %566
%571 = add nuw i64 %554, 4
%572 = getelementptr inbounds i8, i8* %1, i64 %571
%573 = load i8, i8* %572
%574 = getelementptr inbounds i8, i8* %555, i64 5
store i8 %573, i8* %570
%575 = add nuw i64 %554, 5
%576 = getelementptr inbounds i8, i8* %1, i64 %575
%577 = load i8, i8* %576
%578 = getelementptr inbounds i8, i8* %555, i64 6
store i8 %577, i8* %574
%579 = add nuw i64 %554, 6
%580 = getelementptr inbounds i8, i8* %1, i64 %579
%581 = load i8, i8* %580
%582 = getelementptr inbounds i8, i8* %555, i64 7
store i8 %581, i8* %578
%583 = add nuw i64 %554, 7
%584 = getelementptr inbounds i8, i8* %1, i64 %583
%585 = load i8, i8* %584
%586 = getelementptr inbounds i8, i8* %555, i64 8
store i8 %585, i8* %582
%587 = add nuw i64 %554, 8
%588 = icmp eq i64 %587, %57
br i1 %588, label %843, label %553
589: ; preds = %324, %322
%590 = phi i8* [ %0, %322 ], [ %326, %324 ]
br i1 %36, label %593, label %591
591: ; preds = %589
%592 = getelementptr inbounds i8, i8* %590, i64 1
store i8 %15, i8* %590
br label %593
593: ; preds = %591, %589
%594 = phi i8* [ %592, %591 ], [ %590, %589 ]
br i1 %30, label %597, label %595
595: ; preds = %593
%596 = getelementptr inbounds i8, i8* %594, i64 1
store i8 %31, i8* %594
br label %597
597: ; preds = %595, %593
%598 = phi i8* [ %596, %595 ], [ %594, %593 ]
br i1 %33, label %602, label %599
599: ; preds = %597
%600 = getelementptr inbounds i8, i8* %598, i64 1
store i8 %34, i8* %598
%601 = getelementptr inbounds i8, i8* %598, i64 2
store i8 %32, i8* %600
br label %602
602: ; preds = %599, %597
%603 = phi i8* [ %601, %599 ], [ %598, %597 ]
%604 = icmp eq i64 %59, 0
br i1 %604, label %687, label %605
605: ; preds = %602
%606 = icmp ult i64 %59, 32
br i1 %606, label %684, label %607
607: ; preds = %605
%608 = add i64 %59, -1
%609 = trunc i64 %608 to i32
%610 = icmp eq i32 %609, -1
%611 = icmp ugt i64 %608, 4294967295
%612 = or i1 %610, %611
br i1 %612, label %684, label %613
613: ; preds = %607
%614 = and i64 %59, -32
%615 = trunc i64 %614 to i32
%616 = getelementptr i8, i8* %603, i64 %614
%617 = add i64 %614, -32
%618 = lshr exact i64 %617, 5
%619 = add nuw nsw i64 %618, 1
%620 = and i64 %619, 7
%621 = icmp ult i64 %617, 224
br i1 %621, label %669, label %622
622: ; preds = %613
%623 = and i64 %619, 1152921504606846968
br label %624
624: ; preds = %624, %622
%625 = phi i64 [ 0, %622 ], [ %666, %624 ]
%626 = phi i64 [ 0, %622 ], [ %667, %624 ]
%627 = getelementptr i8, i8* %603, i64 %625
%628 = bitcast i8* %627 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %628
%629 = getelementptr i8, i8* %627, i64 16
%630 = bitcast i8* %629 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %630
%631 = or i64 %625, 32
%632 = getelementptr i8, i8* %603, i64 %631
%633 = bitcast i8* %632 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %633
%634 = getelementptr i8, i8* %632, i64 16
%635 = bitcast i8* %634 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %635
%636 = or i64 %625, 64
%637 = getelementptr i8, i8* %603, i64 %636
%638 = bitcast i8* %637 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %638
%639 = getelementptr i8, i8* %637, i64 16
%640 = bitcast i8* %639 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %640
%641 = or i64 %625, 96
%642 = getelementptr i8, i8* %603, i64 %641
%643 = bitcast i8* %642 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %643
%644 = getelementptr i8, i8* %642, i64 16
%645 = bitcast i8* %644 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %645
%646 = or i64 %625, 128
%647 = getelementptr i8, i8* %603, i64 %646
%648 = bitcast i8* %647 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %648
%649 = getelementptr i8, i8* %647, i64 16
%650 = bitcast i8* %649 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %650
%651 = or i64 %625, 160
%652 = getelementptr i8, i8* %603, i64 %651
%653 = bitcast i8* %652 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %653
%654 = getelementptr i8, i8* %652, i64 16
%655 = bitcast i8* %654 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %655
%656 = or i64 %625, 192
%657 = getelementptr i8, i8* %603, i64 %656
%658 = bitcast i8* %657 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %658
%659 = getelementptr i8, i8* %657, i64 16
%660 = bitcast i8* %659 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %660
%661 = or i64 %625, 224
%662 = getelementptr i8, i8* %603, i64 %661
%663 = bitcast i8* %662 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %663
%664 = getelementptr i8, i8* %662, i64 16
%665 = bitcast i8* %664 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %665
%666 = add nuw i64 %625, 256
%667 = add i64 %626, 8
%668 = icmp eq i64 %667, %623
br i1 %668, label %669, label %624
669: ; preds = %624, %613
%670 = phi i64 [ 0, %613 ], [ %666, %624 ]
%671 = icmp eq i64 %620, 0
br i1 %671, label %682, label %672
672: ; preds = %669, %672
%673 = phi i64 [ %679, %672 ], [ %670, %669 ]
%674 = phi i64 [ %680, %672 ], [ 0, %669 ]
%675 = getelementptr i8, i8* %603, i64 %673
%676 = bitcast i8* %675 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %676
%677 = getelementptr i8, i8* %675, i64 16
%678 = bitcast i8* %677 to <16 x i8>*
store <16 x i8> <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>, <16 x i8>* %678
%679 = add nuw i64 %673, 32
%680 = add i64 %674, 1
%681 = icmp eq i64 %680, %620
br i1 %681, label %682, label %672
682: ; preds = %672, %669
%683 = icmp eq i64 %59, %614
br i1 %683, label %687, label %684
684: ; preds = %607, %605, %682
%685 = phi i32 [ 0, %607 ], [ 0, %605 ], [ %615, %682 ]
%686 = phi i8* [ %603, %607 ], [ %603, %605 ], [ %616, %682 ]
br label %800
687: ; preds = %800, %682, %602
%688 = phi i8* [ %603, %602 ], [ %616, %682 ], [ %803, %800 ]
%689 = icmp eq i64 %57, 0
br i1 %689, label %843, label %690
690: ; preds = %687
%691 = icmp ult i64 %57, 32
br i1 %691, label %778, label %692
692: ; preds = %690
%693 = getelementptr i8, i8* %688, i64 %57
%694 = getelementptr i8, i8* %1, i64 %57
%695 = icmp ult i8* %688, %694
%696 = icmp ugt i8* %693, %1
%697 = and i1 %695, %696
br i1 %697, label %778, label %698
698: ; preds = %692
%699 = and i64 %57, -32
%700 = getelementptr i8, i8* %688, i64 %699
%701 = add i64 %699, -32
%702 = lshr exact i64 %701, 5
%703 = add nuw nsw i64 %702, 1
%704 = and i64 %703, 3
%705 = icmp ult i64 %701, 96
br i1 %705, label %757, label %706
706: ; preds = %698
%707 = and i64 %703, 1152921504606846972
br label %708
708: ; preds = %708, %706
%709 = phi i64 [ 0, %706 ], [ %754, %708 ]
%710 = phi i64 [ 0, %706 ], [ %755, %708 ]
%711 = getelementptr i8, i8* %688, i64 %709
%712 = getelementptr inbounds i8, i8* %1, i64 %709
%713 = bitcast i8* %712 to <16 x i8>*
%714 = load <16 x i8>, <16 x i8>* %713
%715 = getelementptr inbounds i8, i8* %712, i64 16
%716 = bitcast i8* %715 to <16 x i8>*
%717 = load <16 x i8>, <16 x i8>* %716
%718 = bitcast i8* %711 to <16 x i8>*
store <16 x i8> %714, <16 x i8>* %718
%719 = getelementptr i8, i8* %711, i64 16
%720 = bitcast i8* %719 to <16 x i8>*
store <16 x i8> %717, <16 x i8>* %720
%721 = or i64 %709, 32
%722 = getelementptr i8, i8* %688, i64 %721
%723 = getelementptr inbounds i8, i8* %1, i64 %721
%724 = bitcast i8* %723 to <16 x i8>*
%725 = load <16 x i8>, <16 x i8>* %724
%726 = getelementptr inbounds i8, i8* %723, i64 16
%727 = bitcast i8* %726 to <16 x i8>*
%728 = load <16 x i8>, <16 x i8>* %727
%729 = bitcast i8* %722 to <16 x i8>*
store <16 x i8> %725, <16 x i8>* %729
%730 = getelementptr i8, i8* %722, i64 16
%731 = bitcast i8* %730 to <16 x i8>*
store <16 x i8> %728, <16 x i8>* %731
%732 = or i64 %709, 64
%733 = getelementptr i8, i8* %688, i64 %732
%734 = getelementptr inbounds i8, i8* %1, i64 %732
%735 = bitcast i8* %734 to <16 x i8>*
%736 = load <16 x i8>, <16 x i8>* %735
%737 = getelementptr inbounds i8, i8* %734, i64 16
%738 = bitcast i8* %737 to <16 x i8>*
%739 = load <16 x i8>, <16 x i8>* %738
%740 = bitcast i8* %733 to <16 x i8>*
store <16 x i8> %736, <16 x i8>* %740
%741 = getelementptr i8, i8* %733, i64 16
%742 = bitcast i8* %741 to <16 x i8>*
store <16 x i8> %739, <16 x i8>* %742
%743 = or i64 %709, 96
%744 = getelementptr i8, i8* %688, i64 %743
%745 = getelementptr inbounds i8, i8* %1, i64 %743
%746 = bitcast i8* %745 to <16 x i8>*
%747 = load <16 x i8>, <16 x i8>* %746
%748 = getelementptr inbounds i8, i8* %745, i64 16
%749 = bitcast i8* %748 to <16 x i8>*
%750 = load <16 x i8>, <16 x i8>* %749
%751 = bitcast i8* %744 to <16 x i8>*
store <16 x i8> %747, <16 x i8>* %751
%752 = getelementptr i8, i8* %744, i64 16
%753 = bitcast i8* %752 to <16 x i8>*
store <16 x i8> %750, <16 x i8>* %753
%754 = add nuw i64 %709, 128
%755 = add i64 %710, 4
%756 = icmp eq i64 %755, %707
br i1 %756, label %757, label %708
757: ; preds = %708, %698
%758 = phi i64 [ 0, %698 ], [ %754, %708 ]
%759 = icmp eq i64 %704, 0
br i1 %759, label %776, label %760
760: ; preds = %757, %760
%761 = phi i64 [ %773, %760 ], [ %758, %757 ]
%762 = phi i64 [ %774, %760 ], [ 0, %757 ]
%763 = getelementptr i8, i8* %688, i64 %761
%764 = getelementptr inbounds i8, i8* %1, i64 %761
%765 = bitcast i8* %764 to <16 x i8>*
%766 = load <16 x i8>, <16 x i8>* %765
%767 = getelementptr inbounds i8, i8* %764, i64 16
%768 = bitcast i8* %767 to <16 x i8>*
%769 = load <16 x i8>, <16 x i8>* %768
%770 = bitcast i8* %763 to <16 x i8>*
store <16 x i8> %766, <16 x i8>* %770
%771 = getelementptr i8, i8* %763, i64 16
%772 = bitcast i8* %771 to <16 x i8>*
store <16 x i8> %769, <16 x i8>* %772
%773 = add nuw i64 %761, 32
%774 = add i64 %762, 1
%775 = icmp eq i64 %774, %704
br i1 %775, label %776, label %760
776: ; preds = %760, %757
%777 = icmp eq i64 %57, %699
br i1 %777, label %843, label %778
778: ; preds = %692, %690, %776
%779 = phi i64 [ 0, %692 ], [ 0, %690 ], [ %699, %776 ]
%780 = phi i8* [ %688, %692 ], [ %688, %690 ], [ %700, %776 ]
%781 = xor i64 %779, -1
%782 = add i64 %57, %781
%783 = and i64 %57, 7
%784 = icmp eq i64 %783, 0
br i1 %784, label %795, label %785
785: ; preds = %778, %785
%786 = phi i64 [ %792, %785 ], [ %779, %778 ]
%787 = phi i8* [ %791, %785 ], [ %780, %778 ]
%788 = phi i64 [ %793, %785 ], [ 0, %778 ]
%789 = getelementptr inbounds i8, i8* %1, i64 %786
%790 = load i8, i8* %789
%791 = getelementptr inbounds i8, i8* %787, i64 1
store i8 %790, i8* %787
%792 = add nuw i64 %786, 1
%793 = add i64 %788, 1
%794 = icmp eq i64 %793, %783
br i1 %794, label %795, label %785
795: ; preds = %785, %778
%796 = phi i8* [ undef, %778 ], [ %791, %785 ]
%797 = phi i64 [ %779, %778 ], [ %792, %785 ]
%798 = phi i8* [ %780, %778 ], [ %791, %785 ]
%799 = icmp ult i64 %782, 7
br i1 %799, label %843, label %807
800: ; preds = %684, %800
%801 = phi i32 [ %804, %800 ], [ %685, %684 ]
%802 = phi i8* [ %803, %800 ], [ %686, %684 ]
%803 = getelementptr inbounds i8, i8* %802, i64 1
store i8 48, i8* %802
%804 = add i32 %801, 1
%805 = zext i32 %804 to i64
%806 = icmp ugt i64 %59, %805
br i1 %806, label %800, label %687
807: ; preds = %795, %807
%808 = phi i64 [ %841, %807 ], [ %797, %795 ]
%809 = phi i8* [ %840, %807 ], [ %798, %795 ]
%810 = getelementptr inbounds i8, i8* %1, i64 %808
%811 = load i8, i8* %810
%812 = getelementptr inbounds i8, i8* %809, i64 1
store i8 %811, i8* %809
%813 = add nuw i64 %808, 1
%814 = getelementptr inbounds i8, i8* %1, i64 %813
%815 = load i8, i8* %814
%816 = getelementptr inbounds i8, i8* %809, i64 2
store i8 %815, i8* %812
%817 = add nuw i64 %808, 2
%818 = getelementptr inbounds i8, i8* %1, i64 %817
%819 = load i8, i8* %818
%820 = getelementptr inbounds i8, i8* %809, i64 3
store i8 %819, i8* %816
%821 = add nuw i64 %808, 3
%822 = getelementptr inbounds i8, i8* %1, i64 %821
%823 = load i8, i8* %822
%824 = getelementptr inbounds i8, i8* %809, i64 4
store i8 %823, i8* %820
%825 = add nuw i64 %808, 4
%826 = getelementptr inbounds i8, i8* %1, i64 %825
%827 = load i8, i8* %826
%828 = getelementptr inbounds i8, i8* %809, i64 5
store i8 %827, i8* %824
%829 = add nuw i64 %808, 5
%830 = getelementptr inbounds i8, i8* %1, i64 %829
%831 = load i8, i8* %830
%832 = getelementptr inbounds i8, i8* %809, i64 6
store i8 %831, i8* %828
%833 = add nuw i64 %808, 6
%834 = getelementptr inbounds i8, i8* %1, i64 %833
%835 = load i8, i8* %834
%836 = getelementptr inbounds i8, i8* %809, i64 7
store i8 %835, i8* %832
%837 = add nuw i64 %808, 7
%838 = getelementptr inbounds i8, i8* %1, i64 %837
%839 = load i8, i8* %838
%840 = getelementptr inbounds i8, i8* %809, i64 8
store i8 %839, i8* %836
%841 = add nuw i64 %808, 8
%842 = icmp eq i64 %841, %57
br i1 %842, label %843, label %807
843: ; preds = %548, %553, %795, %807, %529, %776, %282, %437, %687, %279
%844 = phi i8* [ %280, %279 ], [ %688, %687 ], [ %438, %437 ], [ %284, %282 ], [ %700, %776 ], [ %453, %529 ], [ %796, %795 ], [ %840, %807 ], [ %549, %548 ], [ %586, %553 ]
store i8 0, i8* %844
ret i8* %844
}