#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ _ts_lcopy(unsigned char *, unsigned char *, char *);
int _ts_lmatch(unsigned char *, unsigned char *, unsigned char *);
unsigned long int ts_ip(int which, unsigned char *a, int len, char *host,
                        int *port) {
  unsigned char *rr, *srv_target[10], *buf = a;
  unsigned short int i;
  unsigned long int l;
  int srv = 0, srvs = 0, aflag = 0;
  short int srv_port[10], srv_pri[10], srv_weight[10];
  buf += 12;
  for (; *buf != 0 && !(*buf & 0xc0 && buf++); buf += *buf + 1)
    if ((buf + *buf + 1) > (a + len))
      return 0;
  buf++;
  ;
  if ((buf + 2) - a > len)
    return 0;
  ;
  ((char *)&i)[0] = *buf++;
  ((char *)&i)[1] = *buf++;
  ;
  if (i == 1)
    aflag = 1;
  if ((buf + 2) - a > len)
    return 0;
  ;
  ((char *)&i)[0] = *buf++;
  ((char *)&i)[1] = *buf++;
  ;
  while (buf < (a + len)) {
    rr = buf;
    for (; *buf != 0 && !(*buf & 0xc0 && buf++); buf += *buf + 1)
      if ((buf + *buf + 1) > (a + len))
        return 0;
    buf++;
    ;
    if ((buf + 2) - a > len)
      return 0;
    ;
    ((char *)&i)[0] = *buf++;
    ((char *)&i)[1] = *buf++;
    ;
    if (i != 33)
      break;
    if ((buf + 2) - a > len)
      return 0;
    ;
    ((char *)&i)[0] = *buf++;
    ((char *)&i)[1] = *buf++;
    ;
    if (i != 1)
      break;
    if ((buf + 4) - a > len)
      return 0;
    ;
    ((char *)&l)[0] = *buf++;
    ((char *)&l)[1] = *buf++;
    ((char *)&l)[2] = *buf++;
    ((char *)&l)[3] = *buf++;
    ;
    if ((buf + 2) - a > len)
      return 0;
    ;
    ((char *)&i)[0] = *buf++;
    ((char *)&i)[1] = *buf++;
    ;
    if ((buf + i) - a > len)
      return 0;
    ;
    if ((buf + 2) - a > len)
      return 0;
    ;
    ((char *)&i)[0] = *buf++;
    ((char *)&i)[1] = *buf++;
    ;
    srv_pri[srvs] = i;
    if ((buf + 2) - a > len)
      return 0;
    ;
    ((char *)&i)[0] = *buf++;
    ((char *)&i)[1] = *buf++;
    ;
    srv_weight[srvs] = i;
    if ((buf + 2) - a > len)
      return 0;
    ;
    ((char *)&i)[0] = *buf++;
    ((char *)&i)[1] = *buf++;
    ;
    srv_port[srvs] = i;
    srv_target[srvs] = buf;
    for (; *buf != 0 && !(*buf & 0xc0 && buf++); buf += *buf + 1)
      if ((buf + *buf + 1) > (a + len))
        return 0;
    buf++;
    ;
    srvs++;
    if (srvs == 10)
      break;
  }
  if (!aflag && (srvs == 0 || which >= srvs))
    return 0;
  buf = rr;
  while (srvs > 1) {
    int cur;
    for (cur = 0; cur < srvs; cur++) {
      if (srv_pri[srv] > srv_pri[cur] ||
          (srv_pri[srv] == srv_pri[cur] && srv_weight[srv] > srv_weight[cur]))
        continue;
      srv = cur;
    }
    if (which == 0)
      break;
    srv_pri[srv] = srv_weight[srv] = -1;
    which--;
  }
  if (!aflag)
    *port = srv_port[srv];
  while (buf < (a + len)) {
    int match = 0;
    rr = buf;
    for (; *buf != 0 && !(*buf & 0xc0 && buf++); buf += *buf + 1)
      if ((buf + *buf + 1) > (a + len))
        return 0;
    buf++;
    ;
    if (aflag)
      match = (which-- == 0) ? 1 : 0;
    else
      match = _ts_lmatch(a, srv_target[srv], rr);
    if ((buf + 2) - a > len)
      return 0;
    ;
    ((char *)&i)[0] = *buf++;
    ((char *)&i)[1] = *buf++;
    ;
    if (i == 5 && match == 1) {
      if ((buf + 2) - a > len)
        return 0;
      ;
      ((char *)&i)[0] = *buf++;
      ((char *)&i)[1] = *buf++;
      ;
      if ((buf + 4) - a > len)
        return 0;
      ;
      ((char *)&l)[0] = *buf++;
      ((char *)&l)[1] = *buf++;
      ((char *)&l)[2] = *buf++;
      ((char *)&l)[3] = *buf++;
      ;
      if ((buf + 2) - a > len)
        return 0;
      ;
      ((char *)&i)[0] = *buf++;
      ((char *)&i)[1] = *buf++;
      ;
      if ((buf + i) - a > len)
        return 0;
      ;
      _ts_lcopy(a, buf, host);
      return 0;
    }
    if (i != 1)
      match = 0;
    if ((buf + 2) - a > len)
      return 0;
    ;
    ((char *)&i)[0] = *buf++;
    ((char *)&i)[1] = *buf++;
    ;
    if (i != 1)
      match = 0;
    if ((buf + 4) - a > len)
      return 0;
    ;
    ((char *)&l)[0] = *buf++;
    ((char *)&l)[1] = *buf++;
    ((char *)&l)[2] = *buf++;
    ((char *)&l)[3] = *buf++;
    ;
    if ((buf + 2) - a > len)
      return 0;
    ;
    ((char *)&i)[0] = *buf++;
    ((char *)&i)[1] = *buf++;
    ;
    if ((buf + i) - a > len)
      return 0;
    ;
    if (match) {
      if ((buf + 4) - a > len)
        return 0;
      ;
      ((char *)&l)[0] = *buf++;
      ((char *)&l)[1] = *buf++;
      ((char *)&l)[2] = *buf++;
      ((char *)&l)[3] = *buf++;
      return l;
    }
    buf += i;
  }
  _ts_lcopy(a, srv_target[srv], host);
  return 0;
}


