#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*/ basm_print(char *, ...);
int BASM_XCallGenRepackSigSysV(char *sig) {
  static char *gregs[6] = {"rdi", "rsi", "rdx", "rcx", "r8", "r9"};
  static char *xregs[8] = {"xmm0", "xmm1", "xmm2", "xmm3",
                           "xmm4", "xmm5", "xmm6", "xmm7"};
  char *s;
  int i, j, ni, nx, ns;
  s = sig;
  i = 0;
  j = 0;
  ni = 0;
  nx = 0;
  ns = 0;
  if (*s == '(')
    s++;
  while (*s && (*s != ')')) {
    switch (*s++) {
    case 'a':
    case 'b':
    case 'c':
    case 'h':
    case 's':
    case 't':
    case 'w':
    case 'i':
    case 'j':
      if (ni < 6) {
        basm_print("mov %s, [rbp+%d]\n", gregs[ni], (i + 2) * 8);
        i++;
        ni++;
        break;
      }
      basm_print("mov eax, [rbp+%d]\n", (i + 2) * 8);
      basm_print("mov [rsp+%d], eax\n", ns * 8);
      i++;
      ns++;
      break;
    case 'l':
    case 'm':
    case 'x':
    case 'y':
      if (ni < 6) {
        basm_print("mov %s, [rbp+%d]\n", gregs[ni], (i + 2) * 8);
        i++;
        ni++;
        break;
      }
      basm_print("mov rax, [rbp+%d]\n", (i + 2) * 8);
      basm_print("mov [rsp+%d], rax\n", ns * 8);
      i++;
      ns++;
      break;
    case 'r':
      if (ni < 6) {
        basm_print("mov %s, [rbp+%d]\n", gregs[ni], (i + 2) * 8);
        i++;
        ni++;
        break;
      }
      basm_print("mov rax, [rbp+%d]\n", (i + 2) * 8);
      basm_print("mov [rsp+%d], rax\n", ns * 8);
      i++;
      ns++;
      break;
    case 'P':
      if (ni < 6) {
        basm_print("mov %s, [rbp+%d]\n", gregs[ni], (i + 2) * 8);
        i++;
        ni++;
      } else {
        basm_print("mov rax, [rbp+%d]\n", (i + 2) * 8);
        basm_print("mov [rsp+%d], rax\n", ns * 8);
        i++;
        ns++;
      }
      while (*s == 'P')
        s++;
      if ((*s >= 'a') && (*s <= 'z')) {
        s++;
        break;
      }
      if (*s == 'X') {
        while (*s && *s != ';')
          s++;
        if (*s == ';')
          s++;
      }
      break;
    case 'Q':
      if (ni < 6) {
        basm_print("mov %s, [rbp+%d]\n", gregs[ni], (i + 2) * 8);
        i++;
        ni++;
      } else {
        basm_print("mov rax, [rbp+%d]\n", (i + 2) * 8);
        basm_print("mov [rsp+%d], rax\n", ns * 8);
        i++;
        ns++;
      }
      while (*s == 'Q')
        s++;
      if ((*s >= 'a') && (*s <= 'z')) {
        s++;
        break;
      }
      if (*s == 'L') {
        while (*s && *s != ';')
          s++;
        if (*s == ';')
          s++;
      }
      break;
    case 'L':
      if (ni < 6) {
        basm_print("mov %s, [rbp+%d]\n", gregs[ni], (i + 2) * 8);
        i++;
        ni++;
      } else {
        basm_print("mov rax, [rbp+%d]\n", (i + 2) * 8);
        basm_print("mov [rsp+%d], rax\n", ns * 8);
        i++;
        ns++;
      }
      while (*s && *s != ';')
        s++;
      if (*s == ';')
        s++;
      break;
    case 'd':
      if (nx < 8) {
        basm_print("movsd %s, [rbp+%d]\n", xregs[nx], (i + 2) * 8);
        i++;
        nx++;
        break;
      }
      basm_print("movsd xmm8, [rbp+%d]\n", (i + 2) * 8);
      basm_print("movsd [rsp+%d], xmm8\n", ns * 8);
      i++;
      ns++;
      break;
    case 'e':
      if (nx < 8) {
        if (i & 1)
          i++;
        basm_print("movdqa %s, [rbp+%d]\n", xregs[nx], (i + 2) * 8);
        i += 2;
        nx++;
        break;
      }
      if (i & 1)
        i++;
      if (ns & 1)
        ns++;
      basm_print("movdqa xmm8, [rbp+%d]\n", (i + 2) * 8);
      basm_print("movdqa [rsp+%d], xmm8\n", ns * 8);
      i += 2;
      ns += 2;
      break;
    case 'f':
    case 'k':
      if (nx < 8) {
        basm_print("movss %s, [rbp+%d]\n", xregs[nx], (i + 2) * 8);
        i++;
        nx++;
        break;
      }
      basm_print("movss xmm8, [rbp+%d]\n", (i + 2) * 8);
      basm_print("movss [rsp+%d], xmm8\n", ns * 8);
      i++;
      ns++;
      break;
    case 'g':
    case 'n':
    case 'o':
      if (nx < 8) {
        if (i & 1)
          i++;
        basm_print("movdqa %s, [rbp+%d]\n", xregs[nx], (i + 2) * 8);
        i += 2;
        nx++;
        break;
      }
      if (i & 1)
        i++;
      if (ns & 1)
        ns++;
      basm_print("movdqa xmm8, [rbp+%d]\n", (i + 2) * 8);
      basm_print("movdqa [rsp+%d], xmm8\n", ns * 8);
      i += 2;
      ns += 2;
      break;
    case 'C':
      switch (*s++) {
      case 'f':
        i += 8;
        break;
      case 'd':
        i += 16;
        break;
      case 'e':
        i += 32;
        break;
      case 'g':
        i += 32;
        break;
      case 'k':
        i += 4;
        break;
      }
      break;
    case 'G':
      switch (*s++) {
      case 'f':
        i += 4;
        break;
      case 'd':
        i += 8;
        break;
      case 'e':
        i += 12;
        break;
      case 'g':
        i += 16;
        break;
      case 'k':
        i += 4;
        break;
      }
      break;
    default:
      break;
    }
  }
  if (*s && *s == ')')
    s++;
  return (i);
}


