#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 */
typedef struct TYPE_3__ TYPE_1__;

/* Type definitions */
struct TYPE_3__ {
  int rm_so;
  int rm_eo;
};
typedef TYPE_1__ regmatch_t;

/* Variables and functions */
int /*<<< orphan*/ assert(int /*<<< orphan*/);
int strlen(char const *);
scalar_t__ tolower(char const);
scalar_t__ toupper(char const);
size_t router_rewrite_metric(char (*newmetric)[8192], char **newfirstspace,
                             const char *metric, const char *firstspace,
                             const char *replacement, const size_t nmatch,
                             const regmatch_t *pmatch) {
  char escape = 0;
  int ref = 0;
  char *s = *newmetric;
  const char *p;
  const char *q;
  const char *t;
  enum rewrite_case {
    RETAIN,
    LOWER,
    UPPER,
    RETAIN_DOT,
    LOWER_DOT,
    UPPER_DOT
  } rcase = RETAIN;
  assert(pmatch != NULL);
  q = metric;
  t = metric + pmatch[0].rm_so;
  if (s - *newmetric + t - q < sizeof(*newmetric)) {
    while (q < t)
      *s++ = *q++;
  } else {
    return 0;
  }
  for (p = replacement;; p++) {
    switch (*p) {
    case '\\':
      if (!escape) {
        escape = 1;
        rcase = RETAIN;
        break;
      }
    default:
      if (escape == 1 && rcase == RETAIN && *p == '_') {
        rcase = LOWER;
      } else if (escape == 1 && rcase == RETAIN && *p == '^') {
        rcase = UPPER;
      } else if (escape == 1 && *p == '.') {
        if (rcase == LOWER) {
          rcase = LOWER_DOT;
        } else if (rcase == UPPER) {
          rcase = UPPER_DOT;
        } else {
          rcase = RETAIN_DOT;
        }
      } else if (escape && *p >= '0' && *p <= '9') {
        escape = 2;
        ref *= 10;
        ref += *p - '0';
      } else {
        if (escape) {
          if (ref > 0 && ref <= nmatch && pmatch[ref].rm_so >= 0) {
            q = metric + pmatch[ref].rm_so;
            t = metric + pmatch[ref].rm_eo;
            if (s - *newmetric + t - q < sizeof(*newmetric)) {
              switch (rcase) {
              case RETAIN:
                while (q < t)
                  *s++ = *q++;
                break;
              case LOWER:
                while (q < t)
                  *s++ = (char)tolower(*q++);
                break;
              case UPPER:
                while (q < t)
                  *s++ = (char)toupper(*q++);
                break;
              case RETAIN_DOT:
                while (q < t) {
                  if (*q == '.')
                    *s++ = '_';
                  else
                    *s++ = *q;
                  q++;
                }
                break;
              case LOWER_DOT:
                while (q < t) {
                  if (*q == '.')
                    *s++ = '_';
                  else
                    *s++ = (char)tolower(*q);
                  q++;
                }
                break;
              case UPPER_DOT:
                while (q < t) {
                  if (*q == '.')
                    *s++ = '_';
                  else
                    *s++ = (char)toupper(*q);
                  q++;
                }
                break;
              }
            }
          }
          ref = 0;
        }
        if (*p != '\\') {
          escape = 0;
          rcase = RETAIN;
          if (s - *newmetric + 1 < sizeof(*newmetric))
            *s++ = *p;
        }
      }
      break;
    }
    if (*p == '\0')
      break;
  }
  s--;
  q = metric + pmatch[0].rm_eo;
  t = firstspace;
  if (s - *newmetric + t - q < sizeof(*newmetric)) {
    while (q < t)
      *s++ = *q++;
  } else {
    return 0;
  }
  *newfirstspace = s;
  if (s - *newmetric + strlen(firstspace) < sizeof(*newmetric)) {
    for (p = firstspace; *p != '\0'; p++)
      *s++ = *p;
    *s++ = '\0';
    return s - *newmetric;
  }
  return 0;
}


