#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 */

/* Variables and functions */
int /*<<< orphan*/ memset(unsigned char *, int /*<<< orphan*/, size_t);
char *hex_to_decimal(const char *hex, size_t hex_len, char *buf,
                     size_t buf_len) {
  size_t i, j, k, dec_len;
  unsigned char *dec_buf;
  char ascii_offset;
  unsigned char num_val;
  if (hex == 0 || buf == 0 || buf_len < 2 || buf_len < hex_len) {
    return NULL;
  }
  if (hex_len >= 2 && hex[0] == '0' && (hex[1] == 'x' || hex[1] == 'X')) {
    hex += 2;
    hex_len -= 2;
  }
  dec_buf = (unsigned char *)buf;
  dec_len = buf_len - 1;
  memset(dec_buf, 0, dec_len);
  for (i = 0; i < hex_len && hex[i] != 0; ++i) {
    ascii_offset = 0;
    if (hex[i] >= '0' && hex[i] <= '9') {
      ascii_offset = '0';
    } else if (hex[i] >= 'A' && hex[i] <= 'F') {
      ascii_offset = 'A';
    } else if (hex[i] >= 'a' && hex[i] <= 'f') {
      ascii_offset = 'a';
    }
    if (ascii_offset == 0) {
      dec_buf[0] = '\0';
      return NULL;
    }
    for (j = 0; j < dec_len; ++j) {
      k = dec_len - 1 - j;
      dec_buf[k] *= 16;
    }
    if (ascii_offset == '0') {
      num_val = (hex[i] - '0');
    } else {
      num_val = 10 + (hex[i] - ascii_offset);
    }
    dec_buf[dec_len - 1] += num_val;
    for (j = 0; j < dec_len; ++j) {
      k = dec_len - 1 - j;
      if (dec_buf[k] >= 10) {
        dec_buf[k - 1] += (dec_buf[k] / 10);
        dec_buf[k] = (dec_buf[k] % 10);
      }
    }
  }
  for (j = 0; j < dec_len; ++j) {
    buf[j] = '0' + dec_buf[j];
  }
  for (j = 0; j < dec_len && dec_buf[j] == '0'; ++j) {
    ;
  }
  if (j == dec_len) {
    --j;
  }
  for (i = 0; i < (dec_len - j); ++i) {
    dec_buf[i] = dec_buf[i + j];
  }
  buf[buf_len - 1 - j] = '\0';
  return buf;
}


