#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 */
size_t FILENAME_MAX;
char *strchr(char const *, char);
int /*<<< orphan*/ strcpy(char *, char const *);
int strlen(char const *);
long strtol(char *, char **, int);
int get_cache_fname(char *path, const char *cache, const char *str) {
  size_t s = FILENAME_MAX;
  size_t ln;
  char *init = path;
  char *p;
  while ((p = strchr(cache, '%'))) {
    ln = p - cache;
    if (ln >= s)
      return -1;
    while (cache < p)
      *path++ = *cache++;
    s -= ln;
    if (*++p == 's') {
      ln = strlen(str);
      if (ln > s)
        return -1;
      strcpy(path, str);
      s -= ln;
      path += ln;
      str += ln;
      p++;
    } else if (*p >= '0' && *p <= '9') {
      char *p1;
      long l = strtol(p, &p1, 10);
      ln = strlen(str);
      if (l > ln)
        l = ln;
      if (*p1 == 's') {
        if (l >= s)
          return -1;
        s -= l;
        while (l--)
          *path++ = *str++;
        p = p1 + 1;
      } else {
        if (s < 3)
          return -1;
        *path++ = '%';
        *path++ = *p++;
      }
    } else {
      if (s < 3)
        return -1;
      *path++ = '%';
      *path++ = *p++;
    }
    cache = p;
  }
  ln = strlen(cache);
  if (ln >= s)
    return -1;
  s -= ln;
  while (ln--)
    *path++ = *cache++;
  bool need_slash = (*str && path > init && path[-1] != '/');
  ln = strlen(str) + need_slash ? 1 : 0;
  if (ln >= s)
    return -1;
  if (need_slash)
    *path++ = '/';
  strcpy(path, str);
  return 0;
}


