#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(int /*<<< orphan*/);
scalar_t__ toupper(int /*<<< orphan*/);
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 } 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 && *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;
              }
            }
          }
          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    $0x70,%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    120b <router_rewrite_metric+0xcb>
jmp    11d1 <router_rewrite_metric+0x91>
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    1206 <router_rewrite_metric+0xc6>
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    11d1 <router_rewrite_metric+0x91>
jmp    1218 <router_rewrite_metric+0xd8>
movq   $0x0,-0x8(%rbp)
jmp    166c <router_rewrite_metric+0x52c>
mov    -0x30(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%al
sub    $0x5c,%al
jne    1252 <router_rewrite_metric+0x112>
jmp    1233 <router_rewrite_metric+0xf3>
cmpb   $0x0,-0x39(%rbp)
jne    124d <router_rewrite_metric+0x10d>
movb   $0x1,-0x39(%rbp)
movl   $0x0,-0x64(%rbp)
jmp    1503 <router_rewrite_metric+0x3c3>
jmp    1252 <router_rewrite_metric+0x112>
movsbl -0x39(%rbp),%eax
cmp    $0x1,%eax
jne    1285 <router_rewrite_metric+0x145>
cmpl   $0x0,-0x64(%rbp)
jne    1285 <router_rewrite_metric+0x145>
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5f,%eax
jne    1285 <router_rewrite_metric+0x145>
movl   $0x1,-0x64(%rbp)
jmp    14fe <router_rewrite_metric+0x3be>
movsbl -0x39(%rbp),%eax
cmp    $0x1,%eax
jne    12b8 <router_rewrite_metric+0x178>
cmpl   $0x0,-0x64(%rbp)
jne    12b8 <router_rewrite_metric+0x178>
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5e,%eax
jne    12b8 <router_rewrite_metric+0x178>
movl   $0x2,-0x64(%rbp)
jmp    14f9 <router_rewrite_metric+0x3b9>
movsbl -0x39(%rbp),%eax
cmp    $0x0,%eax
je     1305 <router_rewrite_metric+0x1c5>
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jl     1305 <router_rewrite_metric+0x1c5>
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
jg     1305 <router_rewrite_metric+0x1c5>
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    14f4 <router_rewrite_metric+0x3b4>
cmpb   $0x0,-0x39(%rbp)
je     149d <router_rewrite_metric+0x35d>
cmpl   $0x0,-0x40(%rbp)
jle    1496 <router_rewrite_metric+0x356>
movslq -0x40(%rbp),%rax
cmp    -0x38(%rbp),%rax
ja     1496 <router_rewrite_metric+0x356>
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,8)
jl     1496 <router_rewrite_metric+0x356>
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    1491 <router_rewrite_metric+0x351>
mov    -0x64(%rbp),%eax
mov    %eax,-0x68(%rbp)
test   %eax,%eax
je     13bf <router_rewrite_metric+0x27f>
jmp    139d <router_rewrite_metric+0x25d>
mov    -0x68(%rbp),%eax
sub    $0x1,%eax
je     13fe <router_rewrite_metric+0x2be>
jmp    13ae <router_rewrite_metric+0x26e>
mov    -0x68(%rbp),%eax
sub    $0x2,%eax
je     1445 <router_rewrite_metric+0x305>
jmp    148c <router_rewrite_metric+0x34c>
jmp    13c4 <router_rewrite_metric+0x284>
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    13f9 <router_rewrite_metric+0x2b9>
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    13c4 <router_rewrite_metric+0x284>
jmp    148c <router_rewrite_metric+0x34c>
jmp    1403 <router_rewrite_metric+0x2c3>
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    1440 <router_rewrite_metric+0x300>
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    1403 <router_rewrite_metric+0x2c3>
jmp    148c <router_rewrite_metric+0x34c>
jmp    144a <router_rewrite_metric+0x30a>
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    1487 <router_rewrite_metric+0x347>
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    144a <router_rewrite_metric+0x30a>
jmp    148c <router_rewrite_metric+0x34c>
jmp    1491 <router_rewrite_metric+0x351>
jmp    1496 <router_rewrite_metric+0x356>
movl   $0x0,-0x40(%rbp)
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5c,%eax
je     14ef <router_rewrite_metric+0x3af>
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    14ea <router_rewrite_metric+0x3aa>
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    14ef <router_rewrite_metric+0x3af>
jmp    14f4 <router_rewrite_metric+0x3b4>
jmp    14f9 <router_rewrite_metric+0x3b9>
jmp    14fe <router_rewrite_metric+0x3be>
jmp    1503 <router_rewrite_metric+0x3c3>
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    1518 <router_rewrite_metric+0x3d8>
jmp    152e <router_rewrite_metric+0x3ee>
jmp    151d <router_rewrite_metric+0x3dd>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1220 <router_rewrite_metric+0xe0>
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    15b6 <router_rewrite_metric+0x476>
jmp    157c <router_rewrite_metric+0x43c>
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    15b1 <router_rewrite_metric+0x471>
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    157c <router_rewrite_metric+0x43c>
jmp    15c3 <router_rewrite_metric+0x483>
movq   $0x0,-0x8(%rbp)
jmp    166c <router_rewrite_metric+0x52c>
mov    -0x48(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x28(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
cmp    $0x2000,%rax
jae    1664 <router_rewrite_metric+0x524>
mov    -0x28(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     163e <router_rewrite_metric+0x4fe>
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    1606 <router_rewrite_metric+0x4c6>
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    166c <router_rewrite_metric+0x52c>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<router_rewrite_metric>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,0x18(%rsp)
mov    %r8,%rbp
mov    %rcx,%r14
mov    %rdx,%r12
mov    %rsi,%r13
mov    %rdi,%rbx
mov    0x90(%rsp),%r15
xor    %edi,%edi
test   %r15,%r15
setne  %dil
call   1050 <assert@plt>
movslq (%r15),%rax
cmp    $0x1fff,%rax
ja     1814 <router_rewrite_metric+0x6d4>
mov    %r15,%r9
mov    %r14,%r15
mov    %r12,0x8(%rsp)
mov    %rbx,0x10(%rsp)
test   %eax,%eax
mov    %r14,0x50(%rsp)
mov    %r13,0x28(%rsp)
je     121c <router_rewrite_metric+0xdc>
mov    0x8(%rsp),%r11
add    %r11,%rax
lea    0x1(%r11),%rsi
cmp    %rsi,%rax
mov    %rsi,%r8
cmova  %rax,%r8
sub    %r11,%r8
mov    %r11,%rcx
mov    0x10(%rsp),%r10
mov    %r10,%r14
cmp    $0x20,%r8
jb     12fe <router_rewrite_metric+0x1be>
cmp    %rsi,%rax
cmova  %rax,%rsi
cmp    %rsi,%r10
jae    11f4 <router_rewrite_metric+0xb4>
sub    %r11,%rsi
add    %r10,%rsi
mov    %r11,%rcx
mov    %r10,%r14
cmp    %r11,%rsi
ja     12fe <router_rewrite_metric+0x1be>
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    1233 <router_rewrite_metric+0xf3>
xor    %ebx,%ebx
jmp    12a8 <router_rewrite_metric+0x168>
mov    0x10(%rsp),%r10
mov    %r10,%r14
mov    0x8(%rsp),%r11
mov    0x18(%rsp),%r8
jmp    1323 <router_rewrite_metric+0x1e3>
and    $0xfffffffffffffffc,%rdi
xor    %ebx,%ebx
nopl   0x0(%rax)
movups (%r11,%rbx,1),%xmm0
movups 0x10(%r11,%rbx,1),%xmm1
movups %xmm0,(%r10,%rbx,1)
movups %xmm1,0x10(%r10,%rbx,1)
movups 0x20(%r11,%rbx,1),%xmm0
movups 0x30(%r11,%rbx,1),%xmm1
movups %xmm0,0x20(%r10,%rbx,1)
movups %xmm1,0x30(%r10,%rbx,1)
movups 0x40(%r11,%rbx,1),%xmm0
movups 0x50(%r11,%rbx,1),%xmm1
movups %xmm0,0x40(%r10,%rbx,1)
movups %xmm1,0x50(%r10,%rbx,1)
movups 0x60(%r11,%rbx,1),%xmm0
movups 0x70(%r11,%rbx,1),%xmm1
movups %xmm0,0x60(%r10,%rbx,1)
movups %xmm1,0x70(%r10,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%rdi
jne    1240 <router_rewrite_metric+0x100>
test   %rsi,%rsi
je     12eb <router_rewrite_metric+0x1ab>
lea    (%r10,%rbx,1),%rdi
add    $0x10,%rdi
add    %r11,%rbx
add    $0x10,%rbx
shl    $0x5,%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rbx,%rdx,1),%xmm0
movups (%rbx,%rdx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rdx,1)
movups %xmm1,(%rdi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    12d0 <router_rewrite_metric+0x190>
lea    (%r10,%rcx,1),%r14
cmp    %rcx,%r8
jne    12fb <router_rewrite_metric+0x1bb>
mov    0x18(%rsp),%r8
jmp    1323 <router_rewrite_metric+0x1e3>
add    %r11,%rcx
mov    0x18(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rcx),%edx
add    $0x1,%rcx
mov    %dl,(%r14)
add    $0x1,%r14
cmp    %rax,%rcx
jb     1310 <router_rewrite_metric+0x1d0>
mov    $0x1,%edi
sub    %r10,%rdi
mov    %r11,%rax
neg    %rax
mov    %rax,0x40(%rsp)
lea    0x1(%r11),%rax
mov    %rax,0x48(%rsp)
xor    %r12d,%r12d
lea    0x70(%r11),%rax
mov    %rax,0x30(%rsp)
lea    0x10(%r11),%rax
mov    %rax,0x38(%rsp)
xor    %esi,%esi
xor    %r15d,%r15d
mov    %rdi,0x20(%rsp)
jmp    136a <router_rewrite_metric+0x22a>
xor    %r15d,%r15d
add    $0x1,%rbp
mov    %ecx,%r12d
movzbl 0x0(%rbp),%edx
mov    $0x1,%cl
cmp    $0x5c,%edx
jne    137a <router_rewrite_metric+0x23a>
test   %r12b,%r12b
je     1360 <router_rewrite_metric+0x220>
cmp    $0x1,%r12b
sete   %al
test   %r15d,%r15d
sete   %bl
and    %al,%bl
cmp    $0x1,%bl
jne    13a0 <router_rewrite_metric+0x260>
cmp    $0x5f,%dl
jne    13a0 <router_rewrite_metric+0x260>
mov    $0x1,%r15d
jmp    1363 <router_rewrite_metric+0x223>
nopl   0x0(%rax,%rax,1)
test   %bl,%bl
je     13b1 <router_rewrite_metric+0x271>
cmp    $0x5e,%dl
jne    13ca <router_rewrite_metric+0x28a>
mov    $0x2,%r15d
jmp    1363 <router_rewrite_metric+0x223>
test   %r12b,%r12b
je     13d1 <router_rewrite_metric+0x291>
lea    -0x30(%rdx),%eax
cmp    $0xa,%al
jae    13d1 <router_rewrite_metric+0x291>
lea    (%rsi,%rsi,4),%eax
lea    (%rdx,%rax,2),%esi
add    $0xffffffd0,%esi
mov    $0x2,%cl
jmp    1363 <router_rewrite_metric+0x223>
lea    -0x30(%rdx),%eax
cmp    $0x9,%al
jbe    13bd <router_rewrite_metric+0x27d>
test   %r12b,%r12b
je     13dc <router_rewrite_metric+0x29c>
test   %esi,%esi
jg     1414 <router_rewrite_metric+0x2d4>
xor    %esi,%esi
mov    0x0(%rbp),%cl
cmp    $0x5c,%cl
jne    13ec <router_rewrite_metric+0x2ac>
mov    %r12d,%ecx
jmp    1363 <router_rewrite_metric+0x223>
lea    (%rdi,%r14,1),%rax
cmp    $0x1fff,%rax
ja     1402 <router_rewrite_metric+0x2c2>
mov    %cl,(%r14)
add    $0x1,%r14
mov    0x0(%rbp),%cl
xor    %r15d,%r15d
test   %cl,%cl
je     1648 <router_rewrite_metric+0x508>
xor    %ecx,%ecx
jmp    1363 <router_rewrite_metric+0x223>
mov    %esi,%ecx
cmp    %r8,%rcx
ja     13da <router_rewrite_metric+0x29a>
mov    (%r9,%rcx,8),%eax
test   %eax,%eax
js     13da <router_rewrite_metric+0x29a>
lea    (%r11,%rax,1),%rbx
movslq 0x4(%r9,%rcx,8),%rcx
lea    (%r11,%rcx,1),%r13
mov    %r14,%rdx
sub    %r10,%rdx
add    %r13,%rdx
sub    %rbx,%rdx
cmp    $0x1fff,%rdx
ja     13da <router_rewrite_metric+0x29a>
test   %r15d,%r15d
je     147a <router_rewrite_metric+0x33a>
cmp    $0x1,%r15d
je     14ae <router_rewrite_metric+0x36e>
cmp    $0x2,%r15d
jne    13da <router_rewrite_metric+0x29a>
cmp    %rcx,%rax
jge    14d8 <router_rewrite_metric+0x398>
nopl   0x0(%rax,%rax,1)
movsbl (%rbx),%edi
add    $0x1,%rbx
call   1030 <toupper@plt>
mov    %al,(%r14)
add    $0x1,%r14
cmp    %r13,%rbx
jb     1460 <router_rewrite_metric+0x320>
jmp    14d8 <router_rewrite_metric+0x398>
cmp    %rcx,%rax
jge    13da <router_rewrite_metric+0x29a>
mov    0x48(%rsp),%rcx
add    %rax,%rcx
cmp    %r13,%rcx
mov    %r13,%r9
cmova  %rcx,%r9
sub    %r11,%r9
sub    %rax,%r9
cmp    $0x20,%r9
jae    14fb <router_rewrite_metric+0x3bb>
mov    0x90(%rsp),%r9
jmp    1630 <router_rewrite_metric+0x4f0>
cmp    %rcx,%rax
jge    14d8 <router_rewrite_metric+0x398>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbl (%rbx),%edi
add    $0x1,%rbx
call   1060 <tolower@plt>
mov    %al,(%r14)
add    $0x1,%r14
cmp    %r13,%rbx
jb     14c0 <router_rewrite_metric+0x380>
xor    %esi,%esi
mov    0x10(%rsp),%r10
mov    0x8(%rsp),%r11
mov    0x18(%rsp),%r8
mov    0x90(%rsp),%r9
mov    0x20(%rsp),%rdi
jmp    13dc <router_rewrite_metric+0x29c>
cmp    %r13,%rcx
cmovbe %r13,%rcx
cmp    %rcx,%r14
jae    1527 <router_rewrite_metric+0x3e7>
mov    0x40(%rsp),%rdx
add    %r14,%rdx
sub    %rax,%rcx
add    %rdx,%rcx
cmp    %rcx,%rbx
jae    1527 <router_rewrite_metric+0x3e7>
mov    0x90(%rsp),%r9
jmp    1630 <router_rewrite_metric+0x4f0>
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    154c <router_rewrite_metric+0x40c>
xor    %edx,%edx
jmp    15c0 <router_rewrite_metric+0x480>
and    $0xfffffffffffffffc,%rdi
mov    0x30(%rsp),%rcx
add    %rax,%rcx
xor    %edx,%edx
nopw   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)
movups -0x10(%rcx,%rdx,1),%xmm0
movups (%rcx,%rdx,1),%xmm1
movups %xmm0,0x60(%r14,%rdx,1)
movups %xmm1,0x70(%r14,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1560 <router_rewrite_metric+0x420>
test   %rsi,%rsi
je     15fb <router_rewrite_metric+0x4bb>
lea    (%r14,%rdx,1),%rcx
add    $0x10,%rcx
add    %rdx,%rax
add    0x38(%rsp),%rax
shl    $0x5,%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups -0x10(%rax,%rdx,1),%xmm0
movups (%rax,%rdx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdx,1)
movups %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    15e0 <router_rewrite_metric+0x4a0>
add    %r8,%r14
cmp    %r8,%r9
mov    %r8,%rax
mov    0x18(%rsp),%r8
jne    1612 <router_rewrite_metric+0x4d2>
xor    %esi,%esi
jmp    14e9 <router_rewrite_metric+0x3a9>
add    %rax,%rbx
mov    0x90(%rsp),%r9
mov    0x20(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rbx),%eax
add    $0x1,%rbx
mov    %al,(%r14)
add    $0x1,%r14
cmp    %r13,%rbx
jb     1630 <router_rewrite_metric+0x4f0>
jmp    13da <router_rewrite_metric+0x29a>
lea    -0x1(%r14),%rbp
movslq 0x4(%r9),%rdx
lea    (%r11,%rdx,1),%rax
mov    %rbp,%r15
sub    %r10,%r15
mov    0x50(%rsp),%rbx
lea    (%rbx,%r15,1),%rcx
sub    %rax,%rcx
cmp    $0x1fff,%rcx
ja     1814 <router_rewrite_metric+0x6d4>
cmp    %rbx,%rax
jae    1691 <router_rewrite_metric+0x551>
mov    %rbx,%r9
sub    %r11,%r9
sub    %rdx,%r9
cmp    $0x20,%r9
jae    169b <router_rewrite_metric+0x55b>
mov    0x28(%rsp),%rdx
jmp    17c0 <router_rewrite_metric+0x680>
mov    0x28(%rsp),%rdx
jmp    17d9 <router_rewrite_metric+0x699>
cmp    %rbx,%rbp
jae    16be <router_rewrite_metric+0x57e>
mov    %r11,%rcx
not    %rcx
add    %rbx,%rcx
sub    %rdx,%rcx
add    %r14,%rcx
cmp    %rcx,%rax
jae    16be <router_rewrite_metric+0x57e>
mov    0x28(%rsp),%rdx
jmp    17c0 <router_rewrite_metric+0x680>
mov    %r9,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r11d
and    $0x3,%r11d
cmp    $0x60,%rcx
jae    16e5 <router_rewrite_metric+0x5a5>
xor    %esi,%esi
jmp    1761 <router_rewrite_metric+0x621>
and    $0xfffffffffffffffc,%rdi
mov    0x8(%rsp),%rcx
add    %rdx,%rcx
add    $0x70,%rcx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
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)
movups -0x10(%rcx,%rsi,1),%xmm0
movups (%rcx,%rsi,1),%xmm1
movups %xmm0,0x5f(%r14,%rsi,1)
movups %xmm1,0x6f(%r14,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1700 <router_rewrite_metric+0x5c0>
test   %r11,%r11
je     17ab <router_rewrite_metric+0x66b>
lea    (%rsi,%r14,1),%rcx
add    $0xf,%rcx
add    %rsi,%rdx
mov    0x8(%rsp),%rsi
add    %rsi,%rdx
add    $0x10,%rdx
shl    $0x5,%r11
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdx,%rsi,1),%xmm0
movups (%rdx,%rsi,1),%xmm1
movups %xmm0,-0x10(%rcx,%rsi,1)
movups %xmm1,(%rcx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r11
jne    1790 <router_rewrite_metric+0x650>
add    %r8,%rbp
cmp    %r8,%r9
mov    0x28(%rsp),%rdx
je     17d3 <router_rewrite_metric+0x693>
add    %r8,%rax
nopl   0x0(%rax,%rax,1)
movzbl (%rax),%ecx
add    $0x1,%rax
mov    %cl,0x0(%rbp)
add    $0x1,%rbp
cmp    %rbx,%rax
jb     17c0 <router_rewrite_metric+0x680>
mov    %rbp,%r15
sub    %r10,%r15
mov    %rbp,(%rdx)
mov    %rbx,%rdi
call   1040 <strlen@plt>
cltq
add    %r15,%rax
cmp    $0x1fff,%rax
ja     1814 <router_rewrite_metric+0x6d4>
mov    (%rbx),%al
test   %al,%al
je     1828 <router_rewrite_metric+0x6e8>
add    $0x1,%rbx
mov    0x10(%rsp),%rcx
mov    %al,0x0(%rbp)
add    $0x1,%rbp
movzbl (%rbx),%eax
add    $0x1,%rbx
test   %al,%al
jne    1800 <router_rewrite_metric+0x6c0>
jmp    182d <router_rewrite_metric+0x6ed>
xor    %ebp,%ebp
mov    %rbp,%rax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x10(%rsp),%rcx
movb   $0x0,0x0(%rbp)
sub    %rcx,%rbp
add    $0x1,%rbp
jmp    1816 <router_rewrite_metric+0x6d6>

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 %331
63: ; preds = %61
%64 = load i8*, i8** %13
store i8* %64, i8** %19
br label %65
65: ; preds = %252, %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 %245
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 %244
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 %243
100: ; preds = %94, %91, %87
%101 = load i8, i8* %16
%102 = sext i8 %101 to i32
%103 = icmp ne i32 %102, 0
br i1 %103, label %104, label %123
104: ; preds = %100
%105 = load i8*, i8** %19
%106 = load i8, i8* %105
%107 = sext i8 %106 to i32
%108 = icmp sge i32 %107, 48
br i1 %108, label %109, label %123
109: ; preds = %104
%110 = load i8*, i8** %19
%111 = load i8, i8* %110
%112 = sext i8 %111 to i32
%113 = icmp sle i32 %112, 57
br i1 %113, label %114, label %123
114: ; preds = %109
store i8 2, i8* %16
%115 = load i32, i32* %17
%116 = mul nsw i32 %115, 10
store i32 %116, i32* %17
%117 = load i8*, i8** %19
%118 = load i8, i8* %117
%119 = sext i8 %118 to i32
%120 = sub nsw i32 %119, 48
%121 = load i32, i32* %17
%122 = add nsw i32 %121, %120
store i32 %122, i32* %17
br label %242
123: ; preds = %109, %104, %100
%124 = load i8, i8* %16
%125 = icmp ne i8 %124, 0
br i1 %125, label %126, label %221
126: ; preds = %123
%127 = load i32, i32* %17
%128 = icmp sgt i32 %127, 0
br i1 %128, label %129, label %220
129: ; preds = %126
%130 = load i32, i32* %17
%131 = sext i32 %130 to i64
%132 = load i64, i64* %14
%133 = icmp ule i64 %131, %132
br i1 %133, label %134, label %220
134: ; preds = %129
%135 = load %struct.TYPE_3__*, %struct.TYPE_3__** %15
%136 = load i32, i32* %17
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %135, i64 %137
%139 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %138, i32 0, i32 0
%140 = load i32, i32* %139
%141 = icmp sge i32 %140, 0
br i1 %141, label %142, label %220
142: ; preds = %134
%143 = load i8*, i8** %11
%144 = load %struct.TYPE_3__*, %struct.TYPE_3__** %15
%145 = load i32, i32* %17
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %144, i64 %146
%148 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %147, i32 0, i32 0
%149 = load i32, i32* %148
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i8, i8* %143, i64 %150
store i8* %151, i8** %20
%152 = load i8*, i8** %11
%153 = load %struct.TYPE_3__*, %struct.TYPE_3__** %15
%154 = load i32, i32* %17
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %153, i64 %155
%157 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %156, i32 0, i32 1
%158 = load i32, i32* %157
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds i8, i8* %152, i64 %159
store i8* %160, i8** %21
%161 = load i8*, i8** %18
%162 = load [8192 x i8]*, [8192 x i8]** %9
%163 = getelementptr inbounds [8192 x i8], [8192 x i8]* %162, i64 0, i64 0
%164 = ptrtoint i8* %161 to i64
%165 = ptrtoint i8* %163 to i64
%166 = sub i64 %164, %165
%167 = load i8*, i8** %21
%168 = getelementptr inbounds i8, i8* %167, i64 %166
%169 = load i8*, i8** %20
%170 = ptrtoint i8* %168 to i64
%171 = ptrtoint i8* %169 to i64
%172 = sub i64 %170, %171
%173 = icmp ult i64 %172, 8192
br i1 %173, label %174, label %219
174: ; preds = %142
%175 = load i32, i32* %22
switch i32 %175, label %218 [
i32 0, label %176
i32 1, label %188
i32 2, label %203
]
176: ; preds = %174
br label %177
177: ; preds = %181, %176
%178 = load i8*, i8** %20
%179 = load i8*, i8** %21
%180 = icmp ult i8* %178, %179
br i1 %180, label %181, label %187
181: ; preds = %177
%182 = load i8*, i8** %20
%183 = getelementptr inbounds i8, i8* %182, i32 1
store i8* %183, i8** %20
%184 = load i8, i8* %182
%185 = load i8*, i8** %18
%186 = getelementptr inbounds i8, i8* %185, i32 1
store i8* %186, i8** %18
store i8 %184, i8* %185
br label %177
187: ; preds = %177
br label %218
188: ; preds = %174
br label %189
189: ; preds = %193, %188
%190 = load i8*, i8** %20
%191 = load i8*, i8** %21
%192 = icmp ult i8* %190, %191
br i1 %192, label %193, label %202
193: ; preds = %189
%194 = load i8*, i8** %20
%195 = getelementptr inbounds i8, i8* %194, i32 1
store i8* %195, i8** %20
%196 = load i8, i8* %194
%197 = sext i8 %196 to i32
%198 = call i64 @tolower(i32 %197)
%199 = trunc i64 %198 to i8
%200 = load i8*, i8** %18
%201 = getelementptr inbounds i8, i8* %200, i32 1
store i8* %201, i8** %18
store i8 %199, i8* %200
br label %189
202: ; preds = %189
br label %218
203: ; preds = %174
br label %204
204: ; preds = %208, %203
%205 = load i8*, i8** %20
%206 = load i8*, i8** %21
%207 = icmp ult i8* %205, %206
br i1 %207, label %208, label %217
208: ; preds = %204
%209 = load i8*, i8** %20
%210 = getelementptr inbounds i8, i8* %209, i32 1
store i8* %210, i8** %20
%211 = load i8, i8* %209
%212 = sext i8 %211 to i32
%213 = call i64 @toupper(i32 %212)
%214 = trunc i64 %213 to i8
%215 = load i8*, i8** %18
%216 = getelementptr inbounds i8, i8* %215, i32 1
store i8* %216, i8** %18
store i8 %214, i8* %215
br label %204
217: ; preds = %204
br label %218
218: ; preds = %174, %217, %202, %187
br label %219
219: ; preds = %218, %142
br label %220
220: ; preds = %219, %134, %129, %126
store i32 0, i32* %17
br label %221
221: ; preds = %220, %123
%222 = load i8*, i8** %19
%223 = load i8, i8* %222
%224 = sext i8 %223 to i32
%225 = icmp ne i32 %224, 92
br i1 %225, label %226, label %241
226: ; preds = %221
store i8 0, i8* %16
store i32 0, i32* %22
%227 = load i8*, i8** %18
%228 = load [8192 x i8]*, [8192 x i8]** %9
%229 = getelementptr inbounds [8192 x i8], [8192 x i8]* %228, i64 0, i64 0
%230 = ptrtoint i8* %227 to i64
%231 = ptrtoint i8* %229 to i64
%232 = sub i64 %230, %231
%233 = add nsw i64 %232, 1
%234 = icmp ult i64 %233, 8192
br i1 %234, label %235, label %240
235: ; preds = %226
%236 = load i8*, i8** %19
%237 = load i8, i8* %236
%238 = load i8*, i8** %18
%239 = getelementptr inbounds i8, i8* %238, i32 1
store i8* %239, i8** %18
store i8 %237, i8* %238
br label %240
240: ; preds = %235, %226
br label %241
241: ; preds = %240, %221
br label %242
242: ; preds = %241, %114
br label %243
243: ; preds = %242, %99
br label %244
244: ; preds = %243, %86
br label %245
245: ; preds = %244, %72
%246 = load i8*, i8** %19
%247 = load i8, i8* %246
%248 = sext i8 %247 to i32
%249 = icmp eq i32 %248, 0
br i1 %249, label %250, label %251
250: ; preds = %245
br label %255
251: ; preds = %245
br label %252
252: ; preds = %251
%253 = load i8*, i8** %19
%254 = getelementptr inbounds i8, i8* %253, i32 1
store i8* %254, i8** %19
br label %65
255: ; preds = %250
%256 = load i8*, i8** %18
%257 = getelementptr inbounds i8, i8* %256, i32 -1
store i8* %257, i8** %18
%258 = load i8*, i8** %11
%259 = load %struct.TYPE_3__*, %struct.TYPE_3__** %15
%260 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %259, i64 0
%261 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %260, i32 0, i32 1
%262 = load i32, i32* %261
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i8, i8* %258, i64 %263
store i8* %264, i8** %20
%265 = load i8*, i8** %12
store i8* %265, i8** %21
%266 = load i8*, i8** %18
%267 = load [8192 x i8]*, [8192 x i8]** %9
%268 = getelementptr inbounds [8192 x i8], [8192 x i8]* %267, i64 0, i64 0
%269 = ptrtoint i8* %266 to i64
%270 = ptrtoint i8* %268 to i64
%271 = sub i64 %269, %270
%272 = load i8*, i8** %21
%273 = getelementptr inbounds i8, i8* %272, i64 %271
%274 = load i8*, i8** %20
%275 = ptrtoint i8* %273 to i64
%276 = ptrtoint i8* %274 to i64
%277 = sub i64 %275, %276
%278 = icmp ult i64 %277, 8192
br i1 %278, label %279, label %291
279: ; preds = %255
br label %280
280: ; preds = %284, %279
%281 = load i8*, i8** %20
%282 = load i8*, i8** %21
%283 = icmp ult i8* %281, %282
br i1 %283, label %284, label %290
284: ; preds = %280
%285 = load i8*, i8** %20
%286 = getelementptr inbounds i8, i8* %285, i32 1
store i8* %286, i8** %20
%287 = load i8, i8* %285
%288 = load i8*, i8** %18
%289 = getelementptr inbounds i8, i8* %288, i32 1
store i8* %289, i8** %18
store i8 %287, i8* %288
br label %280
290: ; preds = %280
br label %292
291: ; preds = %255
store i64 0, i64* %8
br label %331
292: ; preds = %290
%293 = load i8*, i8** %18
%294 = load i8**, i8*** %10
store i8* %293, i8** %294
%295 = load i8*, i8** %18
%296 = load [8192 x i8]*, [8192 x i8]** %9
%297 = getelementptr inbounds [8192 x i8], [8192 x i8]* %296, i64 0, i64 0
%298 = ptrtoint i8* %295 to i64
%299 = ptrtoint i8* %297 to i64
%300 = sub i64 %298, %299
%301 = load i8*, i8** %12
%302 = call i32 @strlen(i8* %301)
%303 = sext i32 %302 to i64
%304 = add nsw i64 %300, %303
%305 = icmp ult i64 %304, 8192
br i1 %305, label %306, label %330
306: ; preds = %292
%307 = load i8*, i8** %12
store i8* %307, i8** %19
br label %308
308: ; preds = %318, %306
%309 = load i8*, i8** %19
%310 = load i8, i8* %309
%311 = sext i8 %310 to i32
%312 = icmp ne i32 %311, 0
br i1 %312, label %313, label %321
313: ; preds = %308
%314 = load i8*, i8** %19
%315 = load i8, i8* %314
%316 = load i8*, i8** %18
%317 = getelementptr inbounds i8, i8* %316, i32 1
store i8* %317, i8** %18
store i8 %315, i8* %316
br label %318
318: ; preds = %313
%319 = load i8*, i8** %19
%320 = getelementptr inbounds i8, i8* %319, i32 1
store i8* %320, i8** %19
br label %308
321: ; preds = %308
%322 = load i8*, i8** %18
%323 = getelementptr inbounds i8, i8* %322, i32 1
store i8* %323, i8** %18
store i8 0, i8* %322
%324 = load i8*, i8** %18
%325 = load [8192 x i8]*, [8192 x i8]** %9
%326 = getelementptr inbounds [8192 x i8], [8192 x i8]* %325, i64 0, i64 0
%327 = ptrtoint i8* %324 to i64
%328 = ptrtoint i8* %326 to i64
%329 = sub i64 %327, %328
store i64 %329, i64* %8
br label %331
330: ; preds = %292
store i64 0, i64* %8
br label %331
331: ; preds = %330, %321, %291, %62
%332 = load i64, i64* %8
ret i64 %332
}

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 %500
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 %133
126: ; preds = %133, %121, %24
%127 = phi i8* [ %14, %24 ], [ %45, %121 ], [ %138, %133 ]
%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
br label %140
133: ; preds = %123, %133
%134 = phi i8* [ %136, %133 ], [ %124, %123 ]
%135 = phi i8* [ %138, %133 ], [ %125, %123 ]
%136 = getelementptr inbounds i8, i8* %134, i64 1
%137 = load i8, i8* %134
%138 = getelementptr inbounds i8, i8* %135, i64 1
store i8 %137, i8* %135
%139 = icmp ult i8* %136, %21
br i1 %139, label %133, label %126
140: ; preds = %126, %347
%141 = phi i8 [ %351, %347 ], [ 0, %126 ]
%142 = phi i32 [ %350, %347 ], [ 0, %126 ]
%143 = phi i8* [ %349, %347 ], [ %127, %126 ]
%144 = phi i8* [ %352, %347 ], [ %4, %126 ]
%145 = phi i32 [ %348, %347 ], [ 0, %126 ]
%146 = load i8, i8* %144
%147 = icmp ne i8 %146, 92
%148 = icmp ne i8 %141, 0
%149 = select i1 %147, i1 true, i1 %148
br i1 %149, label %150, label %347
150: ; preds = %140
%151 = icmp eq i8 %141, 1
%152 = icmp eq i32 %145, 0
%153 = select i1 %151, i1 %152, i1 false
%154 = icmp eq i8 %146, 95
%155 = select i1 %153, i1 %154, i1 false
br i1 %155, label %347, label %156
156: ; preds = %150
br i1 %153, label %157, label %159
157: ; preds = %156
%158 = icmp eq i8 %146, 94
br i1 %158, label %347, label %163
159: ; preds = %156
%160 = add i8 %146, -48
%161 = icmp ult i8 %160, 10
%162 = select i1 %148, i1 %161, i1 false
br i1 %162, label %166, label %171
163: ; preds = %157
%164 = add i8 %146, -48
%165 = icmp ult i8 %164, 10
br i1 %165, label %166, label %171
166: ; preds = %159, %163
%167 = zext i8 %146 to i32
%168 = mul nsw i32 %142, 10
%169 = add i32 %168, -48
%170 = add i32 %169, %167
br label %347
171: ; preds = %163, %159
br i1 %148, label %172, label %331
172: ; preds = %171
%173 = icmp sgt i32 %142, 0
br i1 %173, label %174, label %331
174: ; preds = %172
%175 = zext i32 %142 to i64
%176 = icmp ugt i64 %175, %5
br i1 %176, label %331, label %177
177: ; preds = %174
%178 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %6, i64 %175, i32 0
%179 = load i32, i32* %178
%180 = icmp sgt i32 %179, -1
br i1 %180, label %181, label %331
181: ; preds = %177
%182 = zext i32 %179 to i64
%183 = getelementptr i8, i8* %2, i64 %182
%184 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %6, i64 %175, i32 1
%185 = load i32, i32* %184
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i8, i8* %2, i64 %186
%188 = ptrtoint i8* %143 to i64
%189 = sub i64 %188, %22
%190 = getelementptr inbounds i8, i8* %187, i64 %189
%191 = ptrtoint i8* %190 to i64
%192 = ptrtoint i8* %183 to i64
%193 = sub i64 %191, %192
%194 = icmp ult i64 %193, 8192
br i1 %194, label %195, label %331
195: ; preds = %181
switch i32 %145, label %331 [
i32 0, label %200
i32 1, label %198
i32 2, label %196
]
196: ; preds = %195
%197 = icmp slt i64 %182, %186
br i1 %197, label %321, label %331
198: ; preds = %195
%199 = icmp slt i64 %182, %186
br i1 %199, label %311, label %331
200: ; preds = %195
%201 = icmp slt i64 %182, %186
br i1 %201, label %202, label %331
202: ; preds = %200
%203 = add i64 %132, %182
%204 = add i64 %13, %186
%205 = call i64 @llvm.umax.i64(i64 %203, i64 %204)
%206 = add i64 %13, %182
%207 = sub i64 %205, %206
%208 = icmp ult i64 %207, 32
br i1 %208, label %301, label %209
209: ; preds = %202
%210 = getelementptr i8, i8* %143, i64 %129
%211 = add i64 %130, %182
%212 = add i64 %13, %186
%213 = call i64 @llvm.umax.i64(i64 %211, i64 %212)
%214 = sub i64 %213, %182
%215 = getelementptr i8, i8* %210, i64 %214
%216 = getelementptr i8, i8* %131, i64 %213
%217 = icmp ult i8* %143, %216
%218 = icmp ult i8* %183, %215
%219 = and i1 %217, %218
br i1 %219, label %301, label %220
220: ; preds = %209
%221 = and i64 %207, -32
%222 = getelementptr i8, i8* %183, i64 %221
%223 = getelementptr i8, i8* %143, i64 %221
%224 = add i64 %221, -32
%225 = lshr exact i64 %224, 5
%226 = add nuw nsw i64 %225, 1
%227 = and i64 %226, 3
%228 = icmp ult i64 %224, 96
br i1 %228, label %280, label %229
229: ; preds = %220
%230 = and i64 %226, 1152921504606846972
br label %231
231: ; preds = %231, %229
%232 = phi i64 [ 0, %229 ], [ %277, %231 ]
%233 = phi i64 [ 0, %229 ], [ %278, %231 ]
%234 = getelementptr i8, i8* %183, i64 %232
%235 = getelementptr i8, i8* %143, i64 %232
%236 = bitcast i8* %234 to <16 x i8>*
%237 = load <16 x i8>, <16 x i8>* %236
%238 = getelementptr i8, i8* %234, i64 16
%239 = bitcast i8* %238 to <16 x i8>*
%240 = load <16 x i8>, <16 x i8>* %239
%241 = bitcast i8* %235 to <16 x i8>*
store <16 x i8> %237, <16 x i8>* %241
%242 = getelementptr i8, i8* %235, i64 16
%243 = bitcast i8* %242 to <16 x i8>*
store <16 x i8> %240, <16 x i8>* %243
%244 = or i64 %232, 32
%245 = getelementptr i8, i8* %183, i64 %244
%246 = getelementptr i8, i8* %143, i64 %244
%247 = bitcast i8* %245 to <16 x i8>*
%248 = load <16 x i8>, <16 x i8>* %247
%249 = getelementptr i8, i8* %245, i64 16
%250 = bitcast i8* %249 to <16 x i8>*
%251 = load <16 x i8>, <16 x i8>* %250
%252 = bitcast i8* %246 to <16 x i8>*
store <16 x i8> %248, <16 x i8>* %252
%253 = getelementptr i8, i8* %246, i64 16
%254 = bitcast i8* %253 to <16 x i8>*
store <16 x i8> %251, <16 x i8>* %254
%255 = or i64 %232, 64
%256 = getelementptr i8, i8* %183, i64 %255
%257 = getelementptr i8, i8* %143, i64 %255
%258 = bitcast i8* %256 to <16 x i8>*
%259 = load <16 x i8>, <16 x i8>* %258
%260 = getelementptr i8, i8* %256, i64 16
%261 = bitcast i8* %260 to <16 x i8>*
%262 = load <16 x i8>, <16 x i8>* %261
%263 = bitcast i8* %257 to <16 x i8>*
store <16 x i8> %259, <16 x i8>* %263
%264 = getelementptr i8, i8* %257, i64 16
%265 = bitcast i8* %264 to <16 x i8>*
store <16 x i8> %262, <16 x i8>* %265
%266 = or i64 %232, 96
%267 = getelementptr i8, i8* %183, i64 %266
%268 = getelementptr i8, i8* %143, i64 %266
%269 = bitcast i8* %267 to <16 x i8>*
%270 = load <16 x i8>, <16 x i8>* %269
%271 = getelementptr i8, i8* %267, i64 16
%272 = bitcast i8* %271 to <16 x i8>*
%273 = load <16 x i8>, <16 x i8>* %272
%274 = bitcast i8* %268 to <16 x i8>*
store <16 x i8> %270, <16 x i8>* %274
%275 = getelementptr i8, i8* %268, i64 16
%276 = bitcast i8* %275 to <16 x i8>*
store <16 x i8> %273, <16 x i8>* %276
%277 = add nuw i64 %232, 128
%278 = add i64 %233, 4
%279 = icmp eq i64 %278, %230
br i1 %279, label %280, label %231
280: ; preds = %231, %220
%281 = phi i64 [ 0, %220 ], [ %277, %231 ]
%282 = icmp eq i64 %227, 0
br i1 %282, label %299, label %283
283: ; preds = %280, %283
%284 = phi i64 [ %296, %283 ], [ %281, %280 ]
%285 = phi i64 [ %297, %283 ], [ 0, %280 ]
%286 = getelementptr i8, i8* %183, i64 %284
%287 = getelementptr i8, i8* %143, i64 %284
%288 = bitcast i8* %286 to <16 x i8>*
%289 = load <16 x i8>, <16 x i8>* %288
%290 = getelementptr i8, i8* %286, i64 16
%291 = bitcast i8* %290 to <16 x i8>*
%292 = load <16 x i8>, <16 x i8>* %291
%293 = bitcast i8* %287 to <16 x i8>*
store <16 x i8> %289, <16 x i8>* %293
%294 = getelementptr i8, i8* %287, i64 16
%295 = bitcast i8* %294 to <16 x i8>*
store <16 x i8> %292, <16 x i8>* %295
%296 = add nuw i64 %284, 32
%297 = add i64 %285, 1
%298 = icmp eq i64 %297, %227
br i1 %298, label %299, label %283
299: ; preds = %283, %280
%300 = icmp eq i64 %207, %221
br i1 %300, label %331, label %301
301: ; preds = %209, %202, %299
%302 = phi i8* [ %183, %209 ], [ %183, %202 ], [ %222, %299 ]
%303 = phi i8* [ %143, %209 ], [ %143, %202 ], [ %223, %299 ]
br label %304
304: ; preds = %301, %304
%305 = phi i8* [ %307, %304 ], [ %302, %301 ]
%306 = phi i8* [ %309, %304 ], [ %303, %301 ]
%307 = getelementptr inbounds i8, i8* %305, i64 1
%308 = load i8, i8* %305
%309 = getelementptr inbounds i8, i8* %306, i64 1
store i8 %308, i8* %306
%310 = icmp ult i8* %307, %187
br i1 %310, label %304, label %331
311: ; preds = %198, %311
%312 = phi i8* [ %314, %311 ], [ %183, %198 ]
%313 = phi i8* [ %319, %311 ], [ %143, %198 ]
%314 = getelementptr inbounds i8, i8* %312, i64 1
%315 = load i8, i8* %312
%316 = sext i8 %315 to i32
%317 = tail call i64 @tolower(i32 %316)
%318 = trunc i64 %317 to i8
%319 = getelementptr inbounds i8, i8* %313, i64 1
store i8 %318, i8* %313
%320 = icmp ult i8* %314, %187
br i1 %320, label %311, label %331
321: ; preds = %196, %321
%322 = phi i8* [ %324, %321 ], [ %183, %196 ]
%323 = phi i8* [ %329, %321 ], [ %143, %196 ]
%324 = getelementptr inbounds i8, i8* %322, i64 1
%325 = load i8, i8* %322
%326 = sext i8 %325 to i32
%327 = tail call i64 @toupper(i32 %326)
%328 = trunc i64 %327 to i8
%329 = getelementptr inbounds i8, i8* %323, i64 1
store i8 %328, i8* %323
%330 = icmp ult i8* %324, %187
br i1 %330, label %321, label %331
331: ; preds = %321, %311, %304, %299, %196, %198, %200, %172, %174, %177, %195, %181, %171
%332 = phi i32 [ %142, %171 ], [ 0, %181 ], [ 0, %195 ], [ 0, %177 ], [ 0, %174 ], [ 0, %172 ], [ 0, %200 ], [ 0, %198 ], [ 0, %196 ], [ 0, %299 ], [ 0, %304 ], [ 0, %311 ], [ 0, %321 ]
%333 = phi i8* [ %143, %171 ], [ %143, %181 ], [ %143, %195 ], [ %143, %177 ], [ %143, %174 ], [ %143, %172 ], [ %143, %200 ], [ %143, %198 ], [ %143, %196 ], [ %223, %299 ], [ %309, %304 ], [ %319, %311 ], [ %329, %321 ]
%334 = load i8, i8* %144
%335 = icmp eq i8 %334, 92
br i1 %335, label %347, label %336
336: ; preds = %331
%337 = ptrtoint i8* %333 to i64
%338 = add i64 %128, %337
%339 = icmp ult i64 %338, 8192
br i1 %339, label %340, label %343
340: ; preds = %336
%341 = getelementptr inbounds i8, i8* %333, i64 1
store i8 %334, i8* %333
%342 = load i8, i8* %144
br label %343
343: ; preds = %336, %340
%344 = phi i8 [ %334, %336 ], [ %342, %340 ]
%345 = phi i8* [ %333, %336 ], [ %341, %340 ]
%346 = icmp eq i8 %344, 0
br i1 %346, label %353, label %347
347: ; preds = %166, %150, %157, %331, %140, %343
%348 = phi i32 [ 0, %343 ], [ 0, %140 ], [ %145, %331 ], [ %145, %166 ], [ 1, %150 ], [ 2, %157 ]
%349 = phi i8* [ %345, %343 ], [ %143, %140 ], [ %333, %331 ], [ %143, %166 ], [ %143, %150 ], [ %143, %157 ]
%350 = phi i32 [ %332, %343 ], [ %142, %140 ], [ %332, %331 ], [ %170, %166 ], [ %142, %150 ], [ %142, %157 ]
%351 = phi i8 [ 0, %343 ], [ 1, %140 ], [ %141, %331 ], [ 2, %166 ], [ 1, %150 ], [ 1, %157 ]
%352 = getelementptr inbounds i8, i8* %144, i64 1
br label %140
353: ; preds = %343
%354 = getelementptr i8, i8* %345, i64 -1
%355 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %6, i64 0, i32 1
%356 = load i32, i32* %355
%357 = sext i32 %356 to i64
%358 = getelementptr i8, i8* %2, i64 %357
%359 = ptrtoint i8* %354 to i64
%360 = sub i64 %359, %22
%361 = getelementptr inbounds i8, i8* %3, i64 %360
%362 = ptrtoint i8* %361 to i64
%363 = ptrtoint i8* %358 to i64
%364 = sub i64 %362, %363
%365 = icmp ult i64 %364, 8192
br i1 %365, label %366, label %500
366: ; preds = %353
%367 = icmp ult i8* %358, %3
br i1 %367, label %368, label %477
368: ; preds = %366
%369 = add i64 %9, %357
%370 = sub i64 %10, %369
%371 = icmp ult i64 %370, 32
br i1 %371, label %463, label %372
372: ; preds = %368
%373 = xor i64 %11, -1
%374 = add i64 %373, %12
%375 = sub i64 %374, %357
%376 = getelementptr i8, i8* %345, i64 %375
%377 = sub i64 %12, %11
%378 = getelementptr i8, i8* %2, i64 %377
%379 = icmp ult i8* %354, %378
%380 = icmp ult i8* %358, %376
%381 = and i1 %379, %380
br i1 %381, label %463, label %382
382: ; preds = %372
%383 = and i64 %370, -32
%384 = getelementptr i8, i8* %358, i64 %383
%385 = getelementptr i8, i8* %354, i64 %383
%386 = add i64 %383, -32
%387 = lshr exact i64 %386, 5
%388 = add nuw nsw i64 %387, 1
%389 = and i64 %388, 3
%390 = icmp ult i64 %386, 96
br i1 %390, label %442, label %391
391: ; preds = %382
%392 = and i64 %388, 1152921504606846972
br label %393
393: ; preds = %393, %391
%394 = phi i64 [ 0, %391 ], [ %439, %393 ]
%395 = phi i64 [ 0, %391 ], [ %440, %393 ]
%396 = getelementptr i8, i8* %358, i64 %394
%397 = getelementptr i8, i8* %354, i64 %394
%398 = bitcast i8* %396 to <16 x i8>*
%399 = load <16 x i8>, <16 x i8>* %398
%400 = getelementptr i8, i8* %396, i64 16
%401 = bitcast i8* %400 to <16 x i8>*
%402 = load <16 x i8>, <16 x i8>* %401
%403 = bitcast i8* %397 to <16 x i8>*
store <16 x i8> %399, <16 x i8>* %403
%404 = getelementptr i8, i8* %397, i64 16
%405 = bitcast i8* %404 to <16 x i8>*
store <16 x i8> %402, <16 x i8>* %405
%406 = or i64 %394, 32
%407 = getelementptr i8, i8* %358, i64 %406
%408 = getelementptr i8, i8* %354, i64 %406
%409 = bitcast i8* %407 to <16 x i8>*
%410 = load <16 x i8>, <16 x i8>* %409
%411 = getelementptr i8, i8* %407, i64 16
%412 = bitcast i8* %411 to <16 x i8>*
%413 = load <16 x i8>, <16 x i8>* %412
%414 = bitcast i8* %408 to <16 x i8>*
store <16 x i8> %410, <16 x i8>* %414
%415 = getelementptr i8, i8* %408, i64 16
%416 = bitcast i8* %415 to <16 x i8>*
store <16 x i8> %413, <16 x i8>* %416
%417 = or i64 %394, 64
%418 = getelementptr i8, i8* %358, i64 %417
%419 = getelementptr i8, i8* %354, i64 %417
%420 = bitcast i8* %418 to <16 x i8>*
%421 = load <16 x i8>, <16 x i8>* %420
%422 = getelementptr i8, i8* %418, i64 16
%423 = bitcast i8* %422 to <16 x i8>*
%424 = load <16 x i8>, <16 x i8>* %423
%425 = bitcast i8* %419 to <16 x i8>*
store <16 x i8> %421, <16 x i8>* %425
%426 = getelementptr i8, i8* %419, i64 16
%427 = bitcast i8* %426 to <16 x i8>*
store <16 x i8> %424, <16 x i8>* %427
%428 = or i64 %394, 96
%429 = getelementptr i8, i8* %358, i64 %428
%430 = getelementptr i8, i8* %354, i64 %428
%431 = bitcast i8* %429 to <16 x i8>*
%432 = load <16 x i8>, <16 x i8>* %431
%433 = getelementptr i8, i8* %429, i64 16
%434 = bitcast i8* %433 to <16 x i8>*
%435 = load <16 x i8>, <16 x i8>* %434
%436 = bitcast i8* %430 to <16 x i8>*
store <16 x i8> %432, <16 x i8>* %436
%437 = getelementptr i8, i8* %430, i64 16
%438 = bitcast i8* %437 to <16 x i8>*
store <16 x i8> %435, <16 x i8>* %438
%439 = add nuw i64 %394, 128
%440 = add i64 %395, 4
%441 = icmp eq i64 %440, %392
br i1 %441, label %442, label %393
442: ; preds = %393, %382
%443 = phi i64 [ 0, %382 ], [ %439, %393 ]
%444 = icmp eq i64 %389, 0
br i1 %444, label %461, label %445
445: ; preds = %442, %445
%446 = phi i64 [ %458, %445 ], [ %443, %442 ]
%447 = phi i64 [ %459, %445 ], [ 0, %442 ]
%448 = getelementptr i8, i8* %358, i64 %446
%449 = getelementptr i8, i8* %354, i64 %446
%450 = bitcast i8* %448 to <16 x i8>*
%451 = load <16 x i8>, <16 x i8>* %450
%452 = getelementptr i8, i8* %448, i64 16
%453 = bitcast i8* %452 to <16 x i8>*
%454 = load <16 x i8>, <16 x i8>* %453
%455 = bitcast i8* %449 to <16 x i8>*
store <16 x i8> %451, <16 x i8>* %455
%456 = getelementptr i8, i8* %449, i64 16
%457 = bitcast i8* %456 to <16 x i8>*
store <16 x i8> %454, <16 x i8>* %457
%458 = add nuw i64 %446, 32
%459 = add i64 %447, 1
%460 = icmp eq i64 %459, %389
br i1 %460, label %461, label %445
461: ; preds = %445, %442
%462 = icmp eq i64 %370, %383
br i1 %462, label %473, label %463
463: ; preds = %372, %368, %461
%464 = phi i8* [ %358, %372 ], [ %358, %368 ], [ %384, %461 ]
%465 = phi i8* [ %354, %372 ], [ %354, %368 ], [ %385, %461 ]
br label %466
466: ; preds = %463, %466
%467 = phi i8* [ %469, %466 ], [ %464, %463 ]
%468 = phi i8* [ %471, %466 ], [ %465, %463 ]
%469 = getelementptr inbounds i8, i8* %467, i64 1
%470 = load i8, i8* %467
%471 = getelementptr inbounds i8, i8* %468, i64 1
store i8 %470, i8* %468
%472 = icmp ult i8* %469, %3
br i1 %472, label %466, label %473
473: ; preds = %466, %461
%474 = phi i8* [ %385, %461 ], [ %471, %466 ]
%475 = ptrtoint i8* %474 to i64
%476 = sub i64 %475, %22
br label %477
477: ; preds = %473, %366
%478 = phi i64 [ %476, %473 ], [ %360, %366 ]
%479 = phi i8* [ %474, %473 ], [ %354, %366 ]
store i8* %479, i8** %1
%480 = tail call i32 @strlen(i8* %3)
%481 = sext i32 %480 to i64
%482 = add nsw i64 %478, %481
%483 = icmp ult i64 %482, 8192
br i1 %483, label %484, label %500
484: ; preds = %477
%485 = load i8, i8* %3
%486 = icmp eq i8 %485, 0
br i1 %486, label %495, label %487
487: ; preds = %484, %487
%488 = phi i8 [ %493, %487 ], [ %485, %484 ]
%489 = phi i8* [ %492, %487 ], [ %3, %484 ]
%490 = phi i8* [ %491, %487 ], [ %479, %484 ]
%491 = getelementptr inbounds i8, i8* %490, i64 1
store i8 %488, i8* %490
%492 = getelementptr inbounds i8, i8* %489, i64 1
%493 = load i8, i8* %492
%494 = icmp eq i8 %493, 0
br i1 %494, label %495, label %487
495: ; preds = %487, %484
%496 = phi i8* [ %479, %484 ], [ %491, %487 ]
%497 = getelementptr inbounds i8, i8* %496, i64 1
store i8 0, i8* %496
%498 = ptrtoint i8* %497 to i64
%499 = sub i64 %498, %22
br label %500
500: ; preds = %477, %353, %7, %495
%501 = phi i64 [ %499, %495 ], [ 0, %7 ], [ 0, %353 ], [ 0, %477 ]
ret i64 %501
}