x86 assembly (clang, -O0):
<ts_ip>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    %edi,-0xc(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x98(%rbp)
movl   $0x0,-0xac(%rbp)
movl   $0x0,-0xb0(%rbp)
movl   $0x0,-0xb4(%rbp)
mov    -0x98(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
movzbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x119(%rbp)
je     11e4 <ts_ip+0xc4>
mov    -0x98(%rbp),%rax
movzbl (%rax),%ecx
and    $0xc0,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11a(%rbp)
je     11d6 <ts_ip+0xb6>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
cmp    $0x0,%rax
setne  %al
mov    %al,-0x11a(%rbp)
mov    -0x11a(%rbp),%al
xor    $0xff,%al
mov    %al,-0x119(%rbp)
mov    -0x119(%rbp),%al
test   $0x1,%al
jne    11f7 <ts_ip+0xd7>
jmp    125e <ts_ip+0x13e>
mov    -0x98(%rbp),%rax
mov    -0x98(%rbp),%rcx
movzbl (%rcx),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
add    $0x1,%rax
mov    -0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jbe    1233 <ts_ip+0x113>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
jmp    1238 <ts_ip+0x118>
mov    -0x98(%rbp),%rax
movzbl (%rax),%ecx
add    $0x1,%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
jmp    1178 <ts_ip+0x58>
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    129c <ts_ip+0x17c>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x9a(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x99(%rbp)
movzwl -0x9a(%rbp),%eax
cmp    $0x1,%eax
jne    12f0 <ts_ip+0x1d0>
movl   $0x1,-0xb4(%rbp)
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    131c <ts_ip+0x1fc>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x9a(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x99(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    194d <ts_ip+0x82d>
mov    -0x98(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x98(%rbp),%rax
movzbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11b(%rbp)
je     13e8 <ts_ip+0x2c8>
mov    -0x98(%rbp),%rax
movzbl (%rax),%ecx
and    $0xc0,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11c(%rbp)
je     13da <ts_ip+0x2ba>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
cmp    $0x0,%rax
setne  %al
mov    %al,-0x11c(%rbp)
mov    -0x11c(%rbp),%al
xor    $0xff,%al
mov    %al,-0x11b(%rbp)
mov    -0x11b(%rbp),%al
test   $0x1,%al
jne    13fb <ts_ip+0x2db>
jmp    1462 <ts_ip+0x342>
mov    -0x98(%rbp),%rax
mov    -0x98(%rbp),%rcx
movzbl (%rcx),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
add    $0x1,%rax
mov    -0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jbe    1437 <ts_ip+0x317>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
jmp    143c <ts_ip+0x31c>
mov    -0x98(%rbp),%rax
movzbl (%rax),%ecx
add    $0x1,%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
jmp    137c <ts_ip+0x25c>
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    14a0 <ts_ip+0x380>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x9a(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x99(%rbp)
movzwl -0x9a(%rbp),%eax
cmp    $0x21,%eax
je     14ef <ts_ip+0x3cf>
jmp    194d <ts_ip+0x82d>
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    151b <ts_ip+0x3fb>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x9a(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x99(%rbp)
movzwl -0x9a(%rbp),%eax
cmp    $0x1,%eax
je     156a <ts_ip+0x44a>
jmp    194d <ts_ip+0x82d>
mov    -0x98(%rbp),%rax
add    $0x4,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    1596 <ts_ip+0x476>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa8(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa7(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa6(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa5(%rbp)
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    1636 <ts_ip+0x516>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x9a(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x99(%rbp)
mov    -0x98(%rbp),%rax
movzwl -0x9a(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    16a5 <ts_ip+0x585>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    16d1 <ts_ip+0x5b1>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x9a(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x99(%rbp)
mov    -0x9a(%rbp),%cx
movslq -0xb0(%rbp),%rax
mov    %cx,-0xf0(%rbp,%rax,2)
ff
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    174d <ts_ip+0x62d>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x9a(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x99(%rbp)
mov    -0x9a(%rbp),%cx
movslq -0xb0(%rbp),%rax
mov    %cx,-0x110(%rbp,%rax,2)
ff
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    17c9 <ts_ip+0x6a9>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x9a(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x99(%rbp)
mov    -0x9a(%rbp),%cx
movslq -0xb0(%rbp),%rax
mov    %cx,-0xd0(%rbp,%rax,2)
ff
mov    -0x98(%rbp),%rcx
movslq -0xb0(%rbp),%rax
mov    %rcx,-0x90(%rbp,%rax,8)
ff
mov    -0x98(%rbp),%rax
movzbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11d(%rbp)
je     189b <ts_ip+0x77b>
mov    -0x98(%rbp),%rax
movzbl (%rax),%ecx
and    $0xc0,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11e(%rbp)
je     188d <ts_ip+0x76d>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
cmp    $0x0,%rax
setne  %al
mov    %al,-0x11e(%rbp)
mov    -0x11e(%rbp),%al
xor    $0xff,%al
mov    %al,-0x11d(%rbp)
mov    -0x11d(%rbp),%al
test   $0x1,%al
jne    18ae <ts_ip+0x78e>
jmp    1915 <ts_ip+0x7f5>
mov    -0x98(%rbp),%rax
mov    -0x98(%rbp),%rcx
movzbl (%rcx),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
add    $0x1,%rax
mov    -0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jbe    18ea <ts_ip+0x7ca>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
jmp    18ef <ts_ip+0x7cf>
mov    -0x98(%rbp),%rax
movzbl (%rax),%ecx
add    $0x1,%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
jmp    182f <ts_ip+0x70f>
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
cmpl   $0xa,-0xb0(%rbp)
jne    1948 <ts_ip+0x828>
jmp    194d <ts_ip+0x82d>
jmp    1356 <ts_ip+0x236>
cmpl   $0x0,-0xb4(%rbp)
jne    1983 <ts_ip+0x863>
cmpl   $0x0,-0xb0(%rbp)
je     1976 <ts_ip+0x856>
mov    -0xc(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jl     1983 <ts_ip+0x863>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x38(%rbp),%rax
mov    %rax,-0x98(%rbp)
cmpl   $0x1,-0xb0(%rbp)
jle    1a8d <ts_ip+0x96d>
movl   $0x0,-0x114(%rbp)
mov    -0x114(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    1a4e <ts_ip+0x92e>
movslq -0xac(%rbp),%rax
movswl -0xf0(%rbp,%rax,2),%eax
ff
movslq -0x114(%rbp),%rcx
movswl -0xf0(%rbp,%rcx,2),%ecx
ff
cmp    %ecx,%eax
jg     1a29 <ts_ip+0x909>
movslq -0xac(%rbp),%rax
movswl -0xf0(%rbp,%rax,2),%eax
ff
movslq -0x114(%rbp),%rcx
movswl -0xf0(%rbp,%rcx,2),%ecx
ff
cmp    %ecx,%eax
jne    1a2e <ts_ip+0x90e>
movslq -0xac(%rbp),%rax
movswl -0x110(%rbp,%rax,2),%eax
ff
movslq -0x114(%rbp),%rcx
movswl -0x110(%rbp,%rcx,2),%ecx
ff
cmp    %ecx,%eax
jle    1a2e <ts_ip+0x90e>
jmp    1a3a <ts_ip+0x91a>
mov    -0x114(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    19a5 <ts_ip+0x885>
cmpl   $0x0,-0xc(%rbp)
jne    1a5d <ts_ip+0x93d>
jmp    1a8d <ts_ip+0x96d>
movslq -0xac(%rbp),%rax
movw   $0xffff,-0x110(%rbp,%rax,2)
ff ff ff
movslq -0xac(%rbp),%rax
movw   $0xffff,-0xf0(%rbp,%rax,2)
ff ff ff
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    198e <ts_ip+0x86e>
cmpl   $0x0,-0xb4(%rbp)
jne    1aaf <ts_ip+0x98f>
movslq -0xac(%rbp),%rax
movswl -0xd0(%rbp,%rax,2),%ecx
ff
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
jmp    1ab4 <ts_ip+0x994>
mov    -0x98(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    2125 <ts_ip+0x1005>
movl   $0x0,-0x118(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x98(%rbp),%rax
movzbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11f(%rbp)
je     1b50 <ts_ip+0xa30>
mov    -0x98(%rbp),%rax
movzbl (%rax),%ecx
and    $0xc0,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x120(%rbp)
je     1b42 <ts_ip+0xa22>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
cmp    $0x0,%rax
setne  %al
mov    %al,-0x120(%rbp)
mov    -0x120(%rbp),%al
xor    $0xff,%al
mov    %al,-0x11f(%rbp)
mov    -0x11f(%rbp),%al
test   $0x1,%al
jne    1b63 <ts_ip+0xa43>
jmp    1bca <ts_ip+0xaaa>
mov    -0x98(%rbp),%rax
mov    -0x98(%rbp),%rcx
movzbl (%rcx),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
add    $0x1,%rax
mov    -0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jbe    1b9f <ts_ip+0xa7f>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
jmp    1ba4 <ts_ip+0xa84>
mov    -0x98(%rbp),%rax
movzbl (%rax),%ecx
add    $0x1,%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
jmp    1ae4 <ts_ip+0x9c4>
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
cmpl   $0x0,-0xb4(%rbp)
je     1c0c <ts_ip+0xaec>
mov    -0xc(%rbp),%edx
mov    %edx,%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmove  %ecx,%eax
mov    %eax,-0x118(%rbp)
jmp    1c2e <ts_ip+0xb0e>
mov    -0x18(%rbp),%rdi
movslq -0xac(%rbp),%rax
mov    -0x90(%rbp,%rax,8),%rsi
ff
mov    -0x38(%rbp),%rdx
call   1040 <_ts_lmatch@plt>
mov    %eax,-0x118(%rbp)
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    1c5a <ts_ip+0xb3a>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x9a(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x99(%rbp)
movzwl -0x9a(%rbp),%eax
cmp    $0x5,%eax
jne    1e73 <ts_ip+0xd53>
cmpl   $0x1,-0x118(%rbp)
jne    1e73 <ts_ip+0xd53>
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    1cdd <ts_ip+0xbbd>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x9a(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x99(%rbp)
mov    -0x98(%rbp),%rax
add    $0x4,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    1d43 <ts_ip+0xc23>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa8(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa7(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa6(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa5(%rbp)
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    1de3 <ts_ip+0xcc3>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x9a(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x99(%rbp)
mov    -0x98(%rbp),%rax
movzwl -0x9a(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    1e52 <ts_ip+0xd32>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x18(%rbp),%rdi
mov    -0x98(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   1030 <_ts_lcopy@plt>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
movzwl -0x9a(%rbp),%eax
cmp    $0x1,%eax
je     1e8d <ts_ip+0xd6d>
movl   $0x0,-0x118(%rbp)
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    1eb9 <ts_ip+0xd99>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x9a(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x99(%rbp)
movzwl -0x9a(%rbp),%eax
cmp    $0x1,%eax
je     1f0d <ts_ip+0xded>
movl   $0x0,-0x118(%rbp)
mov    -0x98(%rbp),%rax
add    $0x4,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    1f39 <ts_ip+0xe19>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa8(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa7(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa6(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa5(%rbp)
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    1fd9 <ts_ip+0xeb9>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x9a(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0x99(%rbp)
mov    -0x98(%rbp),%rax
movzwl -0x9a(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    2048 <ts_ip+0xf28>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
cmpl   $0x0,-0x118(%rbp)
je     2105 <ts_ip+0xfe5>
mov    -0x98(%rbp),%rax
add    $0x4,%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jle    2081 <ts_ip+0xf61>
movq   $0x0,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa8(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa7(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa6(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rax),%al
mov    %al,-0xa5(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    2149 <ts_ip+0x1029>
movzwl -0x9a(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
jmp    1ab4 <ts_ip+0x994>
mov    -0x18(%rbp),%rdi
movslq -0xac(%rbp),%rax
mov    -0x90(%rbp,%rax,8),%rsi
ff
mov    -0x28(%rbp),%rdx
call   1030 <_ts_lcopy@plt>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ts_ip>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %rsi,%r15
mov    %edi,%r12d
lea    0xc(%rsi),%rax
mov    0xc(%rsi),%bl
movslq %edx,%r11
test   %bl,%bl
je     1183 <ts_ip+0x63>
lea    (%r15,%r11,1),%rdi
xor    %r13d,%r13d
nopl   0x0(%rax)
lea    0x1(%rax),%rdx
cmp    $0x40,%bl
cmovae %rdx,%rax
jae    1186 <ts_ip+0x66>
movzbl (%rax),%esi
lea    (%rax,%rsi,1),%rdx
add    $0x1,%rdx
cmp    %rdi,%rdx
ja     11aa <ts_ip+0x8a>
lea    (%rsi,%rax,1),%rdx
add    $0x1,%rdx
movzbl 0x1(%rsi,%rax,1),%ebx
mov    %rdx,%rax
test   %bl,%bl
jne    1150 <ts_ip+0x30>
jmp    1186 <ts_ip+0x66>
mov    %rax,%rdx
mov    %rdx,%rax
sub    %r15,%rax
add    $0x3,%rax
cmp    %r11,%rax
jg     11a7 <ts_ip+0x87>
lea    0x5(%rdx),%rdi
mov    %rdi,%rax
sub    %r15,%rax
xor    %r9d,%r9d
cmp    %r11,%rax
jle    11bf <ts_ip+0x9f>
xor    %r13d,%r13d
mov    %r13,%rax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movzwl 0x1(%rdx),%r10d
lea    (%r15,%r11,1),%rax
mov    %rax,0x8(%rsp)
cmp    %rax,%rdi
jae    135e <ts_ip+0x23e>
xor    %r9d,%r9d
mov    %rdi,%rdx
mov    (%rdi),%bl
mov    %rdi,%rbp
test   %bl,%bl
je     1223 <ts_ip+0x103>
mov    %rdx,%rsi
nopl   0x0(%rax,%rax,1)
lea    0x1(%rsi),%rbp
cmp    $0x40,%bl
cmovae %rbp,%rsi
jae    1223 <ts_ip+0x103>
movzbl (%rsi),%eax
lea    (%rsi,%rax,1),%rdi
add    $0x1,%rdi
cmp    0x8(%rsp),%rdi
ja     11a7 <ts_ip+0x87>
lea    (%rax,%rsi,1),%rbp
add    $0x1,%rbp
movzbl 0x1(%rax,%rsi,1),%ebx
mov    %rbp,%rsi
test   %bl,%bl
jne    11f0 <ts_ip+0xd0>
mov    %rbp,%rsi
sub    %r15,%rsi
lea    0x3(%rsi),%rax
cmp    %r11,%rax
jg     11a7 <ts_ip+0x87>
cmpw   $0x21,0x1(%rbp)
jne    135e <ts_ip+0x23e>
lea    0x5(%rsi),%rax
cmp    %r11,%rax
jg     11a7 <ts_ip+0x87>
cmpw   $0x1,0x3(%rbp)
jne    135e <ts_ip+0x23e>
lea    0x9(%rsi),%rax
cmp    %r11,%rax
jg     11a7 <ts_ip+0x87>
lea    0xb(%rbp),%rdi
mov    %rdi,%rax
sub    %r15,%rax
mov    $0x0,%r13d
cmp    %r11,%rax
jg     11aa <ts_ip+0x8a>
movzwl 0x9(%rbp),%eax
add    %rax,%rdi
sub    %r15,%rdi
cmp    %r11,%rdi
jg     11a7 <ts_ip+0x87>
lea    0xd(%rsi),%rax
mov    $0x0,%r13d
cmp    %r11,%rax
jg     11aa <ts_ip+0x8a>
movzwl 0xb(%rbp),%eax
mov    %ax,0x30(%rsp,%r9,2)
add    $0xf,%rsi
cmp    %r11,%rsi
jg     11a7 <ts_ip+0x87>
movzwl 0xd(%rbp),%eax
mov    %ax,0x10(%rsp,%r9,2)
lea    0x11(%rbp),%rsi
mov    %rsi,%rax
sub    %r15,%rax
cmp    %r11,%rax
jg     11a7 <ts_ip+0x87>
movzwl 0xf(%rbp),%eax
mov    %ax,0x60(%rsp,%r9,2)
mov    %rsi,0x80(%rsp,%r9,8)
mov    0x11(%rbp),%bl
test   %bl,%bl
je     1337 <ts_ip+0x217>
mov    0x8(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
lea    0x1(%rsi),%rdi
cmp    $0x40,%bl
cmovae %rdi,%rsi
jae    133f <ts_ip+0x21f>
movzbl (%rsi),%eax
lea    (%rsi,%rax,1),%rdi
add    $0x1,%rdi
cmp    %rbp,%rdi
ja     11a7 <ts_ip+0x87>
lea    (%rax,%rsi,1),%rdi
add    $0x1,%rdi
movzbl 0x1(%rax,%rsi,1),%ebx
mov    %rdi,%rsi
test   %bl,%bl
jne    1300 <ts_ip+0x1e0>
jmp    133f <ts_ip+0x21f>
mov    %rsi,%rdi
mov    0x8(%rsp),%rbp
add    $0x1,%r9
cmp    $0xa,%r9
je     1358 <ts_ip+0x238>
add    $0x1,%rdi
cmp    %rbp,%rdi
jb     11d9 <ts_ip+0xb9>
jmp    135e <ts_ip+0x23e>
mov    $0xa,%r9d
cmp    $0x1,%r10d
je     1379 <ts_ip+0x259>
xor    %r13d,%r13d
test   %r9d,%r9d
je     11aa <ts_ip+0x8a>
cmp    %r12d,%r9d
jle    11aa <ts_ip+0x8a>
xor    %ebp,%ebp
cmp    $0x2,%r9d
mov    %rcx,0x50(%rsp)
jb     1440 <ts_ip+0x320>
mov    %r10d,%r14d
mov    %r9d,%r10d
mov    %r10d,%edi
and    $0xfffffffe,%edi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
xor    %ebx,%ebx
cmp    $0x1,%r9d
jne    13fc <ts_ip+0x2dc>
test   $0x1,%r10b
je     13d0 <ts_ip+0x2b0>
movslq %ebp,%rax
movzwl 0x30(%rsp,%rbx,2),%esi
cmp    %si,0x30(%rsp,%rax,2)
jg     13d0 <ts_ip+0x2b0>
jne    13cb <ts_ip+0x2ab>
movzwl 0x10(%rsp,%rax,2),%eax
cmp    0x10(%rsp,%rbx,2),%ax
jg     13d0 <ts_ip+0x2b0>
mov    %ebx,%ebp
nopl   (%rax)
sub    $0x1,%r12d
jb     143a <ts_ip+0x31a>
movslq %ebp,%rax
movw   $0xffff,0x10(%rsp,%rax,2)
movw   $0xffff,0x30(%rsp,%rax,2)
jmp    13a0 <ts_ip+0x280>
nopl   0x0(%rax)
lea    0x1(%rbx),%ebp
add    $0x2,%rbx
cmp    %rbx,%rdi
je     13a8 <ts_ip+0x288>
movslq %ebp,%rax
movzwl 0x30(%rsp,%rbx,2),%esi
cmp    %si,0x30(%rsp,%rax,2)
jg     141b <ts_ip+0x2fb>
jne    1419 <ts_ip+0x2f9>
movzwl 0x10(%rsp,%rax,2),%eax
cmp    0x10(%rsp,%rbx,2),%ax
jg     141b <ts_ip+0x2fb>
mov    %ebx,%ebp
movslq %ebp,%rax
movzwl 0x32(%rsp,%rbx,2),%esi
cmp    %si,0x30(%rsp,%rax,2)
jg     13f3 <ts_ip+0x2d3>
jne    13f0 <ts_ip+0x2d0>
movzwl 0x10(%rsp,%rax,2),%eax
cmp    0x12(%rsp,%rbx,2),%ax
jle    13f0 <ts_ip+0x2d0>
jmp    13f3 <ts_ip+0x2d3>
xor    %r12d,%r12d
mov    %r14d,%r10d
movslq %ebp,%r9
cmp    $0x1,%r10d
je     1452 <ts_ip+0x332>
movswl 0x60(%rsp,%r9,2),%eax
mov    %eax,(%r8)
xor    %r13d,%r13d
mov    0x8(%rsp),%rdi
cmp    %rdi,%rdx
jae    157e <ts_ip+0x45e>
mov    (%rdx),%cl
mov    %rdx,%r14
test   %cl,%cl
je     14a5 <ts_ip+0x385>
mov    %rdx,%rax
nop
lea    0x1(%rax),%r14
cmp    $0x40,%cl
cmovae %r14,%rax
jae    14a5 <ts_ip+0x385>
movzbl (%rax),%ecx
lea    (%rax,%rcx,1),%rsi
add    $0x1,%rsi
cmp    %rdi,%rsi
ja     11aa <ts_ip+0x8a>
lea    (%rcx,%rax,1),%r14
add    $0x1,%r14
movzbl 0x1(%rcx,%rax,1),%ecx
mov    %r14,%rax
test   %cl,%cl
jne    1470 <ts_ip+0x350>
cmp    $0x1,%r10d
jne    14b6 <ts_ip+0x396>
xor    %eax,%eax
sub    $0x1,%r12d
setb   %al
jmp    14e1 <ts_ip+0x3c1>
mov    0x80(%rsp,%r9,8),%rsi
mov    %r15,%rdi
mov    %r11,0x58(%rsp)
mov    %r10d,%ebp
mov    %r9,%rbx
call   1040 <_ts_lmatch@plt>
mov    %rbx,%r9
mov    %ebp,%r10d
mov    0x8(%rsp),%rdi
mov    0x58(%rsp),%r11
mov    %r14,%rcx
sub    %r15,%rcx
lea    0x3(%rcx),%rdx
cmp    %r11,%rdx
jg     11aa <ts_ip+0x8a>
movzwl 0x1(%r14),%edx
lea    0x5(%rcx),%rsi
cmp    $0x5,%edx
jne    150b <ts_ip+0x3eb>
cmp    $0x1,%eax
je     1598 <ts_ip+0x478>
cmp    %r11,%rsi
jg     11aa <ts_ip+0x8a>
xor    $0x1,%edx
movzwl 0x3(%r14),%esi
xor    $0x1,%esi
or     %edx,%esi
setne  %bl
lea    0x9(%rcx),%rdx
cmp    %r11,%rdx
jg     11aa <ts_ip+0x8a>
lea    0xb(%r14),%rdx
mov    %rdx,%rsi
sub    %r15,%rsi
cmp    %r11,%rsi
jg     11aa <ts_ip+0x8a>
movzwl 0x9(%r14),%esi
add    %rsi,%rdx
mov    %rdx,%rsi
sub    %r15,%rsi
cmp    %r11,%rsi
jg     11aa <ts_ip+0x8a>
test   %eax,%eax
sete   %al
or     %al,%bl
jne    145a <ts_ip+0x33a>
add    $0xf,%rcx
cmp    %r11,%rcx
jg     11a7 <ts_ip+0x87>
mov    0xb(%r14),%r13d
jmp    11aa <ts_ip+0x8a>
mov    0x80(%rsp,%r9,8),%rsi
mov    %r15,%rdi
mov    0x50(%rsp),%rdx
call   1030 <_ts_lcopy@plt>
jmp    11a7 <ts_ip+0x87>
cmp    %r11,%rsi
jg     11a7 <ts_ip+0x87>
add    $0x9,%rcx
cmp    %r11,%rcx
jg     11a7 <ts_ip+0x87>
lea    0xb(%r14),%rsi
mov    %rsi,%rax
sub    %r15,%rax
cmp    %r11,%rax
jg     11a7 <ts_ip+0x87>
movzwl 0x9(%r14),%eax
add    %rsi,%rax
sub    %r15,%rax
cmp    %r11,%rax
jg     11a7 <ts_ip+0x87>
jmp    1586 <ts_ip+0x466>

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

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