x86 assembly (clang, -O0):
<get_cache_fname>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    0x2e8d(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rdi
mov    $0x25,%esi
call   1050 <strchr@plt>
mov    %rax,-0x40(%rbp)
cmp    $0x0,%rax
je     1414 <get_cache_fname+0x2d4>
mov    -0x40(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jb     11af <get_cache_fname+0x6f>
movl   $0xffffffff,-0x4(%rbp)
jmp    153b <get_cache_fname+0x3fb>
jmp    11b4 <get_cache_fname+0x74>
mov    -0x18(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    11e9 <get_cache_fname+0xa9>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    11b4 <get_cache_fname+0x74>
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movsbl 0x1(%rax),%eax
cmp    $0x73,%eax
jne    1282 <get_cache_fname+0x142>
mov    -0x20(%rbp),%rdi
call   1040 <strlen@plt>
cltq
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jbe    123d <get_cache_fname+0xfd>
movl   $0xffffffff,-0x4(%rbp)
jmp    153b <get_cache_fname+0x3fb>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x30(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1407 <get_cache_fname+0x2c7>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jl     13b7 <get_cache_fname+0x277>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
jg     13b7 <get_cache_fname+0x277>
mov    -0x40(%rbp),%rdi
lea    -0x48(%rbp),%rsi
mov    $0xa,%edx
call   1060 <strtol@plt>
mov    %rax,-0x50(%rbp)
mov    -0x20(%rbp),%rdi
call   1040 <strlen@plt>
cltq
mov    %rax,-0x30(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x30(%rbp),%rax
jbe    12dd <get_cache_fname+0x19d>
mov    -0x30(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x73,%eax
jne    1367 <get_cache_fname+0x227>
mov    -0x50(%rbp),%rax
cmp    -0x28(%rbp),%rax
jb     1307 <get_cache_fname+0x1c7>
movl   $0xffffffff,-0x4(%rbp)
jmp    153b <get_cache_fname+0x3fb>
mov    -0x50(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x50(%rbp)
cmp    $0x0,%rax
je     1356 <get_cache_fname+0x216>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    1316 <get_cache_fname+0x1d6>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    13b2 <get_cache_fname+0x272>
cmpq   $0x3,-0x28(%rbp)
jae    137e <get_cache_fname+0x23e>
movl   $0xffffffff,-0x4(%rbp)
jmp    153b <get_cache_fname+0x3fb>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x25,(%rax)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    1402 <get_cache_fname+0x2c2>
cmpq   $0x3,-0x28(%rbp)
jae    13ce <get_cache_fname+0x28e>
movl   $0xffffffff,-0x4(%rbp)
jmp    153b <get_cache_fname+0x3fb>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x25,(%rax)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    1407 <get_cache_fname+0x2c7>
mov    -0x40(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    116a <get_cache_fname+0x2a>
mov    -0x18(%rbp),%rdi
call   1040 <strlen@plt>
cltq
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jb     143d <get_cache_fname+0x2fd>
movl   $0xffffffff,-0x4(%rbp)
jmp    153b <get_cache_fname+0x3fb>
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x30(%rbp)
cmp    $0x0,%rax
je     148c <get_cache_fname+0x34c>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    144c <get_cache_fname+0x30c>
mov    -0x20(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x55(%rbp)
je     14c5 <get_cache_fname+0x385>
mov    -0x10(%rbp),%rcx
xor    %eax,%eax
cmp    -0x38(%rbp),%rcx
mov    %al,-0x55(%rbp)
jbe    14c5 <get_cache_fname+0x385>
mov    -0x10(%rbp),%rax
movsbl -0x1(%rax),%eax
cmp    $0x2f,%eax
setne  %al
mov    %al,-0x55(%rbp)
mov    -0x55(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,%edx
add    -0x54(%rbp),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
cltq
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jb     150b <get_cache_fname+0x3cb>
movl   $0xffffffff,-0x4(%rbp)
jmp    153b <get_cache_fname+0x3fb>
cmpl   $0x0,-0x54(%rbp)
je     1527 <get_cache_fname+0x3e7>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x2f,(%rax)
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
call   1030 <strcpy@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_cache_fname>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdx,%r14
mov    %rsi,%rbp
mov    %rdi,%rbx
mov    0x2e8a(%rip),%rax
mov    (%rax),%r13
mov    %rsi,%rdi
mov    $0x25,%esi
call   1050 <strchr@plt>
test   %rax,%rax
mov    %rbx,0x10(%rsp)
je     159a <get_cache_fname+0x45a>
mov    %rax,%r12
nop
mov    %r12,%rcx
sub    %rbp,%rcx
sub    %rcx,%r13
jbe    1604 <get_cache_fname+0x4c4>
cmp    %r12,%rbp
jae    12a0 <get_cache_fname+0x160>
lea    (%rcx,%rbp,1),%r10
cmp    $0x20,%rcx
jb     12b0 <get_cache_fname+0x170>
cmp    %r10,%rbx
jae    11b8 <get_cache_fname+0x78>
lea    (%rbx,%rcx,1),%rdx
cmp    %rdx,%rbp
jb     12b0 <get_cache_fname+0x170>
mov    %rcx,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rdx
mov    %rdx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x60,%rdx
jae    11df <get_cache_fname+0x9f>
xor    %edx,%edx
jmp    1249 <get_cache_fname+0x109>
and    $0xfffffffffffffffc,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movups 0x0(%rbp,%rdx,1),%xmm0
movups 0x10(%rbp,%rdx,1),%xmm1
movups %xmm0,(%rbx,%rdx,1)
movups %xmm1,0x10(%rbx,%rdx,1)
movups 0x20(%rbp,%rdx,1),%xmm0
movups 0x30(%rbp,%rdx,1),%xmm1
movups %xmm0,0x20(%rbx,%rdx,1)
movups %xmm1,0x30(%rbx,%rdx,1)
movups 0x40(%rbp,%rdx,1),%xmm0
movups 0x50(%rbp,%rdx,1),%xmm1
movups %xmm0,0x40(%rbx,%rdx,1)
movups %xmm1,0x50(%rbx,%rdx,1)
movups 0x60(%rbp,%rdx,1),%xmm0
movups 0x70(%rbp,%rdx,1),%xmm1
movups %xmm0,0x60(%rbx,%rdx,1)
movups %xmm1,0x70(%rbx,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rdi
jne    11f0 <get_cache_fname+0xb0>
test   %r9,%r9
je     128b <get_cache_fname+0x14b>
lea    (%rdx,%rbp,1),%rdi
add    $0x10,%rdi
add    %rbx,%rdx
add    $0x10,%rdx
shl    $0x5,%r9
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdi,%rsi,1),%xmm0
movups (%rdi,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r9
jne    1270 <get_cache_fname+0x130>
add    %r8,%rbx
cmp    %r8,%rcx
jne    12ad <get_cache_fname+0x16d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movl   $0xffffffff,0x4(%rsp)
ff
jmp    1334 <get_cache_fname+0x1f4>
add    %r8,%rbp
movl   $0xffffffff,0x4(%rsp)
ff
mov    %r12d,%edx
sub    %ebp,%edx
mov    %rbp,%rcx
not    %rcx
add    %r12,%rcx
and    $0x7,%rdx
je     12e4 <get_cache_fname+0x1a4>
nopl   0x0(%rax)
movzbl 0x0(%rbp),%eax
add    $0x1,%rbp
mov    %al,(%rbx)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rdx
jne    12d0 <get_cache_fname+0x190>
cmp    $0x7,%rcx
jb     1334 <get_cache_fname+0x1f4>
nopw   0x0(%rax,%rax,1)
movzbl 0x0(%rbp),%eax
mov    %al,(%rbx)
movzbl 0x1(%rbp),%eax
mov    %al,0x1(%rbx)
movzbl 0x2(%rbp),%eax
mov    %al,0x2(%rbx)
movzbl 0x3(%rbp),%eax
mov    %al,0x3(%rbx)
movzbl 0x4(%rbp),%eax
mov    %al,0x4(%rbx)
movzbl 0x5(%rbp),%eax
mov    %al,0x5(%rbx)
movzbl 0x6(%rbp),%eax
mov    %al,0x6(%rbx)
movzbl 0x7(%rbp),%eax
mov    %al,0x7(%rbx)
add    $0x8,%rbx
add    $0x8,%rbp
cmp    %r10,%rbp
jne    12f0 <get_cache_fname+0x1b0>
mov    0x1(%r12),%al
cmp    $0x73,%al
jne    1370 <get_cache_fname+0x230>
mov    %r14,%rdi
call   1040 <strlen@plt>
movslq %eax,%rbp
sub    %rbp,%r13
jb     17b4 <get_cache_fname+0x674>
mov    %rbx,%rdi
mov    %r14,%rsi
call   1030 <strcpy@plt>
add    %rbp,%rbx
add    %rbp,%r14
add    $0x2,%r12
jmp    142d <get_cache_fname+0x2ed>
nopl   0x0(%rax,%rax,1)
add    $0xd0,%al
cmp    $0x9,%al
ja     1410 <get_cache_fname+0x2d0>
lea    0x1(%r12),%rdi
lea    0x8(%rsp),%rsi
mov    $0xa,%edx
call   1060 <strtol@plt>
mov    %rax,%r15
mov    %r14,%rdi
call   1040 <strlen@plt>
cltq
cmp    %rax,%r15
cmova  %rax,%r15
mov    0x8(%rsp),%rbp
cmpb   $0x73,0x0(%rbp)
jne    1410 <get_cache_fname+0x2d0>
sub    %r15,%r13
jbe    17b4 <get_cache_fname+0x674>
test   %r15,%r15
je     1591 <get_cache_fname+0x451>
cmp    $0x20,%r15
jb     150e <get_cache_fname+0x3ce>
lea    (%r14,%r15,1),%rax
cmp    %rax,%rbx
jae    13df <get_cache_fname+0x29f>
lea    (%rbx,%r15,1),%rax
cmp    %rax,%r14
jb     150e <get_cache_fname+0x3ce>
mov    %r15,%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    144e <get_cache_fname+0x30e>
xor    %esi,%esi
jmp    14c0 <get_cache_fname+0x380>
nopw   0x0(%rax,%rax,1)
cmp    $0x3,%r13
jb     17b4 <get_cache_fname+0x674>
movb   $0x25,(%rbx)
mov    0x1(%r12),%al
add    $0x2,%r12
mov    %al,0x1(%rbx)
add    $0x2,%rbx
mov    %r12,%rbp
mov    %rbp,%rdi
mov    $0x25,%esi
call   1050 <strchr@plt>
mov    %rax,%r12
test   %rax,%rax
jne    1180 <get_cache_fname+0x40>
jmp    159a <get_cache_fname+0x45a>
and    $0xfffffffffffffffc,%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    1460 <get_cache_fname+0x320>
test   %rcx,%rcx
je     14fb <get_cache_fname+0x3bb>
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    14e0 <get_cache_fname+0x3a0>
add    %rax,%rbx
add    %rax,%r14
cmp    %rax,%r15
je     158c <get_cache_fname+0x44c>
and    $0x1f,%r15d
lea    -0x1(%r15),%rsi
mov    %r15,%rdx
and    $0x7,%rdx
je     153a <get_cache_fname+0x3fa>
xor    %ecx,%ecx
nopl   (%rax)
movzbl (%r14,%rcx,1),%eax
mov    %al,(%rbx,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1520 <get_cache_fname+0x3e0>
sub    %rcx,%r15
add    %rcx,%rbx
add    %rcx,%r14
cmp    $0x7,%rsi
jb     158c <get_cache_fname+0x44c>
movzbl (%r14),%eax
mov    %al,(%rbx)
movzbl 0x1(%r14),%eax
mov    %al,0x1(%rbx)
movzbl 0x2(%r14),%eax
mov    %al,0x2(%rbx)
movzbl 0x3(%r14),%eax
mov    %al,0x3(%rbx)
movzbl 0x4(%r14),%eax
mov    %al,0x4(%rbx)
movzbl 0x5(%r14),%eax
mov    %al,0x5(%rbx)
movzbl 0x6(%r14),%eax
mov    %al,0x6(%rbx)
movzbl 0x7(%r14),%eax
add    $0x8,%r14
mov    %al,0x7(%rbx)
add    $0x8,%rbx
add    $0xfffffffffffffff8,%r15
jne    1540 <get_cache_fname+0x400>
mov    0x8(%rsp),%rbp
add    $0x1,%rbp
jmp    1430 <get_cache_fname+0x2f0>
mov    %rbp,%rdi
call   1040 <strlen@plt>
movslq %eax,%rcx
movl   $0xffffffff,0x4(%rsp)
ff
sub    %rcx,%r13
jbe    17b4 <get_cache_fname+0x674>
test   %eax,%eax
je     1763 <get_cache_fname+0x623>
cmp    $0x20,%eax
jb     16d0 <get_cache_fname+0x590>
lea    (%rcx,%rbp,1),%rdx
cmp    %rdx,%rbx
jae    15dd <get_cache_fname+0x49d>
lea    (%rbx,%rcx,1),%rdx
cmp    %rdx,%rbp
jb     16d0 <get_cache_fname+0x590>
mov    %rcx,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rdx
mov    %rdx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x60,%rdx
jae    1611 <get_cache_fname+0x4d1>
xor    %edx,%edx
jmp    1679 <get_cache_fname+0x539>
movl   $0xffffffff,0x4(%rsp)
ff
jmp    17b4 <get_cache_fname+0x674>
and    $0xfffffffffffffffc,%rdi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rdx,1),%xmm0
movups 0x10(%rbp,%rdx,1),%xmm1
movups %xmm0,(%rbx,%rdx,1)
movups %xmm1,0x10(%rbx,%rdx,1)
movups 0x20(%rbp,%rdx,1),%xmm0
movups 0x30(%rbp,%rdx,1),%xmm1
movups %xmm0,0x20(%rbx,%rdx,1)
movups %xmm1,0x30(%rbx,%rdx,1)
movups 0x40(%rbp,%rdx,1),%xmm0
movups 0x50(%rbp,%rdx,1),%xmm1
movups %xmm0,0x40(%rbx,%rdx,1)
movups %xmm1,0x50(%rbx,%rdx,1)
movups 0x60(%rbp,%rdx,1),%xmm0
movups 0x70(%rbp,%rdx,1),%xmm1
movups %xmm0,0x60(%rbx,%rdx,1)
movups %xmm1,0x70(%rbx,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1620 <get_cache_fname+0x4e0>
test   %r9,%r9
je     16bb <get_cache_fname+0x57b>
lea    (%rdx,%rbp,1),%rdi
add    $0x10,%rdi
add    %rbx,%rdx
add    $0x10,%rdx
shl    $0x5,%r9
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdi,%rsi,1),%xmm0
movups (%rdi,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r9
jne    16a0 <get_cache_fname+0x560>
add    %r8,%rbx
cmp    %rcx,%r8
je     1763 <get_cache_fname+0x623>
and    $0x1f,%eax
add    %r8,%rbp
mov    %rax,%rcx
lea    -0x1(%rcx),%rdi
mov    %rcx,%rsi
and    $0x7,%rsi
je     16fa <get_cache_fname+0x5ba>
xor    %edx,%edx
nop
movzbl 0x0(%rbp,%rdx,1),%eax
mov    %al,(%rbx,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    16e0 <get_cache_fname+0x5a0>
add    %rdx,%rbx
sub    %rdx,%rcx
add    %rdx,%rbp
cmp    $0x7,%rdi
jb     1763 <get_cache_fname+0x623>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x0(%rbp,%rax,1),%edx
mov    %dl,(%rbx,%rax,1)
movzbl 0x1(%rbp,%rax,1),%edx
mov    %dl,0x1(%rbx,%rax,1)
movzbl 0x2(%rbp,%rax,1),%edx
mov    %dl,0x2(%rbx,%rax,1)
movzbl 0x3(%rbp,%rax,1),%edx
mov    %dl,0x3(%rbx,%rax,1)
movzbl 0x4(%rbp,%rax,1),%edx
mov    %dl,0x4(%rbx,%rax,1)
movzbl 0x5(%rbp,%rax,1),%edx
mov    %dl,0x5(%rbx,%rax,1)
movzbl 0x6(%rbp,%rax,1),%edx
mov    %dl,0x6(%rbx,%rax,1)
movzbl 0x7(%rbp,%rax,1),%edx
mov    %dl,0x7(%rbx,%rax,1)
add    $0x8,%rax
cmp    %rax,%rcx
jne    1710 <get_cache_fname+0x5d0>
add    %rax,%rbx
xor    %r15d,%r15d
cmpb   $0x0,(%r14)
je     177b <get_cache_fname+0x63b>
cmp    0x10(%rsp),%rbx
jbe    177b <get_cache_fname+0x63b>
cmpb   $0x2f,-0x1(%rbx)
setne  %r15b
movzbl %r15b,%ebp
neg    %ebp
mov    %r14,%rdi
call   1040 <strlen@plt>
xor    %ecx,%ecx
cmp    %ebp,%eax
setne  %cl
cmp    %rcx,%r13
jbe    17b4 <get_cache_fname+0x674>
test   %r15b,%r15b
je     17a1 <get_cache_fname+0x661>
movb   $0x2f,(%rbx)
add    $0x1,%rbx
mov    %rbx,%rdi
mov    %r14,%rsi
call   1030 <strcpy@plt>
movl   $0x0,0x4(%rsp)
mov    0x4(%rsp),%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@FILENAME_MAX = global i64 0
define i32 @get_cache_fname(i8* %0, i8* %1, i8* %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i64
%9 = alloca i64
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca i8*
%13 = alloca i64
%14 = alloca i32
store i8* %0, i8** %5
store i8* %1, i8** %6
store i8* %2, i8** %7
%15 = load i64, i64* @FILENAME_MAX
store i64 %15, i64* %8
%16 = load i8*, i8** %5
store i8* %16, i8** %10
br label %17
17: ; preds = %148, %3
%18 = load i8*, i8** %6
%19 = call i8* @strchr(i8* %18, i8 signext 37)
store i8* %19, i8** %11
%20 = icmp ne i8* %19, null
br i1 %20, label %21, label %150
21: ; preds = %17
%22 = load i8*, i8** %11
%23 = load i8*, i8** %6
%24 = ptrtoint i8* %22 to i64
%25 = ptrtoint i8* %23 to i64
%26 = sub i64 %24, %25
store i64 %26, i64* %9
%27 = load i64, i64* %9
%28 = load i64, i64* %8
%29 = icmp uge i64 %27, %28
br i1 %29, label %30, label %31
30: ; preds = %21
store i32 -1, i32* %4
br label %212
31: ; preds = %21
br label %32
32: ; preds = %36, %31
%33 = load i8*, i8** %6
%34 = load i8*, i8** %11
%35 = icmp ult i8* %33, %34
br i1 %35, label %36, label %42
36: ; preds = %32
%37 = load i8*, i8** %6
%38 = getelementptr inbounds i8, i8* %37, i32 1
store i8* %38, i8** %6
%39 = load i8, i8* %37
%40 = load i8*, i8** %5
%41 = getelementptr inbounds i8, i8* %40, i32 1
store i8* %41, i8** %5
store i8 %39, i8* %40
br label %32
42: ; preds = %32
%43 = load i64, i64* %9
%44 = load i64, i64* %8
%45 = sub i64 %44, %43
store i64 %45, i64* %8
%46 = load i8*, i8** %11
%47 = getelementptr inbounds i8, i8* %46, i32 1
store i8* %47, i8** %11
%48 = load i8, i8* %47
%49 = sext i8 %48 to i32
%50 = icmp eq i32 %49, 115
br i1 %50, label %51, label %74
51: ; preds = %42
%52 = load i8*, i8** %7
%53 = call i32 @strlen(i8* %52)
%54 = sext i32 %53 to i64
store i64 %54, i64* %9
%55 = load i64, i64* %9
%56 = load i64, i64* %8
%57 = icmp ugt i64 %55, %56
br i1 %57, label %58, label %59
58: ; preds = %51
store i32 -1, i32* %4
br label %212
59: ; preds = %51
%60 = load i8*, i8** %5
%61 = load i8*, i8** %7
%62 = call i32 @strcpy(i8* %60, i8* %61)
%63 = load i64, i64* %9
%64 = load i64, i64* %8
%65 = sub i64 %64, %63
store i64 %65, i64* %8
%66 = load i64, i64* %9
%67 = load i8*, i8** %5
%68 = getelementptr inbounds i8, i8* %67, i64 %66
store i8* %68, i8** %5
%69 = load i64, i64* %9
%70 = load i8*, i8** %7
%71 = getelementptr inbounds i8, i8* %70, i64 %69
store i8* %71, i8** %7
%72 = load i8*, i8** %11
%73 = getelementptr inbounds i8, i8* %72, i32 1
store i8* %73, i8** %11
br label %148
74: ; preds = %42
%75 = load i8*, i8** %11
%76 = load i8, i8* %75
%77 = sext i8 %76 to i32
%78 = icmp sge i32 %77, 48
br i1 %78, label %79, label %135
79: ; preds = %74
%80 = load i8*, i8** %11
%81 = load i8, i8* %80
%82 = sext i8 %81 to i32
%83 = icmp sle i32 %82, 57
br i1 %83, label %84, label %135
84: ; preds = %79
%85 = load i8*, i8** %11
%86 = call i64 @strtol(i8* %85, i8** %12, i32 10)
store i64 %86, i64* %13
%87 = load i8*, i8** %7
%88 = call i32 @strlen(i8* %87)
%89 = sext i32 %88 to i64
store i64 %89, i64* %9
%90 = load i64, i64* %13
%91 = load i64, i64* %9
%92 = icmp ugt i64 %90, %91
br i1 %92, label %93, label %95
93: ; preds = %84
%94 = load i64, i64* %9
store i64 %94, i64* %13
br label %95
95: ; preds = %93, %84
%96 = load i8*, i8** %12
%97 = load i8, i8* %96
%98 = sext i8 %97 to i32
%99 = icmp eq i32 %98, 115
br i1 %99, label %100, label %122
100: ; preds = %95
%101 = load i64, i64* %13
%102 = load i64, i64* %8
%103 = icmp uge i64 %101, %102
br i1 %103, label %104, label %105
104: ; preds = %100
store i32 -1, i32* %4
br label %212
105: ; preds = %100
%106 = load i64, i64* %13
%107 = load i64, i64* %8
%108 = sub i64 %107, %106
store i64 %108, i64* %8
br label %109
109: ; preds = %113, %105
%110 = load i64, i64* %13
%111 = add nsw i64 %110, -1
store i64 %111, i64* %13
%112 = icmp ne i64 %110, 0
br i1 %112, label %113, label %119
113: ; preds = %109
%114 = load i8*, i8** %7
%115 = getelementptr inbounds i8, i8* %114, i32 1
store i8* %115, i8** %7
%116 = load i8, i8* %114
%117 = load i8*, i8** %5
%118 = getelementptr inbounds i8, i8* %117, i32 1
store i8* %118, i8** %5
store i8 %116, i8* %117
br label %109
119: ; preds = %109
%120 = load i8*, i8** %12
%121 = getelementptr inbounds i8, i8* %120, i64 1
store i8* %121, i8** %11
br label %134
122: ; preds = %95
%123 = load i64, i64* %8
%124 = icmp ult i64 %123, 3
br i1 %124, label %125, label %126
125: ; preds = %122
store i32 -1, i32* %4
br label %212
126: ; preds = %122
%127 = load i8*, i8** %5
%128 = getelementptr inbounds i8, i8* %127, i32 1
store i8* %128, i8** %5
store i8 37, i8* %127
%129 = load i8*, i8** %11
%130 = getelementptr inbounds i8, i8* %129, i32 1
store i8* %130, i8** %11
%131 = load i8, i8* %129
%132 = load i8*, i8** %5
%133 = getelementptr inbounds i8, i8* %132, i32 1
store i8* %133, i8** %5
store i8 %131, i8* %132
br label %134
134: ; preds = %126, %119
br label %147
135: ; preds = %79, %74
%136 = load i64, i64* %8
%137 = icmp ult i64 %136, 3
br i1 %137, label %138, label %139
138: ; preds = %135
store i32 -1, i32* %4
br label %212
139: ; preds = %135
%140 = load i8*, i8** %5
%141 = getelementptr inbounds i8, i8* %140, i32 1
store i8* %141, i8** %5
store i8 37, i8* %140
%142 = load i8*, i8** %11
%143 = getelementptr inbounds i8, i8* %142, i32 1
store i8* %143, i8** %11
%144 = load i8, i8* %142
%145 = load i8*, i8** %5
%146 = getelementptr inbounds i8, i8* %145, i32 1
store i8* %146, i8** %5
store i8 %144, i8* %145
br label %147
147: ; preds = %139, %134
br label %148
148: ; preds = %147, %59
%149 = load i8*, i8** %11
store i8* %149, i8** %6
br label %17
150: ; preds = %17
%151 = load i8*, i8** %6
%152 = call i32 @strlen(i8* %151)
%153 = sext i32 %152 to i64
store i64 %153, i64* %9
%154 = load i64, i64* %9
%155 = load i64, i64* %8
%156 = icmp uge i64 %154, %155
br i1 %156, label %157, label %158
157: ; preds = %150
store i32 -1, i32* %4
br label %212
158: ; preds = %150
%159 = load i64, i64* %9
%160 = load i64, i64* %8
%161 = sub i64 %160, %159
store i64 %161, i64* %8
br label %162
162: ; preds = %166, %158
%163 = load i64, i64* %9
%164 = add i64 %163, -1
store i64 %164, i64* %9
%165 = icmp ne i64 %163, 0
br i1 %165, label %166, label %172
166: ; preds = %162
%167 = load i8*, i8** %6
%168 = getelementptr inbounds i8, i8* %167, i32 1
store i8* %168, i8** %6
%169 = load i8, i8* %167
%170 = load i8*, i8** %5
%171 = getelementptr inbounds i8, i8* %170, i32 1
store i8* %171, i8** %5
store i8 %169, i8* %170
br label %162
172: ; preds = %162
%173 = load i8*, i8** %7
%174 = load i8, i8* %173
%175 = sext i8 %174 to i32
%176 = icmp ne i32 %175, 0
br i1 %176, label %177, label %187
177: ; preds = %172
%178 = load i8*, i8** %5
%179 = load i8*, i8** %10
%180 = icmp ugt i8* %178, %179
br i1 %180, label %181, label %187
181: ; preds = %177
%182 = load i8*, i8** %5
%183 = getelementptr inbounds i8, i8* %182, i64 -1
%184 = load i8, i8* %183
%185 = sext i8 %184 to i32
%186 = icmp ne i32 %185, 47
br label %187
187: ; preds = %181, %177, %172
%188 = phi i1 [ false, %177 ], [ false, %172 ], [ %186, %181 ]
%189 = zext i1 %188 to i32
store i32 %189, i32* %14
%190 = load i8*, i8** %7
%191 = call i32 @strlen(i8* %190)
%192 = load i32, i32* %14
%193 = add nsw i32 %191, %192
%194 = icmp ne i32 %193, 0
%195 = zext i1 %194 to i64
%196 = select i1 %194, i32 1, i32 0
%197 = sext i32 %196 to i64
store i64 %197, i64* %9
%198 = load i64, i64* %9
%199 = load i64, i64* %8
%200 = icmp uge i64 %198, %199
br i1 %200, label %201, label %202
201: ; preds = %187
store i32 -1, i32* %4
br label %212
202: ; preds = %187
%203 = load i32, i32* %14
%204 = icmp ne i32 %203, 0
br i1 %204, label %205, label %208
205: ; preds = %202
%206 = load i8*, i8** %5
%207 = getelementptr inbounds i8, i8* %206, i32 1
store i8* %207, i8** %5
store i8 47, i8* %206
br label %208
208: ; preds = %205, %202
%209 = load i8*, i8** %5
%210 = load i8*, i8** %7
%211 = call i32 @strcpy(i8* %209, i8* %210)
store i32 0, i32* %4
br label %212
212: ; preds = %208, %201, %157, %138, %125, %104, %58, %30
%213 = load i32, i32* %4
ret i32 %213
}

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