x86 assembly (clang, -O0):
<router_rewrite_metric>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movb   $0x0,-0x39(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x64(%rbp)
cmpq   $0x0,0x10(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x20(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq (%rcx),%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
add    -0x60(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x2000,%rax
jae    120e <router_rewrite_metric+0xce>
jmp    11d4 <router_rewrite_metric+0x94>
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    1209 <router_rewrite_metric+0xc9>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x58(%rbp)
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
jmp    11d4 <router_rewrite_metric+0x94>
jmp    121b <router_rewrite_metric+0xdb>
movq   $0x0,-0x8(%rbp)
jmp    1803 <router_rewrite_metric+0x6c3>
mov    -0x30(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%al
sub    $0x5c,%al
jne    1255 <router_rewrite_metric+0x115>
jmp    1236 <router_rewrite_metric+0xf6>
cmpb   $0x0,-0x39(%rbp)
jne    1250 <router_rewrite_metric+0x110>
movb   $0x1,-0x39(%rbp)
movl   $0x0,-0x64(%rbp)
jmp    169a <router_rewrite_metric+0x55a>
jmp    1255 <router_rewrite_metric+0x115>
movsbl -0x39(%rbp),%eax
cmp    $0x1,%eax
jne    1288 <router_rewrite_metric+0x148>
cmpl   $0x0,-0x64(%rbp)
jne    1288 <router_rewrite_metric+0x148>
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5f,%eax
jne    1288 <router_rewrite_metric+0x148>
movl   $0x1,-0x64(%rbp)
jmp    1695 <router_rewrite_metric+0x555>
movsbl -0x39(%rbp),%eax
cmp    $0x1,%eax
jne    12bb <router_rewrite_metric+0x17b>
cmpl   $0x0,-0x64(%rbp)
jne    12bb <router_rewrite_metric+0x17b>
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5e,%eax
jne    12bb <router_rewrite_metric+0x17b>
movl   $0x2,-0x64(%rbp)
jmp    1690 <router_rewrite_metric+0x550>
movsbl -0x39(%rbp),%eax
cmp    $0x1,%eax
jne    1315 <router_rewrite_metric+0x1d5>
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    1315 <router_rewrite_metric+0x1d5>
cmpl   $0x1,-0x64(%rbp)
jne    12ee <router_rewrite_metric+0x1ae>
movl   $0x4,-0x64(%rbp)
jmp    1310 <router_rewrite_metric+0x1d0>
cmpl   $0x2,-0x64(%rbp)
jne    1304 <router_rewrite_metric+0x1c4>
movl   $0x5,-0x64(%rbp)
jmp    130b <router_rewrite_metric+0x1cb>
movl   $0x3,-0x64(%rbp)
jmp    1310 <router_rewrite_metric+0x1d0>
jmp    168b <router_rewrite_metric+0x54b>
movsbl -0x39(%rbp),%eax
cmp    $0x0,%eax
je     1362 <router_rewrite_metric+0x222>
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jl     1362 <router_rewrite_metric+0x222>
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
jg     1362 <router_rewrite_metric+0x222>
movb   $0x2,-0x39(%rbp)
imul   $0xa,-0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    1686 <router_rewrite_metric+0x546>
cmpb   $0x0,-0x39(%rbp)
je     162f <router_rewrite_metric+0x4ef>
cmpl   $0x0,-0x40(%rbp)
jle    1628 <router_rewrite_metric+0x4e8>
movslq -0x40(%rbp),%rax
cmp    -0x38(%rbp),%rax
ja     1628 <router_rewrite_metric+0x4e8>
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,8)
jl     1628 <router_rewrite_metric+0x4e8>
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq -0x40(%rbp),%rdx
movslq (%rcx,%rdx,8),%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq -0x40(%rbp),%rdx
movslq 0x4(%rcx,%rdx,8),%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
add    -0x60(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x2000,%rax
jae    1623 <router_rewrite_metric+0x4e3>
mov    -0x64(%rbp),%eax
mov    %rax,-0x70(%rbp)
sub    $0x5,%rax
ja     161e <router_rewrite_metric+0x4de>
mov    -0x70(%rbp),%rax
lea    0xbfd(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    1411 <router_rewrite_metric+0x2d1>
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    1446 <router_rewrite_metric+0x306>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x58(%rbp)
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
jmp    1411 <router_rewrite_metric+0x2d1>
jmp    161e <router_rewrite_metric+0x4de>
jmp    1450 <router_rewrite_metric+0x310>
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    148d <router_rewrite_metric+0x34d>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x58(%rbp)
movsbl (%rax),%edi
call   1060 <tolower@plt>
mov    %al,%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
jmp    1450 <router_rewrite_metric+0x310>
jmp    161e <router_rewrite_metric+0x4de>
jmp    1497 <router_rewrite_metric+0x357>
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    14d4 <router_rewrite_metric+0x394>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x58(%rbp)
movsbl (%rax),%edi
call   1030 <toupper@plt>
mov    %al,%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
jmp    1497 <router_rewrite_metric+0x357>
jmp    161e <router_rewrite_metric+0x4de>
jmp    14de <router_rewrite_metric+0x39e>
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    153b <router_rewrite_metric+0x3fb>
mov    -0x58(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    1513 <router_rewrite_metric+0x3d3>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x48(%rbp)
movb   $0x5f,(%rax)
jmp    152a <router_rewrite_metric+0x3ea>
mov    -0x58(%rbp),%rax
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    14de <router_rewrite_metric+0x39e>
jmp    161e <router_rewrite_metric+0x4de>
jmp    1545 <router_rewrite_metric+0x405>
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    15aa <router_rewrite_metric+0x46a>
mov    -0x58(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    157a <router_rewrite_metric+0x43a>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x48(%rbp)
movb   $0x5f,(%rax)
jmp    1599 <router_rewrite_metric+0x459>
mov    -0x58(%rbp),%rax
movsbl (%rax),%edi
call   1060 <tolower@plt>
mov    %al,%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1545 <router_rewrite_metric+0x405>
jmp    161e <router_rewrite_metric+0x4de>
jmp    15b4 <router_rewrite_metric+0x474>
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    1619 <router_rewrite_metric+0x4d9>
mov    -0x58(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    15e9 <router_rewrite_metric+0x4a9>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x48(%rbp)
movb   $0x5f,(%rax)
jmp    1608 <router_rewrite_metric+0x4c8>
mov    -0x58(%rbp),%rax
movsbl (%rax),%edi
call   1030 <toupper@plt>
mov    %al,%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    15b4 <router_rewrite_metric+0x474>
jmp    161e <router_rewrite_metric+0x4de>
jmp    1623 <router_rewrite_metric+0x4e3>
jmp    1628 <router_rewrite_metric+0x4e8>
movl   $0x0,-0x40(%rbp)
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5c,%eax
je     1681 <router_rewrite_metric+0x541>
movb   $0x0,-0x39(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
add    $0x1,%rax
cmp    $0x2000,%rax
jae    167c <router_rewrite_metric+0x53c>
mov    -0x50(%rbp),%rax
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
jmp    1681 <router_rewrite_metric+0x541>
jmp    1686 <router_rewrite_metric+0x546>
jmp    168b <router_rewrite_metric+0x54b>
jmp    1690 <router_rewrite_metric+0x550>
jmp    1695 <router_rewrite_metric+0x555>
jmp    169a <router_rewrite_metric+0x55a>
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    16af <router_rewrite_metric+0x56f>
jmp    16c5 <router_rewrite_metric+0x585>
jmp    16b4 <router_rewrite_metric+0x574>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1223 <router_rewrite_metric+0xe3>
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq 0x4(%rcx),%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
add    -0x60(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x2000,%rax
jae    174d <router_rewrite_metric+0x60d>
jmp    1713 <router_rewrite_metric+0x5d3>
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    1748 <router_rewrite_metric+0x608>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x58(%rbp)
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
jmp    1713 <router_rewrite_metric+0x5d3>
jmp    175a <router_rewrite_metric+0x61a>
movq   $0x0,-0x8(%rbp)
jmp    1803 <router_rewrite_metric+0x6c3>
mov    -0x48(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x28(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,%ecx
mov    -0x78(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
cmp    $0x2000,%rax
jae    17fb <router_rewrite_metric+0x6bb>
mov    -0x28(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     17d5 <router_rewrite_metric+0x695>
mov    -0x50(%rbp),%rax
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    179d <router_rewrite_metric+0x65d>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x48(%rbp)
movb   $0x0,(%rax)
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    1803 <router_rewrite_metric+0x6c3>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<router_rewrite_metric>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9,0x18(%rsp)
mov    %r8,%rbp
mov    %rcx,0x28(%rsp)
mov    %rdx,%r13
mov    %rsi,%r14
mov    %rdi,%r15
mov    0xa0(%rsp),%rbx
xor    %edi,%edi
test   %rbx,%rbx
setne  %dil
call   1050 <assert@plt>
movslq (%rbx),%rax
cmp    $0x1fff,%rax
ja     1adf <router_rewrite_metric+0x99f>
mov    %rbx,%r11
mov    %r14,0x20(%rsp)
test   %eax,%eax
je     1207 <router_rewrite_metric+0xc7>
add    %r13,%rax
lea    0x1(%r13),%rsi
cmp    %rsi,%rax
mov    %rsi,%r8
cmova  %rax,%r8
sub    %r13,%r8
mov    %r13,%rcx
mov    %r15,%r14
cmp    $0x20,%r8
mov    0x18(%rsp),%r10
jb     12e0 <router_rewrite_metric+0x1a0>
cmp    %rsi,%rax
cmova  %rax,%rsi
cmp    %rsi,%r15
jae    11df <router_rewrite_metric+0x9f>
sub    %r13,%rsi
add    %r15,%rsi
mov    %r13,%rcx
mov    %r15,%r14
cmp    %r13,%rsi
ja     12e0 <router_rewrite_metric+0x1a0>
mov    %r8,%rcx
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rdx
mov    %rdx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x60,%rdx
jae    1214 <router_rewrite_metric+0xd4>
xor    %ebx,%ebx
jmp    128d <router_rewrite_metric+0x14d>
mov    %r15,%r14
mov    0x18(%rsp),%r10
jmp    12f3 <router_rewrite_metric+0x1b3>
and    $0xfffffffffffffffc,%rdi
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups 0x0(%r13,%rbx,1),%xmm0
movups 0x10(%r13,%rbx,1),%xmm1
movups %xmm0,(%r15,%rbx,1)
movups %xmm1,0x10(%r15,%rbx,1)
movups 0x20(%r13,%rbx,1),%xmm0
movups 0x30(%r13,%rbx,1),%xmm1
movups %xmm0,0x20(%r15,%rbx,1)
movups %xmm1,0x30(%r15,%rbx,1)
movups 0x40(%r13,%rbx,1),%xmm0
movups 0x50(%r13,%rbx,1),%xmm1
movups %xmm0,0x40(%r15,%rbx,1)
movups %xmm1,0x50(%r15,%rbx,1)
movdqu 0x60(%r13,%rbx,1),%xmm0
movdqu 0x70(%r13,%rbx,1),%xmm1
movdqu %xmm0,0x60(%r15,%rbx,1)
movdqu %xmm1,0x70(%r15,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%rdi
jne    1220 <router_rewrite_metric+0xe0>
test   %rsi,%rsi
je     12cf <router_rewrite_metric+0x18f>
lea    (%r15,%rbx,1),%rdi
add    $0x10,%rdi
add    %r13,%rbx
add    $0x10,%rbx
shl    $0x5,%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rbx,%rdx,1),%xmm0
movdqu (%rbx,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rdi,%rdx,1)
movdqu %xmm1,(%rdi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    12b0 <router_rewrite_metric+0x170>
lea    (%r15,%rcx,1),%r14
cmp    %rcx,%r8
je     12f3 <router_rewrite_metric+0x1b3>
add    %r13,%rcx
nopl   0x0(%rax,%rax,1)
movzbl (%rcx),%edx
add    $0x1,%rcx
mov    %dl,(%r14)
add    $0x1,%r14
cmp    %rax,%rcx
jb     12e0 <router_rewrite_metric+0x1a0>
mov    $0x1,%edi
mov    %r15,0x40(%rsp)
sub    %r15,%rdi
mov    %r13,%rax
neg    %rax
mov    %rax,0x30(%rsp)
lea    0x1(%r13),%rax
mov    %rax,0x38(%rsp)
xor    %r12d,%r12d
lea    0x30(%r13),%rax
mov    %rax,0x60(%rsp)
lea    0x70(%r13),%rax
mov    %rax,0x48(%rsp)
lea    0x10(%r13),%rax
mov    %rax,0x58(%rsp)
movdqa 0xcc6(%rip),%xmm5
movdqa 0xcce(%rip),%xmm6
movabs $0xffffffffffffffc,%rax
ff ff 0f
or     $0x2,%rax
mov    %rax,0x50(%rsp)
xor    %esi,%esi
xor    %r15d,%r15d
mov    %rdi,0x10(%rsp)
mov    %r13,0x8(%rsp)
jmp    137a <router_rewrite_metric+0x23a>
cs nopw 0x0(%rax,%rax,1)
xor    %r15d,%r15d
add    $0x1,%rbp
mov    %ecx,%r12d
movzbl 0x0(%rbp),%edx
mov    $0x1,%cl
cmp    $0x5c,%edx
jne    138a <router_rewrite_metric+0x24a>
test   %r12b,%r12b
je     1370 <router_rewrite_metric+0x230>
cmp    $0x1,%r12b
sete   %al
test   %r15d,%r15d
sete   %bl
and    %al,%bl
cmp    $0x1,%bl
jne    13b0 <router_rewrite_metric+0x270>
cmp    $0x5f,%dl
jne    13b0 <router_rewrite_metric+0x270>
mov    $0x1,%r15d
jmp    1373 <router_rewrite_metric+0x233>
nopl   0x0(%rax,%rax,1)
test   %bl,%bl
je     13c6 <router_rewrite_metric+0x286>
cmp    $0x2e,%dl
je     1429 <router_rewrite_metric+0x2e9>
cmp    $0x5e,%dl
jne    13e9 <router_rewrite_metric+0x2a9>
mov    $0x2,%r15d
jmp    1373 <router_rewrite_metric+0x233>
cmp    $0x1,%r12b
jne    13f2 <router_rewrite_metric+0x2b2>
cmp    $0x2e,%dl
jne    13e9 <router_rewrite_metric+0x2a9>
cmp    $0x1,%r15d
je     152e <router_rewrite_metric+0x3ee>
cmp    $0x2,%r15d
jne    1429 <router_rewrite_metric+0x2e9>
mov    $0x5,%r15d
jmp    1373 <router_rewrite_metric+0x233>
lea    -0x30(%rdx),%eax
cmp    $0x9,%al
jbe    13fe <router_rewrite_metric+0x2be>
jmp    140e <router_rewrite_metric+0x2ce>
test   %r12b,%r12b
je     140e <router_rewrite_metric+0x2ce>
lea    -0x30(%rdx),%eax
cmp    $0xa,%al
jae    140e <router_rewrite_metric+0x2ce>
lea    (%rsi,%rsi,4),%eax
lea    (%rdx,%rax,2),%esi
add    $0xffffffd0,%esi
mov    $0x2,%cl
jmp    1373 <router_rewrite_metric+0x233>
test   %r12b,%r12b
je     1419 <router_rewrite_metric+0x2d9>
test   %esi,%esi
jg     145c <router_rewrite_metric+0x31c>
xor    %esi,%esi
mov    0x0(%rbp),%cl
cmp    $0x5c,%cl
jne    1434 <router_rewrite_metric+0x2f4>
mov    %r12d,%ecx
jmp    1373 <router_rewrite_metric+0x233>
mov    $0x3,%r15d
jmp    1373 <router_rewrite_metric+0x233>
lea    (%rdi,%r14,1),%rax
cmp    $0x1fff,%rax
ja     144a <router_rewrite_metric+0x30a>
mov    %cl,(%r14)
add    $0x1,%r14
mov    0x0(%rbp),%cl
xor    %r15d,%r15d
test   %cl,%cl
je     1904 <router_rewrite_metric+0x7c4>
xor    %ecx,%ecx
jmp    1373 <router_rewrite_metric+0x233>
mov    %esi,%ecx
cmp    %r10,%rcx
ja     1417 <router_rewrite_metric+0x2d7>
mov    (%r11,%rcx,8),%eax
test   %eax,%eax
js     1417 <router_rewrite_metric+0x2d7>
lea    (%rax,%r13,1),%rbx
movslq 0x4(%r11,%rcx,8),%rcx
add    %rcx,%r13
mov    %r14,%rdx
sub    0x40(%rsp),%rdx
add    %r13,%rdx
sub    %rbx,%rdx
cmp    $0x1fff,%rdx
ja     18f8 <router_rewrite_metric+0x7b8>
cmp    $0x5,%r15d
ja     18f8 <router_rewrite_metric+0x7b8>
mov    %r15d,%edx
lea    0xb7a(%rip),%rsi
movslq (%rsi,%rdx,4),%rdx
add    %rsi,%rdx
jmp    *%rdx
cmp    %rcx,%rax
jge    18f8 <router_rewrite_metric+0x7b8>
mov    0x38(%rsp),%rcx
add    %rax,%rcx
cmp    %r13,%rcx
mov    %r13,%r9
cmova  %rcx,%r9
mov    0x8(%rsp),%rdx
add    %rax,%rdx
sub    %rdx,%r9
cmp    $0x20,%r9
jb     1850 <router_rewrite_metric+0x710>
cmp    %r13,%rcx
cmovbe %r13,%rcx
cmp    %rcx,%r14
jae    1502 <router_rewrite_metric+0x3c2>
mov    0x30(%rsp),%rdx
add    %r14,%rdx
sub    %rax,%rcx
add    %rdx,%rcx
cmp    %rcx,%rbx
jb     1850 <router_rewrite_metric+0x710>
mov    %r9,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x60,%rcx
jae    178a <router_rewrite_metric+0x64a>
xor    %edx,%edx
jmp    1804 <router_rewrite_metric+0x6c4>
mov    $0x4,%r15d
jmp    1373 <router_rewrite_metric+0x233>
cmp    %rcx,%rax
jge    1578 <router_rewrite_metric+0x438>
xchg   %ax,%ax
movsbl (%rbx),%edi
add    $0x1,%rbx
call   1060 <tolower@plt>
mov    %al,(%r14)
add    $0x1,%r14
cmp    %r13,%rbx
jb     1540 <router_rewrite_metric+0x400>
jmp    1578 <router_rewrite_metric+0x438>
cmp    %rcx,%rax
jge    1578 <router_rewrite_metric+0x438>
nop
movsbl (%rbx),%edi
add    $0x1,%rbx
call   1030 <toupper@plt>
mov    %al,(%r14)
add    $0x1,%r14
cmp    %r13,%rbx
jb     1560 <router_rewrite_metric+0x420>
xor    %esi,%esi
mov    0x8(%rsp),%r13
mov    0x18(%rsp),%r10
mov    0xa0(%rsp),%r11
mov    0x10(%rsp),%rdi
movdqa 0xa67(%rip),%xmm5
movdqa 0xa6f(%rip),%xmm6
jmp    1419 <router_rewrite_metric+0x2d9>
cmp    %rcx,%rax
jge    18f8 <router_rewrite_metric+0x7b8>
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,1),%rdx
cmp    %r13,%rdx
mov    %r13,%rcx
cmova  %rdx,%rcx
mov    0x8(%rsp),%rsi
add    %rax,%rsi
sub    %rsi,%rcx
cmp    $0x20,%rcx
jb     18d8 <router_rewrite_metric+0x798>
cmp    %r13,%rdx
cmovbe %r13,%rdx
cmp    %rdx,%r14
jae    15fa <router_rewrite_metric+0x4ba>
mov    0x30(%rsp),%rsi
add    %r14,%rsi
sub    %rax,%rdx
add    %rsi,%rdx
cmp    %rdx,%rbx
jb     18d8 <router_rewrite_metric+0x798>
mov    %rcx,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rsi
mov    %rsi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1868 <router_rewrite_metric+0x728>
mov    %rdx,%rdi
and    0x50(%rsp),%rdi
add    0x60(%rsp),%rax
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rax,%rsi,1),%xmm0
movdqu -0x20(%rax,%rsi,1),%xmm1
movdqa %xmm0,%xmm2
pcmpeqb %xmm5,%xmm2
movdqa %xmm1,%xmm3
pcmpeqb %xmm5,%xmm3
movdqa %xmm2,%xmm4
pandn  %xmm0,%xmm4
pand   %xmm6,%xmm2
por    %xmm4,%xmm2
movdqa %xmm3,%xmm0
pandn  %xmm1,%xmm0
pand   %xmm6,%xmm3
por    %xmm0,%xmm3
movdqu %xmm2,(%r14,%rsi,1)
movdqu %xmm3,0x10(%r14,%rsi,1)
movdqu -0x10(%rax,%rsi,1),%xmm0
movdqu (%rax,%rsi,1),%xmm1
movdqa %xmm0,%xmm2
pcmpeqb %xmm5,%xmm2
movdqa %xmm1,%xmm3
pcmpeqb %xmm5,%xmm3
movdqa %xmm2,%xmm4
pandn  %xmm0,%xmm4
pand   %xmm6,%xmm2
por    %xmm4,%xmm2
movdqa %xmm3,%xmm0
pandn  %xmm1,%xmm0
pand   %xmm6,%xmm3
por    %xmm0,%xmm3
movdqu %xmm2,0x20(%r14,%rsi,1)
movdqu %xmm3,0x30(%r14,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1630 <router_rewrite_metric+0x4f0>
jmp    186a <router_rewrite_metric+0x72a>
cmp    %rcx,%rax
jl     16f4 <router_rewrite_metric+0x5b4>
jmp    18f8 <router_rewrite_metric+0x7b8>
nop
mov    %al,(%r14)
add    $0x1,%r14
add    $0x1,%rbx
cmp    %r13,%rbx
jae    18f8 <router_rewrite_metric+0x7b8>
movzbl (%rbx),%ecx
mov    $0x5f,%al
cmp    $0x2e,%cl
je     16e0 <router_rewrite_metric+0x5a0>
movsbl %cl,%edi
call   1060 <tolower@plt>
movdqa 0x902(%rip),%xmm6
movdqa 0x8ea(%rip),%xmm5
mov    0x10(%rsp),%rdi
mov    0xa0(%rsp),%r11
mov    0x18(%rsp),%r10
jmp    16e0 <router_rewrite_metric+0x5a0>
cmp    %rcx,%rax
jl     1754 <router_rewrite_metric+0x614>
jmp    18f8 <router_rewrite_metric+0x7b8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %al,(%r14)
add    $0x1,%r14
add    $0x1,%rbx
cmp    %r13,%rbx
jae    18f8 <router_rewrite_metric+0x7b8>
movzbl (%rbx),%ecx
mov    $0x5f,%al
cmp    $0x2e,%cl
je     1740 <router_rewrite_metric+0x600>
movsbl %cl,%edi
call   1030 <toupper@plt>
movdqa 0x8a2(%rip),%xmm6
movdqa 0x88a(%rip),%xmm5
mov    0x10(%rsp),%rdi
mov    0xa0(%rsp),%r11
mov    0x18(%rsp),%r10
jmp    1740 <router_rewrite_metric+0x600>
and    $0xfffffffffffffffc,%rdi
mov    0x48(%rsp),%rcx
add    %rax,%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups -0x70(%rcx,%rdx,1),%xmm0
movups -0x60(%rcx,%rdx,1),%xmm1
movups %xmm0,(%r14,%rdx,1)
movups %xmm1,0x10(%r14,%rdx,1)
movups -0x50(%rcx,%rdx,1),%xmm0
movups -0x40(%rcx,%rdx,1),%xmm1
movups %xmm0,0x20(%r14,%rdx,1)
movups %xmm1,0x30(%r14,%rdx,1)
movups -0x30(%rcx,%rdx,1),%xmm0
movups -0x20(%rcx,%rdx,1),%xmm1
movups %xmm0,0x40(%r14,%rdx,1)
movups %xmm1,0x50(%r14,%rdx,1)
movdqu -0x10(%rcx,%rdx,1),%xmm0
movdqu (%rcx,%rdx,1),%xmm1
movdqu %xmm0,0x60(%r14,%rdx,1)
movdqu %xmm1,0x70(%r14,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rdi
jne    17a0 <router_rewrite_metric+0x660>
test   %rsi,%rsi
je     183f <router_rewrite_metric+0x6ff>
lea    (%r14,%rdx,1),%rcx
add    $0x10,%rcx
add    %rdx,%rax
add    0x58(%rsp),%rax
shl    $0x5,%rsi
xor    %edx,%edx
nop
movdqu -0x10(%rax,%rdx,1),%xmm0
movdqu (%rax,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rcx,%rdx,1)
movdqu %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    1820 <router_rewrite_metric+0x6e0>
add    %r8,%r14
cmp    %r8,%r9
je     18bf <router_rewrite_metric+0x77f>
add    %r8,%rbx
mov    0x10(%rsp),%rdi
nop
movzbl (%rbx),%eax
add    $0x1,%rbx
mov    %al,(%r14)
add    $0x1,%r14
cmp    %r13,%rbx
jb     1850 <router_rewrite_metric+0x710>
jmp    18f8 <router_rewrite_metric+0x7b8>
xor    %esi,%esi
test   $0x1,%dl
je     18b7 <router_rewrite_metric+0x777>
movdqu (%rbx,%rsi,1),%xmm0
movdqu 0x10(%rbx,%rsi,1),%xmm1
movdqa %xmm0,%xmm2
pcmpeqb %xmm5,%xmm2
movdqa %xmm1,%xmm3
pcmpeqb %xmm5,%xmm3
movdqa %xmm2,%xmm4
pandn  %xmm0,%xmm4
pand   %xmm6,%xmm2
por    %xmm4,%xmm2
movdqa %xmm3,%xmm0
pandn  %xmm1,%xmm0
pand   %xmm6,%xmm3
por    %xmm0,%xmm3
movdqu %xmm2,(%r14,%rsi,1)
movdqu %xmm3,0x10(%r14,%rsi,1)
add    %r8,%r14
cmp    %r8,%rcx
jne    18d0 <router_rewrite_metric+0x790>
xor    %esi,%esi
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rdi
jmp    1419 <router_rewrite_metric+0x2d9>
add    %r8,%rbx
mov    0x10(%rsp),%rdi
mov    $0x5f,%ecx
nopl   (%rax)
movzbl (%rbx),%eax
cmp    $0x2e,%al
cmove  %ecx,%eax
mov    %al,(%r14)
add    $0x1,%r14
add    $0x1,%rbx
cmp    %r13,%rbx
jb     18e0 <router_rewrite_metric+0x7a0>
xor    %esi,%esi
mov    0x8(%rsp),%r13
jmp    1419 <router_rewrite_metric+0x2d9>
lea    -0x1(%r14),%rbp
movslq 0x4(%r11),%rdx
lea    (%rdx,%r13,1),%rax
mov    %rbp,%rbx
mov    0x40(%rsp),%r15
sub    %r15,%rbx
mov    0x28(%rsp),%rdi
lea    (%rdi,%rbx,1),%rcx
sub    %rax,%rcx
cmp    $0x1fff,%rcx
ja     1adf <router_rewrite_metric+0x99f>
cmp    %rdi,%rax
jae    1991 <router_rewrite_metric+0x851>
mov    %rdi,%r9
sub    %r13,%r9
sub    %rdx,%r9
cmp    $0x20,%r9
jb     1a7b <router_rewrite_metric+0x93b>
cmp    %rdi,%rbp
jae    1969 <router_rewrite_metric+0x829>
mov    %r13,%rcx
not    %rcx
add    %rdi,%rcx
sub    %rdx,%rcx
add    %r14,%rcx
cmp    %rcx,%rax
jb     1a7b <router_rewrite_metric+0x93b>
mov    %r9,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%ebx
and    $0x3,%ebx
cmp    $0x60,%rcx
jae    199b <router_rewrite_metric+0x85b>
xor    %esi,%esi
jmp    1a15 <router_rewrite_metric+0x8d5>
mov    0x20(%rsp),%rdx
jmp    1a99 <router_rewrite_metric+0x959>
and    $0xfffffffffffffffc,%rdi
lea    (%rdx,%r13,1),%rcx
add    $0x70,%rcx
xor    %esi,%esi
nopl   0x0(%rax)
movups -0x70(%rcx,%rsi,1),%xmm0
movups -0x60(%rcx,%rsi,1),%xmm1
movups %xmm0,-0x1(%r14,%rsi,1)
movups %xmm1,0xf(%r14,%rsi,1)
movups -0x50(%rcx,%rsi,1),%xmm0
movups -0x40(%rcx,%rsi,1),%xmm1
movups %xmm0,0x1f(%r14,%rsi,1)
movups %xmm1,0x2f(%r14,%rsi,1)
movups -0x30(%rcx,%rsi,1),%xmm0
movups -0x20(%rcx,%rsi,1),%xmm1
movups %xmm0,0x3f(%r14,%rsi,1)
movups %xmm1,0x4f(%r14,%rsi,1)
movdqu -0x10(%rcx,%rsi,1),%xmm0
movdqu (%rcx,%rsi,1),%xmm1
movdqu %xmm0,0x5f(%r14,%rsi,1)
movdqu %xmm1,0x6f(%r14,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdi
jne    19b0 <router_rewrite_metric+0x870>
test   %rbx,%rbx
je     1a5f <router_rewrite_metric+0x91f>
lea    (%rsi,%r14,1),%rcx
add    $0xf,%rcx
add    %rsi,%rdx
add    %r13,%rdx
add    $0x10,%rdx
shl    $0x5,%rbx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu -0x10(%rdx,%rsi,1),%xmm0
movdqu (%rdx,%rsi,1),%xmm1
movdqu %xmm0,-0x10(%rcx,%rsi,1)
movdqu %xmm1,(%rcx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rbx
jne    1a40 <router_rewrite_metric+0x900>
add    %r8,%rbp
cmp    %r8,%r9
jne    1a73 <router_rewrite_metric+0x933>
mov    0x28(%rsp),%rdi
mov    0x20(%rsp),%rdx
jmp    1a93 <router_rewrite_metric+0x953>
add    %r8,%rax
mov    0x28(%rsp),%rdi
mov    0x20(%rsp),%rdx
movzbl (%rax),%ecx
add    $0x1,%rax
mov    %cl,0x0(%rbp)
add    $0x1,%rbp
cmp    %rdi,%rax
jb     1a80 <router_rewrite_metric+0x940>
mov    %rbp,%rbx
sub    %r15,%rbx
mov    %rbp,(%rdx)
mov    %rdi,%r14
call   1040 <strlen@plt>
cltq
add    %rbx,%rax
cmp    $0x1fff,%rax
ja     1adf <router_rewrite_metric+0x99f>
mov    (%r14),%al
test   %al,%al
je     1ad2 <router_rewrite_metric+0x992>
mov    %r14,%rcx
add    $0x1,%rcx
nop
mov    %al,0x0(%rbp)
add    $0x1,%rbp
movzbl (%rcx),%eax
add    $0x1,%rcx
test   %al,%al
jne    1ac0 <router_rewrite_metric+0x980>
movb   $0x0,0x0(%rbp)
sub    %r15,%rbp
add    $0x1,%rbp
jmp    1ae1 <router_rewrite_metric+0x9a1>
xor    %ebp,%ebp
mov    %rbp,%rax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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