x86 assembly (clang, -O0):
<BASM_XCallGenRepackSigSysV>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x28,%eax
jne    1163 <BASM_XCallGenRepackSigSysV+0x53>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1168 <BASM_XCallGenRepackSigSysV+0x58>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x25(%rbp)
je     118d <BASM_XCallGenRepackSigSysV+0x7d>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x29,%eax
setne  %al
mov    %al,-0x25(%rbp)
mov    -0x25(%rbp),%al
test   $0x1,%al
jne    119d <BASM_XCallGenRepackSigSysV+0x8d>
jmp    1ad2 <BASM_XCallGenRepackSigSysV+0x9c2>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%eax
add    $0xffffffbd,%eax
mov    %eax,%ecx
mov    %rcx,-0x30(%rbp)
sub    $0x36,%eax
ja     1ac8 <BASM_XCallGenRepackSigSysV+0x9b8>
mov    -0x30(%rbp),%rax
lea    0xe34(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
cmpl   $0x6,-0x1c(%rbp)
jge    121c <BASM_XCallGenRepackSigSysV+0x10c>
movslq -0x1c(%rbp),%rcx
lea    0x2e46(%rip),%rax
mov    (%rax,%rcx,8),%rsi
mov    -0x14(%rbp),%edx
add    $0x2,%edx
shl    $0x3,%edx
lea    0xf5c(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
mov    -0x14(%rbp),%esi
add    $0x2,%esi
shl    $0x3,%esi
lea    0xf40(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x24(%rbp),%esi
shl    $0x3,%esi
lea    0xf3f(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
cmpl   $0x6,-0x1c(%rbp)
jge    12a5 <BASM_XCallGenRepackSigSysV+0x195>
movslq -0x1c(%rbp),%rcx
lea    0x2dbd(%rip),%rax
mov    (%rax,%rcx,8),%rsi
mov    -0x14(%rbp),%edx
add    $0x2,%edx
shl    $0x3,%edx
lea    0xed3(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
mov    -0x14(%rbp),%esi
add    $0x2,%esi
shl    $0x3,%esi
lea    0xedd(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x24(%rbp),%esi
shl    $0x3,%esi
lea    0xedc(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
cmpl   $0x6,-0x1c(%rbp)
jge    132e <BASM_XCallGenRepackSigSysV+0x21e>
movslq -0x1c(%rbp),%rcx
lea    0x2d34(%rip),%rax
mov    (%rax,%rcx,8),%rsi
mov    -0x14(%rbp),%edx
add    $0x2,%edx
shl    $0x3,%edx
lea    0xe4a(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
mov    -0x14(%rbp),%esi
add    $0x2,%esi
shl    $0x3,%esi
lea    0xe54(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x24(%rbp),%esi
shl    $0x3,%esi
lea    0xe53(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
cmpl   $0x6,-0x1c(%rbp)
jge    13b7 <BASM_XCallGenRepackSigSysV+0x2a7>
movslq -0x1c(%rbp),%rcx
lea    0x2cab(%rip),%rax
mov    (%rax,%rcx,8),%rsi
mov    -0x14(%rbp),%edx
add    $0x2,%edx
shl    $0x3,%edx
lea    0xdc1(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    13f4 <BASM_XCallGenRepackSigSysV+0x2e4>
mov    -0x14(%rbp),%esi
add    $0x2,%esi
shl    $0x3,%esi
lea    0xdcb(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x24(%rbp),%esi
shl    $0x3,%esi
lea    0xdca(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13f9 <BASM_XCallGenRepackSigSysV+0x2e9>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x50,%eax
jne    141a <BASM_XCallGenRepackSigSysV+0x30a>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    13f9 <BASM_XCallGenRepackSigSysV+0x2e9>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x61,%eax
jl     144b <BASM_XCallGenRepackSigSysV+0x33b>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x7a,%eax
jg     144b <BASM_XCallGenRepackSigSysV+0x33b>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x58,%eax
jne    14c7 <BASM_XCallGenRepackSigSysV+0x3b7>
jmp    1460 <BASM_XCallGenRepackSigSysV+0x350>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x31(%rbp)
je     1485 <BASM_XCallGenRepackSigSysV+0x375>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    1495 <BASM_XCallGenRepackSigSysV+0x385>
jmp    14a6 <BASM_XCallGenRepackSigSysV+0x396>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1460 <BASM_XCallGenRepackSigSysV+0x350>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
jne    14c2 <BASM_XCallGenRepackSigSysV+0x3b2>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    14c7 <BASM_XCallGenRepackSigSysV+0x3b7>
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
cmpl   $0x6,-0x1c(%rbp)
jge    1513 <BASM_XCallGenRepackSigSysV+0x403>
movslq -0x1c(%rbp),%rcx
lea    0x2b4f(%rip),%rax
mov    (%rax,%rcx,8),%rsi
mov    -0x14(%rbp),%edx
add    $0x2,%edx
shl    $0x3,%edx
lea    0xc65(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1550 <BASM_XCallGenRepackSigSysV+0x440>
mov    -0x14(%rbp),%esi
add    $0x2,%esi
shl    $0x3,%esi
lea    0xc6f(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x24(%rbp),%esi
shl    $0x3,%esi
lea    0xc6e(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1555 <BASM_XCallGenRepackSigSysV+0x445>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x51,%eax
jne    1576 <BASM_XCallGenRepackSigSysV+0x466>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1555 <BASM_XCallGenRepackSigSysV+0x445>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x61,%eax
jl     15a7 <BASM_XCallGenRepackSigSysV+0x497>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x7a,%eax
jg     15a7 <BASM_XCallGenRepackSigSysV+0x497>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x4c,%eax
jne    1623 <BASM_XCallGenRepackSigSysV+0x513>
jmp    15bc <BASM_XCallGenRepackSigSysV+0x4ac>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x32(%rbp)
je     15e1 <BASM_XCallGenRepackSigSysV+0x4d1>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x32(%rbp)
mov    -0x32(%rbp),%al
test   $0x1,%al
jne    15f1 <BASM_XCallGenRepackSigSysV+0x4e1>
jmp    1602 <BASM_XCallGenRepackSigSysV+0x4f2>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    15bc <BASM_XCallGenRepackSigSysV+0x4ac>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
jne    161e <BASM_XCallGenRepackSigSysV+0x50e>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1623 <BASM_XCallGenRepackSigSysV+0x513>
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
cmpl   $0x6,-0x1c(%rbp)
jge    166f <BASM_XCallGenRepackSigSysV+0x55f>
movslq -0x1c(%rbp),%rcx
lea    0x29f3(%rip),%rax
mov    (%rax,%rcx,8),%rsi
mov    -0x14(%rbp),%edx
add    $0x2,%edx
shl    $0x3,%edx
lea    0xb09(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    16ac <BASM_XCallGenRepackSigSysV+0x59c>
mov    -0x14(%rbp),%esi
add    $0x2,%esi
shl    $0x3,%esi
lea    0xb13(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x24(%rbp),%esi
shl    $0x3,%esi
lea    0xb12(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    16b1 <BASM_XCallGenRepackSigSysV+0x5a1>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x33(%rbp)
je     16d6 <BASM_XCallGenRepackSigSysV+0x5c6>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x33(%rbp)
mov    -0x33(%rbp),%al
test   $0x1,%al
jne    16e6 <BASM_XCallGenRepackSigSysV+0x5d6>
jmp    16f7 <BASM_XCallGenRepackSigSysV+0x5e7>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    16b1 <BASM_XCallGenRepackSigSysV+0x5a1>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
jne    1713 <BASM_XCallGenRepackSigSysV+0x603>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
cmpl   $0x8,-0x20(%rbp)
jge    175f <BASM_XCallGenRepackSigSysV+0x64f>
movslq -0x20(%rbp),%rcx
lea    0x2933(%rip),%rax
mov    (%rax,%rcx,8),%rsi
mov    -0x14(%rbp),%edx
add    $0x2,%edx
shl    $0x3,%edx
lea    0xa77(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
mov    -0x14(%rbp),%esi
add    $0x2,%esi
shl    $0x3,%esi
lea    0xa5d(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x24(%rbp),%esi
shl    $0x3,%esi
lea    0xa5f(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
cmpl   $0x8,-0x20(%rbp)
jge    1800 <BASM_XCallGenRepackSigSysV+0x6f0>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     17c3 <BASM_XCallGenRepackSigSysV+0x6b3>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
movslq -0x20(%rbp),%rcx
lea    0x2892(%rip),%rax
mov    (%rax,%rcx,8),%rsi
mov    -0x14(%rbp),%edx
add    $0x2,%edx
shl    $0x3,%edx
lea    0xa16(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1818 <BASM_XCallGenRepackSigSysV+0x708>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1830 <BASM_XCallGenRepackSigSysV+0x720>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%esi
add    $0x2,%esi
shl    $0x3,%esi
lea    0x9cd(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x24(%rbp),%esi
shl    $0x3,%esi
lea    0x9d0(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
cmpl   $0x8,-0x20(%rbp)
jge    18b9 <BASM_XCallGenRepackSigSysV+0x7a9>
movslq -0x20(%rbp),%rcx
lea    0x27d9(%rip),%rax
mov    (%rax,%rcx,8),%rsi
mov    -0x14(%rbp),%edx
add    $0x2,%edx
shl    $0x3,%edx
lea    0x9a0(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
mov    -0x14(%rbp),%esi
add    $0x2,%esi
shl    $0x3,%esi
lea    0x986(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x24(%rbp),%esi
shl    $0x3,%esi
lea    0x988(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
cmpl   $0x8,-0x20(%rbp)
jge    195a <BASM_XCallGenRepackSigSysV+0x84a>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     191d <BASM_XCallGenRepackSigSysV+0x80d>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
movslq -0x20(%rbp),%rcx
lea    0x2738(%rip),%rax
mov    (%rax,%rcx,8),%rsi
mov    -0x14(%rbp),%edx
add    $0x2,%edx
shl    $0x3,%edx
lea    0x8bc(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1972 <BASM_XCallGenRepackSigSysV+0x862>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     198a <BASM_XCallGenRepackSigSysV+0x87a>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%esi
add    $0x2,%esi
shl    $0x3,%esi
lea    0x873(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x24(%rbp),%esi
shl    $0x3,%esi
lea    0x876(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%eax
add    $0xffffff9c,%eax
mov    %eax,%ecx
mov    %rcx,-0x40(%rbp)
sub    $0x7,%eax
ja     1a45 <BASM_XCallGenRepackSigSysV+0x935>
mov    -0x40(%rbp),%rax
lea    0x701(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x14(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x14(%rbp)
jmp    1a45 <BASM_XCallGenRepackSigSysV+0x935>
mov    -0x14(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x14(%rbp)
jmp    1a45 <BASM_XCallGenRepackSigSysV+0x935>
mov    -0x14(%rbp),%eax
add    $0x20,%eax
mov    %eax,-0x14(%rbp)
jmp    1a45 <BASM_XCallGenRepackSigSysV+0x935>
mov    -0x14(%rbp),%eax
add    $0x20,%eax
mov    %eax,-0x14(%rbp)
jmp    1a45 <BASM_XCallGenRepackSigSysV+0x935>
mov    -0x14(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x14(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%eax
add    $0xffffff9c,%eax
mov    %eax,%ecx
mov    %rcx,-0x48(%rbp)
sub    $0x7,%eax
ja     1ac3 <BASM_XCallGenRepackSigSysV+0x9b3>
mov    -0x48(%rbp),%rax
lea    0x663(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x14(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x14(%rbp)
jmp    1ac3 <BASM_XCallGenRepackSigSysV+0x9b3>
mov    -0x14(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x14(%rbp)
jmp    1ac3 <BASM_XCallGenRepackSigSysV+0x9b3>
mov    -0x14(%rbp),%eax
add    $0xc,%eax
mov    %eax,-0x14(%rbp)
jmp    1ac3 <BASM_XCallGenRepackSigSysV+0x9b3>
mov    -0x14(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x14(%rbp)
jmp    1ac3 <BASM_XCallGenRepackSigSysV+0x9b3>
mov    -0x14(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x14(%rbp)
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
jmp    1acd <BASM_XCallGenRepackSigSysV+0x9bd>
jmp    1168 <BASM_XCallGenRepackSigSysV+0x58>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1afe <BASM_XCallGenRepackSigSysV+0x9ee>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x29,%eax
jne    1afe <BASM_XCallGenRepackSigSysV+0x9ee>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x14(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<BASM_XCallGenRepackSigSysV>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
xor    %r13d,%r13d
cmpb   $0x28,(%rdi)
sete   %r13b
add    %rdi,%r13
lea    0x103d(%rip),%r14
xor    %r12d,%r12d
xor    %esi,%esi
movl   $0x0,0x4(%rsp)
xor    %r15d,%r15d
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %esi,%rax
mov    %esi,%ebp
lea    0x2c54(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
lea    0x10(,%r12,8),%edx
lea    0xfeb(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
mov    %ebp,%esi
add    $0x1,%r12d
add    $0x1,%esi
movsbl 0x0(%r13),%ecx
test   %ecx,%ecx
je     1718 <BASM_XCallGenRepackSigSysV+0x608>
cmp    $0x29,%cl
je     1718 <BASM_XCallGenRepackSigSysV+0x608>
mov    %r13,%rax
add    $0x1,%r13
add    $0xffffffbd,%ecx
cmp    $0x36,%ecx
ja     117f <BASM_XCallGenRepackSigSysV+0x6f>
lea    0xe55(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
cmp    $0x5,%esi
jle    1150 <BASM_XCallGenRepackSigSysV+0x40>
mov    %esi,%ebp
lea    0x10(,%r12,8),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
lea    0x0(,%r15,8),%esi
lea    0xfa3(%rip),%rdi
jmp    14d0 <BASM_XCallGenRepackSigSysV+0x3c0>
cmp    $0x5,%esi
jle    1150 <BASM_XCallGenRepackSigSysV+0x40>
mov    %esi,%ebp
lea    0x10(,%r12,8),%esi
lea    0xf97(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
lea    0x0(,%r15,8),%esi
lea    0xf94(%rip),%rdi
jmp    14d0 <BASM_XCallGenRepackSigSysV+0x3c0>
mov    %r15,%rbx
mov    %r12d,%eax
and    $0x1,%eax
mov    0x4(%rsp),%r15d
cmp    $0x7,%r15d
jg     12b6 <BASM_XCallGenRepackSigSysV+0x1a6>
movslq %r15d,%rcx
lea    0x2ba8(%rip),%rdx
mov    %esi,%ebp
mov    (%rdx,%rcx,8),%rsi
lea    (%r12,%rax,1),%ecx
add    %eax,%r12d
add    $0x2,%r12d
lea    0x10(,%rcx,8),%edx
lea    0xfa1(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
mov    %ebp,%esi
add    $0x1,%r15d
mov    %r15d,0x4(%rsp)
mov    %rbx,%r15
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
mov    0x4(%rsp),%ebx
cmp    $0x7,%ebx
jg     14a4 <BASM_XCallGenRepackSigSysV+0x394>
movslq %ebx,%rax
lea    0x2b58(%rip),%rcx
mov    %esi,%ebp
mov    (%rcx,%rax,8),%rsi
lea    0x10(,%r12,8),%edx
lea    0xf9e(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
mov    %ebp,%esi
add    $0x1,%r12d
add    $0x1,%ebx
mov    %ebx,0x4(%rsp)
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
mov    %rbx,%r15
mov    %r15d,%ebp
and    $0x1,%ebp
add    %ebp,%ebx
lea    (%r12,%rax,1),%ecx
lea    0x2(%r12,%rax,1),%r12d
mov    %esi,%r14d
lea    0x10(,%rcx,8),%esi
lea    0xf32(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
shl    $0x3,%ebx
lea    0xf38(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1030 <basm_print@plt>
mov    %r14d,%esi
add    %ebp,%r15d
add    $0x2,%r15d
lea    0xe66(%rip),%r14
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
movsbl 0x1(%rax),%ecx
mov    %rax,%r13
add    $0x2,%r13
add    $0xffffff9c,%ecx
cmp    $0x7,%ecx
ja     117f <BASM_XCallGenRepackSigSysV+0x6f>
lea    0xdd3(%rip),%rdx
movslq (%rdx,%rcx,4),%rax
add    %rdx,%rax
jmp    *%rax
add    $0x20,%r12d
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
movsbl 0x1(%rax),%ecx
mov    %rax,%r13
add    $0x2,%r13
add    $0xffffff9c,%ecx
cmp    $0x7,%ecx
ja     117f <BASM_XCallGenRepackSigSysV+0x6f>
lea    0xd83(%rip),%rdx
movslq (%rdx,%rcx,4),%rax
add    %rdx,%rax
jmp    *%rax
add    $0x8,%r12d
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
cmp    $0x5,%esi
jg     14e6 <BASM_XCallGenRepackSigSysV+0x3d6>
movslq %esi,%rax
mov    %esi,%ebp
lea    0x2a30(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
lea    0x10(,%r12,8),%edx
lea    0xdc7(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
mov    %ebp,%esi
add    $0x1,%esi
jmp    151a <BASM_XCallGenRepackSigSysV+0x40a>
cmp    $0x5,%esi
jg     153b <BASM_XCallGenRepackSigSysV+0x42b>
movslq %esi,%rax
mov    %esi,%ebp
lea    0x29f7(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
lea    0x10(,%r12,8),%edx
lea    0xd8e(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
mov    %ebp,%esi
add    $0x1,%esi
jmp    1570 <BASM_XCallGenRepackSigSysV+0x460>
cmp    $0x5,%esi
jg     15c0 <BASM_XCallGenRepackSigSysV+0x4b0>
movslq %esi,%rax
mov    %esi,%ebp
lea    0x29be(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
lea    0x10(,%r12,8),%edx
lea    0xd55(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
mov    %ebp,%esi
add    $0x1,%esi
jmp    1600 <BASM_XCallGenRepackSigSysV+0x4f0>
mov    %esi,%ebp
mov    0x4(%rsp),%edx
cmp    $0x7,%edx
jg     164a <BASM_XCallGenRepackSigSysV+0x53a>
movslq %edx,%rax
lea    0x29b1(%rip),%rcx
mov    %edx,%ebx
mov    (%rcx,%rax,8),%rsi
lea    0x10(,%r12,8),%edx
lea    0xd74(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
add    $0x1,%r12d
jmp    1496 <BASM_XCallGenRepackSigSysV+0x386>
mov    %esi,%ebp
mov    %r12d,%eax
and    $0x1,%eax
mov    0x4(%rsp),%esi
cmp    $0x7,%esi
jg     1685 <BASM_XCallGenRepackSigSysV+0x575>
movslq %esi,%rcx
lea    0x2970(%rip),%rdx
mov    %esi,%ebx
mov    (%rdx,%rcx,8),%rsi
lea    (%r12,%rax,1),%ecx
add    %eax,%r12d
add    $0x2,%r12d
lea    0x10(,%rcx,8),%edx
lea    0xd69(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
add    $0x1,%ebx
mov    %ebx,0x4(%rsp)
mov    %ebp,%esi
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
mov    %esi,%ebp
lea    0x10(,%r12,8),%esi
lea    0xd9a(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
lea    0x0(,%r15,8),%esi
lea    0xd9a(%rip),%rdi
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1030 <basm_print@plt>
mov    %ebp,%esi
add    $0x1,%r12d
add    $0x1,%r15d
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
mov    %esi,%ebp
lea    0x10(,%r12,8),%esi
lea    0xc9b(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
lea    0x0(,%r15,8),%esi
lea    0xc98(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
mov    %ebp,%esi
add    $0x1,%r15d
add    $0x1,%r12d
xchg   %ax,%ax
movzbl 0x0(%r13),%eax
test   %al,%al
je     15b1 <BASM_XCallGenRepackSigSysV+0x4a1>
cmp    $0x3b,%al
je     15b1 <BASM_XCallGenRepackSigSysV+0x4a1>
add    $0x1,%r13
jmp    1520 <BASM_XCallGenRepackSigSysV+0x410>
mov    %esi,%ebp
lea    0x10(,%r12,8),%esi
lea    0xc46(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
lea    0x0(,%r15,8),%esi
lea    0xc43(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
mov    %ebp,%esi
add    $0x1,%r15d
nop
movzbl 0x0(%r13),%eax
add    $0x1,%r13
cmp    $0x50,%al
je     1570 <BASM_XCallGenRepackSigSysV+0x460>
add    $0x1,%r12d
lea    -0x61(%rax),%ecx
cmp    $0x1a,%cl
jb     117f <BASM_XCallGenRepackSigSysV+0x6f>
add    $0xffffffffffffffff,%r13
cmp    $0x58,%al
jne    117f <BASM_XCallGenRepackSigSysV+0x6f>
mov    $0x58,%al
test   %al,%al
je     15b1 <BASM_XCallGenRepackSigSysV+0x4a1>
nop
cmp    $0x3b,%al
je     15b1 <BASM_XCallGenRepackSigSysV+0x4a1>
movzbl 0x1(%r13),%eax
add    $0x1,%r13
test   %al,%al
jne    15a0 <BASM_XCallGenRepackSigSysV+0x490>
xor    %ecx,%ecx
cmp    $0x3b,%al
sete   %cl
add    %rcx,%r13
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
mov    %esi,%ebp
lea    0x10(,%r12,8),%esi
lea    0xbc1(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
lea    0x0(,%r15,8),%esi
lea    0xbbe(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
mov    %ebp,%esi
add    $0x1,%r15d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl 0x0(%r13),%eax
add    $0x1,%r13
cmp    $0x51,%al
je     1600 <BASM_XCallGenRepackSigSysV+0x4f0>
add    $0x1,%r12d
lea    -0x61(%rax),%ecx
cmp    $0x1a,%cl
jb     117f <BASM_XCallGenRepackSigSysV+0x6f>
add    $0xffffffffffffffff,%r13
cmp    $0x4c,%al
jne    117f <BASM_XCallGenRepackSigSysV+0x6f>
mov    $0x4c,%al
test   %al,%al
je     15b1 <BASM_XCallGenRepackSigSysV+0x4a1>
nop
cmp    $0x3b,%al
je     15b1 <BASM_XCallGenRepackSigSysV+0x4a1>
movzbl 0x1(%r13),%eax
add    $0x1,%r13
test   %al,%al
jne    1630 <BASM_XCallGenRepackSigSysV+0x520>
jmp    15b1 <BASM_XCallGenRepackSigSysV+0x4a1>
lea    0x10(,%r12,8),%esi
lea    0xb73(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
lea    0x0(,%r15,8),%esi
lea    0xb73(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
add    $0x1,%r12d
add    $0x1,%r15d
mov    %ebp,%esi
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
mov    %r15d,%ebx
and    $0x1,%ebx
lea    (%rbx,%r15,1),%r14d
lea    (%r12,%rax,1),%ecx
add    %eax,%r12d
add    $0x2,%r12d
lea    0x10(,%rcx,8),%esi
lea    0xb65(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
shl    $0x3,%r14d
lea    0xb6a(%rip),%rdi
mov    %r14d,%esi
lea    0xaa8(%rip),%r14
xor    %eax,%eax
call   1030 <basm_print@plt>
add    %ebx,%r15d
add    $0x2,%r15d
mov    %ebp,%esi
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
add    $0x10,%r12d
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
add    $0x8,%r12d
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
add    $0x4,%r12d
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
add    $0xc,%r12d
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
add    $0x4,%r12d
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
add    $0x10,%r12d
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
add    $0x4,%r12d
jmp    117f <BASM_XCallGenRepackSigSysV+0x6f>
mov    %r12d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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