x86 assembly (clang, -O0):
<hex_to_decimal>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1157 <hex_to_decimal+0x47>
cmpq   $0x0,-0x20(%rbp)
je     1157 <hex_to_decimal+0x47>
cmpq   $0x2,-0x28(%rbp)
jb     1157 <hex_to_decimal+0x47>
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1164 <hex_to_decimal+0x54>
movq   $0x0,-0x8(%rbp)
jmp    1545 <hex_to_decimal+0x435>
cmpq   $0x2,-0x18(%rbp)
jb     11b9 <hex_to_decimal+0xa9>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jne    11b9 <hex_to_decimal+0xa9>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x78,%eax
je     11a1 <hex_to_decimal+0x91>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x58,%eax
jne    11b9 <hex_to_decimal+0xa9>
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
sub    $0x2,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x48(%rbp),%rdx
xor    %esi,%esi
call   1030 <memset@plt>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x18(%rbp),%rcx
mov    %al,-0x53(%rbp)
jae    120c <hex_to_decimal+0xfc>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x53(%rbp)
mov    -0x53(%rbp),%al
test   $0x1,%al
jne    121c <hex_to_decimal+0x10c>
jmp    142e <hex_to_decimal+0x31e>
movb   $0x0,-0x51(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jl     1253 <hex_to_decimal+0x143>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jg     1253 <hex_to_decimal+0x143>
movb   $0x30,-0x51(%rbp)
jmp    12be <hex_to_decimal+0x1ae>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jl     1286 <hex_to_decimal+0x176>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x46,%eax
jg     1286 <hex_to_decimal+0x176>
movb   $0x41,-0x51(%rbp)
jmp    12b9 <hex_to_decimal+0x1a9>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x61,%eax
jl     12b4 <hex_to_decimal+0x1a4>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x66,%eax
jg     12b4 <hex_to_decimal+0x1a4>
movb   $0x61,-0x51(%rbp)
jmp    12b9 <hex_to_decimal+0x1a9>
jmp    12be <hex_to_decimal+0x1ae>
movsbl -0x51(%rbp),%eax
cmp    $0x0,%eax
jne    12df <hex_to_decimal+0x1cf>
mov    -0x50(%rbp),%rax
movb   $0x0,(%rax)
movq   $0x0,-0x8(%rbp)
jmp    1545 <hex_to_decimal+0x435>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1328 <hex_to_decimal+0x218>
mov    -0x48(%rbp),%rax
sub    $0x1,%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
shl    $0x4,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    12e7 <hex_to_decimal+0x1d7>
movsbl -0x51(%rbp),%eax
cmp    $0x30,%eax
jne    134c <hex_to_decimal+0x23c>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    %al,-0x52(%rbp)
jmp    1364 <hex_to_decimal+0x254>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x51(%rbp),%ecx
sub    %ecx,%eax
add    $0xa,%eax
mov    %al,-0x52(%rbp)
movzbl -0x52(%rbp),%esi
mov    -0x50(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
movzbl (%rax,%rcx,1),%edx
add    %esi,%edx
mov    %dl,(%rax,%rcx,1)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1418 <hex_to_decimal+0x308>
mov    -0x48(%rbp),%rax
sub    $0x1,%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
jl     1402 <hex_to_decimal+0x2f2>
mov    -0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
mov    -0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    $0x1,%rcx
movzbl (%rax,%rcx,1),%edx
add    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    -0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1407 <hex_to_decimal+0x2f7>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1385 <hex_to_decimal+0x275>
jmp    141d <hex_to_decimal+0x30d>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11e4 <hex_to_decimal+0xd4>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1471 <hex_to_decimal+0x361>
mov    -0x50(%rbp),%rax
mov    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
add    $0x30,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1436 <hex_to_decimal+0x326>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rcx
xor    %eax,%eax
cmp    -0x48(%rbp),%rcx
mov    %al,-0x54(%rbp)
jae    14a1 <hex_to_decimal+0x391>
mov    -0x50(%rbp),%rax
mov    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
sete   %al
mov    %al,-0x54(%rbp)
mov    -0x54(%rbp),%al
test   $0x1,%al
jne    14b1 <hex_to_decimal+0x3a1>
jmp    14c7 <hex_to_decimal+0x3b7>
jmp    14b6 <hex_to_decimal+0x3a6>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1479 <hex_to_decimal+0x369>
mov    -0x38(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    14e1 <hex_to_decimal+0x3d1>
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    -0x38(%rbp),%rcx
cmp    %rcx,%rax
jae    1529 <hex_to_decimal+0x419>
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x38(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    14e9 <hex_to_decimal+0x3d9>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
sub    -0x38(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hex_to_decimal>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
xor    %eax,%eax
mov    %rsi,(%rsp)
cmp    %rsi,%rcx
jb     159c <hex_to_decimal+0x48c>
mov    %rdi,%r12
test   %rdi,%rdi
je     159c <hex_to_decimal+0x48c>
mov    %rdx,%r14
test   %rdx,%rdx
je     159c <hex_to_decimal+0x48c>
mov    %rcx,%r13
cmp    $0x2,%rcx
jb     159c <hex_to_decimal+0x48c>
cmpq   $0x2,(%rsp)
jb     1174 <hex_to_decimal+0x64>
cmpb   $0x30,(%r12)
jne    1191 <hex_to_decimal+0x81>
mov    0x1(%r12),%al
or     $0x20,%al
cmp    $0x78,%al
jne    1191 <hex_to_decimal+0x81>
add    $0x2,%r12
addq   $0xfffffffffffffffe,(%rsp)
lea    -0x1(%r13),%r15
mov    %r14,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
cmpq   $0x0,(%rsp)
jne    11a2 <hex_to_decimal+0x92>
jmp    13d9 <hex_to_decimal+0x2c9>
lea    -0x1(%r13),%r15
mov    %r14,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
lea    -0x2(%r13),%r9
lea    -0x10(%r15),%rax
mov    %rax,0x20(%rsp)
shr    $0x4,%rax
add    $0x1,%rax
mov    %r15,%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rcx,0x8(%rsp)
mov    %eax,%r10d
and    $0x3,%r10d
and    $0xfffffffffffffffc,%rax
mov    %rax,0x10(%rsp)
mov    %r15,%r8
and    $0xfffffffffffffff8,%r8
lea    (%r14,%r13,1),%rdi
add    $0xffffffffffffffef,%rdi
mov    %r10,0x18(%rsp)
shl    $0x4,%r10
mov    %r8,%rcx
neg    %rcx
lea    (%r14,%r13,1),%rsi
add    $0xfffffffffffffffe,%rsi
mov    %r15,%rbx
neg    %rbx
movdqa 0xdf9(%rip),%xmm0
xor    %r11d,%r11d
jmp    121e <hex_to_decimal+0x10e>
nopl   0x0(%rax)
add    $0x1,%r11
cmp    (%rsp),%r11
je     13d4 <hex_to_decimal+0x2c4>
mov    (%r12,%r11,1),%dl
test   %dl,%dl
je     13d4 <hex_to_decimal+0x2c4>
lea    -0x30(%rdx),%eax
mov    $0xd0,%r13b
cmp    $0xa,%al
jb     124d <hex_to_decimal+0x13d>
lea    -0x41(%rdx),%eax
mov    $0xc9,%r13b
cmp    $0x6,%al
jb     124d <hex_to_decimal+0x13d>
add    $0x9f,%dl
mov    $0xa9,%r13b
cmp    $0x5,%dl
ja     14fb <hex_to_decimal+0x3eb>
cmp    $0x8,%r15
jae    1260 <hex_to_decimal+0x150>
xor    %ebp,%ebp
jmp    1376 <hex_to_decimal+0x266>
nopw   0x0(%rax,%rax,1)
cmp    $0x10,%r15
jae    1270 <hex_to_decimal+0x160>
xor    %edx,%edx
jmp    1340 <hex_to_decimal+0x230>
nopl   (%rax)
cmpq   $0x30,0x20(%rsp)
jae    1287 <hex_to_decimal+0x177>
xor    %ebp,%ebp
cmpq   $0x0,0x18(%rsp)
jne    12f7 <hex_to_decimal+0x1e7>
jmp    131f <hex_to_decimal+0x20f>
mov    0x10(%rsp),%rdx
xor    %ebp,%ebp
xchg   %ax,%ax
movdqu -0x30(%rdi,%rbp,1),%xmm1
movdqu -0x20(%rdi,%rbp,1),%xmm2
movdqu -0x10(%rdi,%rbp,1),%xmm3
movdqu (%rdi,%rbp,1),%xmm4
psllw  $0x4,%xmm4
pand   %xmm0,%xmm4
movdqu %xmm4,(%rdi,%rbp,1)
psllw  $0x4,%xmm3
pand   %xmm0,%xmm3
movdqu %xmm3,-0x10(%rdi,%rbp,1)
psllw  $0x4,%xmm2
pand   %xmm0,%xmm2
movdqu %xmm2,-0x20(%rdi,%rbp,1)
psllw  $0x4,%xmm1
pand   %xmm0,%xmm1
movdqu %xmm1,-0x30(%rdi,%rbp,1)
add    $0xffffffffffffffc0,%rbp
add    $0xfffffffffffffffc,%rdx
jne    1290 <hex_to_decimal+0x180>
neg    %rbp
cmpq   $0x0,0x18(%rsp)
je     131f <hex_to_decimal+0x20f>
mov    %rdi,%rdx
sub    %rbp,%rdx
xor    %eax,%eax
nop
movdqu (%rdx,%rax,1),%xmm1
psllw  $0x4,%xmm1
pand   %xmm0,%xmm1
movdqu %xmm1,(%rdx,%rax,1)
add    $0xfffffffffffffff0,%rax
mov    %r10,%rbp
add    %rax,%rbp
jne    1300 <hex_to_decimal+0x1f0>
cmp    0x8(%rsp),%r15
je     138d <hex_to_decimal+0x27d>
mov    0x8(%rsp),%rbp
mov    %rbp,%rdx
test   $0x8,%r15b
je     1376 <hex_to_decimal+0x266>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
neg    %rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   0x8(%rdi,%rdx,1),%xmm1
psllw  $0x4,%xmm1
pand   %xmm0,%xmm1
movq   %xmm1,0x8(%rdi,%rdx,1)
add    $0xfffffffffffffff8,%rdx
cmp    %rdx,%rcx
jne    1350 <hex_to_decimal+0x240>
mov    %r8,%rbp
cmp    %r8,%r15
je     138d <hex_to_decimal+0x27d>
neg    %rbp
nopl   0x0(%rax)
shlb   $0x4,(%rsi,%rbp,1)
add    $0xffffffffffffffff,%rbp
cmp    %rbp,%rbx
jne    1380 <hex_to_decimal+0x270>
add    (%r12,%r11,1),%r13b
add    %r13b,(%r14,%r9,1)
xor    %edx,%edx
jmp    13ad <hex_to_decimal+0x29d>
nopl   0x0(%rax)
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%rbx
je     1210 <hex_to_decimal+0x100>
movzbl (%rsi,%rdx,1),%eax
cmp    $0xa,%al
jb     13a0 <hex_to_decimal+0x290>
movzbl %al,%ebp
imul   $0xcd,%ebp,%ebp
shr    $0xb,%ebp
add    %bpl,-0x1(%rsi,%rdx,1)
add    %ebp,%ebp
lea    0x0(%rbp,%rbp,4),%ebp
sub    %bpl,%al
mov    %al,(%rsi,%rdx,1)
jmp    13a0 <hex_to_decimal+0x290>
test   %r15,%r15
je     13f3 <hex_to_decimal+0x2e3>
cmp    $0x8,%r15
jae    13e6 <hex_to_decimal+0x2d6>
xor    %eax,%eax
jmp    150f <hex_to_decimal+0x3ff>
cmp    $0x20,%r15
jae    13fd <hex_to_decimal+0x2ed>
xor    %eax,%eax
jmp    14ca <hex_to_decimal+0x3ba>
xor    %r15d,%r15d
xor    %eax,%eax
jmp    1533 <hex_to_decimal+0x423>
mov    %r15,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rdx
mov    %rdx,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     1506 <hex_to_decimal+0x3f6>
movabs $0xffffffffffffffc,%rsi
ff ff 0f
or     $0x2,%rsi
and    %rcx,%rsi
xor    %edx,%edx
movdqa 0xbd9(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movdqu (%r14,%rdx,1),%xmm1
movdqu 0x10(%r14,%rdx,1),%xmm2
movdqu 0x20(%r14,%rdx,1),%xmm3
movdqu 0x30(%r14,%rdx,1),%xmm4
paddb  %xmm0,%xmm1
paddb  %xmm0,%xmm2
movdqu %xmm1,(%r14,%rdx,1)
movdqu %xmm2,0x10(%r14,%rdx,1)
paddb  %xmm0,%xmm3
paddb  %xmm0,%xmm4
movdqu %xmm3,0x20(%r14,%rdx,1)
movdqu %xmm4,0x30(%r14,%rdx,1)
add    $0x40,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1440 <hex_to_decimal+0x330>
test   $0x1,%cl
je     14bf <hex_to_decimal+0x3af>
movdqu (%r14,%rdx,1),%xmm0
movdqu 0x10(%r14,%rdx,1),%xmm1
movdqa 0xb66(%rip),%xmm2
paddb  %xmm2,%xmm0
paddb  %xmm2,%xmm1
movdqu %xmm0,(%r14,%rdx,1)
movdqu %xmm1,0x10(%r14,%rdx,1)
cmp    %rax,%r15
je     151d <hex_to_decimal+0x40d>
test   $0x18,%r15b
je     150f <hex_to_decimal+0x3ff>
mov    %rax,%rcx
mov    %r15,%rax
and    $0xfffffffffffffff8,%rax
movdqa 0xb44(%rip),%xmm0
nopl   0x0(%rax)
movq   (%r14,%rcx,1),%xmm1
paddb  %xmm0,%xmm1
movq   %xmm1,(%r14,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    14e0 <hex_to_decimal+0x3d0>
jmp    1518 <hex_to_decimal+0x408>
mov    %r14,%rcx
xor    %r14d,%r14d
jmp    1596 <hex_to_decimal+0x486>
xor    %edx,%edx
test   $0x1,%cl
jne    1495 <hex_to_decimal+0x385>
jmp    14bf <hex_to_decimal+0x3af>
addb   $0x30,(%r14,%rax,1)
add    $0x1,%rax
cmp    %rax,%r15
jne    150f <hex_to_decimal+0x3ff>
xor    %eax,%eax
nop
cmpb   $0x30,(%r14,%rax,1)
jne    1533 <hex_to_decimal+0x423>
add    $0x1,%rax
cmp    %rax,%r15
jne    1520 <hex_to_decimal+0x410>
mov    %r15,%rax
xor    %esi,%esi
cmp    %rax,%r15
sete   %sil
mov    %rax,%rdx
sub    %rsi,%rdx
mov    %r15,%rcx
sub    %rdx,%rcx
je     1593 <hex_to_decimal+0x483>
neg    %rsi
add    %rsi,%rax
mov    %r15,%r8
sub    %rax,%r8
cmp    $0x8,%r8
jb     1571 <hex_to_decimal+0x461>
lea    (%r14,%r15,1),%rsi
cmp    %r14,%rsi
jbe    15ab <hex_to_decimal+0x49b>
lea    (%r14,%r8,1),%rsi
add    %r14,%rdx
cmp    %rsi,%rdx
jae    15ab <hex_to_decimal+0x49b>
xor    %edx,%edx
sub    %rdx,%r15
add    %r14,%rdx
nopl   0x0(%rax)
movzbl (%rdx,%rax,1),%ebx
mov    %bl,(%rdx)
add    $0xffffffffffffffff,%r15
add    $0x1,%rdx
cmp    %r15,%rax
jne    1580 <hex_to_decimal+0x470>
add    %r14,%rcx
movb   $0x0,(%rcx)
mov    %r14,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x20,%r8
jae    15b8 <hex_to_decimal+0x4a8>
xor    %edx,%edx
jmp    16a1 <hex_to_decimal+0x591>
mov    %r8,%rdx
and    $0xffffffffffffffe0,%rdx
lea    -0x20(%rdx),%rsi
mov    %rsi,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%ebp
and    $0x3,%ebp
cmp    $0x60,%rsi
jae    15dd <hex_to_decimal+0x4cd>
xor    %ebx,%ebx
jmp    1654 <hex_to_decimal+0x544>
and    $0xfffffffffffffffc,%rdi
lea    (%r14,%rax,1),%rsi
add    $0x70,%rsi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x70(%rsi,%rbx,1),%xmm0
movups -0x60(%rsi,%rbx,1),%xmm1
movups %xmm0,(%r14,%rbx,1)
movups %xmm1,0x10(%r14,%rbx,1)
movups -0x50(%rsi,%rbx,1),%xmm0
movups -0x40(%rsi,%rbx,1),%xmm1
movups %xmm0,0x20(%r14,%rbx,1)
movups %xmm1,0x30(%r14,%rbx,1)
movups -0x30(%rsi,%rbx,1),%xmm0
movups -0x20(%rsi,%rbx,1),%xmm1
movups %xmm0,0x40(%r14,%rbx,1)
movups %xmm1,0x50(%r14,%rbx,1)
movdqu -0x10(%rsi,%rbx,1),%xmm0
movdqu (%rsi,%rbx,1),%xmm1
movdqu %xmm0,0x60(%r14,%rbx,1)
movdqu %xmm1,0x70(%r14,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%rdi
jne    15f0 <hex_to_decimal+0x4e0>
test   %rbp,%rbp
je     168e <hex_to_decimal+0x57e>
lea    (%rbx,%r14,1),%rsi
add    $0x10,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rsi,%rax,1),%xmm0
movdqu (%rsi,%rax,1),%xmm1
movdqu %xmm0,-0x10(%rsi)
movdqu %xmm1,(%rsi)
add    $0x20,%rsi
add    $0xffffffffffffffff,%rbp
jne    1670 <hex_to_decimal+0x560>
cmp    %rdx,%r8
je     1593 <hex_to_decimal+0x483>
test   $0x18,%r8b
je     1573 <hex_to_decimal+0x463>
mov    %rdx,%rsi
mov    %r8,%rdx
and    $0xfffffffffffffff8,%rdx
lea    (%r14,%rax,1),%rdi
nop
mov    (%rdi,%rsi,1),%rbp
mov    %rbp,(%r14,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    16b0 <hex_to_decimal+0x5a0>
cmp    %rdx,%r8
je     1593 <hex_to_decimal+0x483>
jmp    1573 <hex_to_decimal+0x463>

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

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