#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, ...);
int BASM_XCallGenNatRepackSigW64(char *sig) {
  static char *gregs[4] = {"rcx", "rdx", "r8", "r9"};
  static char *xregs[4] = {"xmm0", "xmm1", "xmm2", "xmm3"};
  char *s;
  int i, j, ni, ns, offs;
  offs = 16 + 16 + 32 - 16;
  s = sig;
  i = 0;
  j = 0;
  ni = 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 < 4) {
        basm_print("mov [rsp+%d], %s\n", i * 8, gregs[ni]);
        i++;
        ni++;
        break;
      }
      basm_print("mov eax, [rbp+%d]\n", ns * 8 + offs);
      basm_print("mov [rsp+%d], eax\n", i * 8);
      i++;
      ns++;
      break;
    case 'l':
    case 'm':
    case 'x':
    case 'y':
      if (ni < 4) {
        basm_print("mov [rsp+%d], %s\n", i * 8, gregs[ni]);
        i++;
        ni++;
        break;
      }
      basm_print("mov rax, [rbp+%d]\n", ns * 8 + offs);
      basm_print("mov [rsp+%d], rax\n", i * 8);
      i++;
      ns++;
      break;
    case 'r':
      if (ni < 4) {
        basm_print("mov [rsp+%d], %s\n", i * 8, gregs[ni]);
        i++;
        ni++;
        break;
      }
      basm_print("mov rax, [rbp+%d]\n", ns * 8 + offs);
      basm_print("mov [rsp+%d], rax\n", i * 8);
      i++;
      ns++;
      break;
    case 'P':
      if (ni < 4) {
        basm_print("mov [rsp+%d], %s\n", i * 8, gregs[ni]);
        i++;
        ni++;
      } else {
        basm_print("mov rax, [rbp+%d]\n", ns * 8 + offs);
        basm_print("mov [rsp+%d], rax\n", i * 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 < 4) {
        basm_print("mov [rsp+%d], %s\n", i * 8, gregs[ni]);
        i++;
        ni++;
      } else {
        basm_print("mov rax, [rbp+%d]\n", ns * 8 + offs);
        basm_print("mov [rsp+%d], rax\n", i * 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 < 4) {
        basm_print("mov [rsp+%d], %s\n", i * 8, gregs[ni]);
        i++;
        ni++;
      } else {
        basm_print("mov rax, [rbp+%d]\n", ns * 8 + offs);
        basm_print("mov [rsp+%d], rax\n", i * 8);
        i++;
        ns++;
      }
      while (*s && *s != ';')
        s++;
      if (*s == ';')
        s++;
      break;
    case 'd':
      if (ni < 4) {
        basm_print("movsd [rsp+%d], %s\n", i * 8, xregs[ni]);
        i++;
        ni++;
      } else {
        basm_print("movsd xmm4, [rbp+%d]\n", ns * 8 + offs);
        basm_print("movsd [rsp+%d], xmm4\n", i * 8);
        i++;
        ns++;
      }
      break;
    case 'e':
      if (ni < 4) {
        if (i & 1)
          i++;
        basm_print("movdqa [rsp+%d], %s\n", i * 8, xregs[ni]);
        i += 2;
        ni++;
      } else {
        if (i & 1)
          i++;
        if (ns & 1)
          ns++;
        basm_print("movdqa xmm4, [rbp+%d]\n", ns * 8 + offs);
        basm_print("movdqa [rsp+%d], xmm4\n", i * 8);
        i += 2;
        ns += 2;
      }
      break;
    case 'f':
    case 'k':
      if (ni < 4) {
        basm_print("movss [rsp+%d], %s\n", i * 8, xregs[ni]);
        i++;
        ni++;
      } else {
        basm_print("movss xmm4, [rbp+%d]\n", ns * 8 + offs);
        basm_print("movss [rsp+%d], xmm4\n", i * 8);
        i++;
        ns++;
      }
      break;
    case 'g':
    case 'n':
    case 'o':
      if (ni < 4) {
        if (i & 1)
          i++;
        basm_print("movdqa [rsp+%d], %s\n", i * 8, xregs[ni]);
        i += 2;
        ni++;
      } else {
        if (i & 1)
          i++;
        if (ns & 1)
          ns++;
        basm_print("movdqa xmm4, [rbp+%d]\n", ns * 8 + offs);
        basm_print("movdqa [rsp+%d], xmm4\n", i * 8);
        i += 2;
        ns += 2;
      }
      break;
    default:
      break;
    }
  }
  if (*s && *s == ')')
    s++;
  return (i);
}


x86 assembly (clang, -O0):
<BASM_XCallGenNatRepackSigW64>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x30,-0x24(%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)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x28,%eax
jne    1163 <BASM_XCallGenNatRepackSigW64+0x53>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1168 <BASM_XCallGenNatRepackSigW64+0x58>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x25(%rbp)
je     118d <BASM_XCallGenNatRepackSigW64+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_XCallGenNatRepackSigW64+0x8d>
jmp    19b8 <BASM_XCallGenNatRepackSigW64+0x8a8>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%eax
add    $0xffffffb4,%eax
mov    %eax,%ecx
mov    %rcx,-0x30(%rbp)
sub    $0x2d,%eax
ja     19ae <BASM_XCallGenNatRepackSigW64+0x89e>
mov    -0x30(%rbp),%rax
lea    0xe34(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
cmpl   $0x4,-0x1c(%rbp)
jge    1219 <BASM_XCallGenNatRepackSigW64+0x109>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
movslq -0x1c(%rbp),%rcx
lea    0x2e40(%rip),%rax
mov    (%rax,%rcx,8),%rdx
lea    0xedf(%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    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
mov    -0x20(%rbp),%esi
shl    $0x3,%esi
add    -0x24(%rbp),%esi
lea    0xec3(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
lea    0xec2(%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    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
cmpl   $0x4,-0x1c(%rbp)
jge    129f <BASM_XCallGenNatRepackSigW64+0x18f>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
movslq -0x1c(%rbp),%rcx
lea    0x2dba(%rip),%rax
mov    (%rax,%rcx,8),%rdx
lea    0xe59(%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    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
mov    -0x20(%rbp),%esi
shl    $0x3,%esi
add    -0x24(%rbp),%esi
lea    0xe63(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
lea    0xe62(%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    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
cmpl   $0x4,-0x1c(%rbp)
jge    1325 <BASM_XCallGenNatRepackSigW64+0x215>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
movslq -0x1c(%rbp),%rcx
lea    0x2d34(%rip),%rax
mov    (%rax,%rcx,8),%rdx
lea    0xdd3(%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    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
mov    -0x20(%rbp),%esi
shl    $0x3,%esi
add    -0x24(%rbp),%esi
lea    0xddd(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
lea    0xddc(%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    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
cmpl   $0x4,-0x1c(%rbp)
jge    13ab <BASM_XCallGenNatRepackSigW64+0x29b>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
movslq -0x1c(%rbp),%rcx
lea    0x2cae(%rip),%rax
mov    (%rax,%rcx,8),%rdx
lea    0xd4d(%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    13e8 <BASM_XCallGenNatRepackSigW64+0x2d8>
mov    -0x20(%rbp),%esi
shl    $0x3,%esi
add    -0x24(%rbp),%esi
lea    0xd57(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
lea    0xd56(%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    13ed <BASM_XCallGenNatRepackSigW64+0x2dd>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x50,%eax
jne    140e <BASM_XCallGenNatRepackSigW64+0x2fe>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    13ed <BASM_XCallGenNatRepackSigW64+0x2dd>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x61,%eax
jl     143f <BASM_XCallGenNatRepackSigW64+0x32f>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x7a,%eax
jg     143f <BASM_XCallGenNatRepackSigW64+0x32f>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x58,%eax
jne    14bb <BASM_XCallGenNatRepackSigW64+0x3ab>
jmp    1454 <BASM_XCallGenNatRepackSigW64+0x344>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x31(%rbp)
je     1479 <BASM_XCallGenNatRepackSigW64+0x369>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    1489 <BASM_XCallGenNatRepackSigW64+0x379>
jmp    149a <BASM_XCallGenNatRepackSigW64+0x38a>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1454 <BASM_XCallGenNatRepackSigW64+0x344>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
jne    14b6 <BASM_XCallGenNatRepackSigW64+0x3a6>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    14bb <BASM_XCallGenNatRepackSigW64+0x3ab>
jmp    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
cmpl   $0x4,-0x1c(%rbp)
jge    1504 <BASM_XCallGenNatRepackSigW64+0x3f4>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
movslq -0x1c(%rbp),%rcx
lea    0x2b55(%rip),%rax
mov    (%rax,%rcx,8),%rdx
lea    0xbf4(%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    1541 <BASM_XCallGenNatRepackSigW64+0x431>
mov    -0x20(%rbp),%esi
shl    $0x3,%esi
add    -0x24(%rbp),%esi
lea    0xbfe(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
lea    0xbfd(%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    1546 <BASM_XCallGenNatRepackSigW64+0x436>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x51,%eax
jne    1567 <BASM_XCallGenNatRepackSigW64+0x457>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1546 <BASM_XCallGenNatRepackSigW64+0x436>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x61,%eax
jl     1598 <BASM_XCallGenNatRepackSigW64+0x488>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x7a,%eax
jg     1598 <BASM_XCallGenNatRepackSigW64+0x488>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x4c,%eax
jne    1614 <BASM_XCallGenNatRepackSigW64+0x504>
jmp    15ad <BASM_XCallGenNatRepackSigW64+0x49d>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x32(%rbp)
je     15d2 <BASM_XCallGenNatRepackSigW64+0x4c2>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x32(%rbp)
mov    -0x32(%rbp),%al
test   $0x1,%al
jne    15e2 <BASM_XCallGenNatRepackSigW64+0x4d2>
jmp    15f3 <BASM_XCallGenNatRepackSigW64+0x4e3>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    15ad <BASM_XCallGenNatRepackSigW64+0x49d>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
jne    160f <BASM_XCallGenNatRepackSigW64+0x4ff>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1614 <BASM_XCallGenNatRepackSigW64+0x504>
jmp    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
cmpl   $0x4,-0x1c(%rbp)
jge    165d <BASM_XCallGenNatRepackSigW64+0x54d>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
movslq -0x1c(%rbp),%rcx
lea    0x29fc(%rip),%rax
mov    (%rax,%rcx,8),%rdx
lea    0xa9b(%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    169a <BASM_XCallGenNatRepackSigW64+0x58a>
mov    -0x20(%rbp),%esi
shl    $0x3,%esi
add    -0x24(%rbp),%esi
lea    0xaa5(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
lea    0xaa4(%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    169f <BASM_XCallGenNatRepackSigW64+0x58f>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x33(%rbp)
je     16c4 <BASM_XCallGenNatRepackSigW64+0x5b4>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x33(%rbp)
mov    -0x33(%rbp),%al
test   $0x1,%al
jne    16d4 <BASM_XCallGenNatRepackSigW64+0x5c4>
jmp    16e5 <BASM_XCallGenNatRepackSigW64+0x5d5>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    169f <BASM_XCallGenNatRepackSigW64+0x58f>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
jne    1701 <BASM_XCallGenNatRepackSigW64+0x5f1>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
cmpl   $0x4,-0x1c(%rbp)
jge    174a <BASM_XCallGenNatRepackSigW64+0x63a>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
movslq -0x1c(%rbp),%rcx
lea    0x292f(%rip),%rax
mov    (%rax,%rcx,8),%rdx
lea    0xa0c(%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    1787 <BASM_XCallGenNatRepackSigW64+0x677>
mov    -0x20(%rbp),%esi
shl    $0x3,%esi
add    -0x24(%rbp),%esi
lea    0x9f2(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
lea    0x9f4(%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    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
cmpl   $0x4,-0x1c(%rbp)
jge    17e8 <BASM_XCallGenNatRepackSigW64+0x6d8>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     17ae <BASM_XCallGenNatRepackSigW64+0x69e>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
movslq -0x1c(%rbp),%rcx
lea    0x2891(%rip),%rax
mov    (%rax,%rcx,8),%rdx
lea    0x9ae(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1855 <BASM_XCallGenNatRepackSigW64+0x745>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1800 <BASM_XCallGenNatRepackSigW64+0x6f0>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1818 <BASM_XCallGenNatRepackSigW64+0x708>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%esi
shl    $0x3,%esi
add    -0x24(%rbp),%esi
lea    0x965(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
lea    0x968(%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    $0x2,%eax
mov    %eax,-0x20(%rbp)
jmp    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
cmpl   $0x4,-0x1c(%rbp)
jge    189e <BASM_XCallGenNatRepackSigW64+0x78e>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
movslq -0x1c(%rbp),%rcx
lea    0x27db(%rip),%rax
mov    (%rax,%rcx,8),%rdx
lea    0x93b(%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    18db <BASM_XCallGenNatRepackSigW64+0x7cb>
mov    -0x20(%rbp),%esi
shl    $0x3,%esi
add    -0x24(%rbp),%esi
lea    0x921(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
lea    0x923(%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    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
cmpl   $0x4,-0x1c(%rbp)
jge    193c <BASM_XCallGenNatRepackSigW64+0x82c>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1902 <BASM_XCallGenNatRepackSigW64+0x7f2>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
movslq -0x1c(%rbp),%rcx
lea    0x273d(%rip),%rax
mov    (%rax,%rcx,8),%rdx
lea    0x85a(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    19a9 <BASM_XCallGenNatRepackSigW64+0x899>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1954 <BASM_XCallGenNatRepackSigW64+0x844>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     196c <BASM_XCallGenNatRepackSigW64+0x85c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%esi
shl    $0x3,%esi
add    -0x24(%rbp),%esi
lea    0x811(%rip),%rdi
mov    $0x0,%al
call   1030 <basm_print@plt>
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
lea    0x814(%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    $0x2,%eax
mov    %eax,-0x20(%rbp)
jmp    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
jmp    19b3 <BASM_XCallGenNatRepackSigW64+0x8a3>
jmp    1168 <BASM_XCallGenNatRepackSigW64+0x58>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     19e4 <BASM_XCallGenNatRepackSigW64+0x8d4>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x29,%eax
jne    19e4 <BASM_XCallGenNatRepackSigW64+0x8d4>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x14(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<BASM_XCallGenNatRepackSigW64>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
xor    %r14d,%r14d
cmpb   $0x28,(%rdi)
sete   %r14b
add    %rdi,%r14
lea    0xed1(%rip),%r15
lea    0x2caa(%rip),%rbp
xor    %ebx,%ebx
xor    %r13d,%r13d
xor    %r12d,%r12d
jmp    1172 <BASM_XCallGenNatRepackSigW64+0x62>
lea    0x30(,%r12,8),%esi
lea    0xf9d(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
lea    0x0(,%rbx,8),%esi
lea    0xf9b(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
add    $0x1,%ebx
add    $0x1,%r12d
movsbl (%r14),%eax
test   %eax,%eax
je     1533 <BASM_XCallGenNatRepackSigW64+0x423>
cmp    $0x29,%al
je     1533 <BASM_XCallGenNatRepackSigW64+0x423>
add    $0x1,%r14
add    $0xffffffb4,%eax
cmp    $0x2d,%eax
ja     1172 <BASM_XCallGenNatRepackSigW64+0x62>
movslq (%r15,%rax,4),%rax
add    %r15,%rax
jmp    *%rax
cmp    $0x3,%r13d
jg     1140 <BASM_XCallGenNatRepackSigW64+0x30>
jmp    11a9 <BASM_XCallGenNatRepackSigW64+0x99>
cmp    $0x3,%r13d
jg     120f <BASM_XCallGenNatRepackSigW64+0xff>
lea    0x0(,%rbx,8),%esi
movslq %r13d,%rax
mov    0x0(%rbp,%rax,8),%rdx
lea    0xf1b(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
add    $0x1,%ebx
add    $0x1,%r13d
jmp    1172 <BASM_XCallGenNatRepackSigW64+0x62>
mov    %ebx,%ebp
and    $0x1,%ebp
add    %ebx,%ebp
cmp    $0x3,%r13d
jg     1263 <BASM_XCallGenNatRepackSigW64+0x153>
lea    0x0(,%rbp,8),%esi
movslq %r13d,%rax
lea    0x2c0f(%rip),%rcx
mov    (%rcx,%rax,8),%rdx
lea    0xf7c(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
add    $0x2,%ebp
add    $0x1,%r13d
jmp    12a1 <BASM_XCallGenNatRepackSigW64+0x191>
lea    0x30(,%r12,8),%esi
lea    0xef4(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
lea    0x0(,%rbx,8),%esi
lea    0xef2(%rip),%rdi
jmp    1164 <BASM_XCallGenNatRepackSigW64+0x54>
cmp    $0x3,%r13d
jg     12df <BASM_XCallGenNatRepackSigW64+0x1cf>
lea    0x0(,%rbx,8),%esi
movslq %r13d,%rax
lea    0x2bad(%rip),%rcx
mov    (%rcx,%rax,8),%rdx
lea    0xf5d(%rip),%rdi
jmp    11bf <BASM_XCallGenNatRepackSigW64+0xaf>
mov    %r12d,%ebx
and    $0x1,%ebx
lea    (%rbx,%r12,1),%eax
lea    0x30(,%rax,8),%esi
lea    0xf12(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
lea    0x0(,%rbp,8),%esi
lea    0xf14(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
add    $0x2,%ebp
add    %ebx,%r12d
add    $0x2,%r12d
mov    %ebp,%ebx
lea    0x2b36(%rip),%rbp
jmp    1172 <BASM_XCallGenNatRepackSigW64+0x62>
cmp    $0x3,%r13d
jg     1393 <BASM_XCallGenNatRepackSigW64+0x283>
lea    0x0(,%rbx,8),%esi
movslq %r13d,%rax
mov    0x0(%rbp,%rax,8),%rdx
lea    0xe0b(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
add    $0x1,%r13d
jmp    13d0 <BASM_XCallGenNatRepackSigW64+0x2c0>
lea    0x30(,%r12,8),%esi
lea    0xee1(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
lea    0x0(,%rbx,8),%esi
lea    0xee2(%rip),%rdi
jmp    1164 <BASM_XCallGenNatRepackSigW64+0x54>
cmp    $0x3,%r13d
jg     1420 <BASM_XCallGenNatRepackSigW64+0x310>
lea    0x0(,%rbx,8),%esi
movslq %r13d,%rax
mov    0x0(%rbp,%rax,8),%rdx
lea    0xdb2(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
add    $0x1,%r13d
jmp    144f <BASM_XCallGenNatRepackSigW64+0x33f>
cmp    $0x3,%r13d
jg     1472 <BASM_XCallGenNatRepackSigW64+0x362>
lea    0x0(,%rbx,8),%esi
movslq %r13d,%rax
mov    0x0(%rbp,%rax,8),%rdx
lea    0xd82(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
add    $0x1,%r13d
jmp    14b0 <BASM_XCallGenNatRepackSigW64+0x3a0>
cmp    $0x3,%r13d
jg     150a <BASM_XCallGenNatRepackSigW64+0x3fa>
lea    0x0(,%rbx,8),%esi
movslq %r13d,%rax
lea    0x2a7d(%rip),%rcx
mov    (%rcx,%rax,8),%rdx
lea    0xdaa(%rip),%rdi
jmp    11bf <BASM_XCallGenNatRepackSigW64+0xaf>
lea    0x30(,%r12,8),%esi
lea    0xd70(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
lea    0x0(,%rbx,8),%esi
lea    0xd6e(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
add    $0x1,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r14),%eax
add    $0x1,%r14
cmp    $0x51,%al
je     13d0 <BASM_XCallGenNatRepackSigW64+0x2c0>
add    $0x1,%ebx
lea    -0x61(%rax),%ecx
cmp    $0x1a,%cl
jb     1172 <BASM_XCallGenNatRepackSigW64+0x62>
add    $0xffffffffffffffff,%r14
cmp    $0x4c,%al
jne    1172 <BASM_XCallGenNatRepackSigW64+0x62>
mov    $0x4c,%al
test   %al,%al
je     1411 <BASM_XCallGenNatRepackSigW64+0x301>
nopl   (%rax)
cmp    $0x3b,%al
je     1411 <BASM_XCallGenNatRepackSigW64+0x301>
movzbl 0x1(%r14),%eax
add    $0x1,%r14
test   %al,%al
jne    1400 <BASM_XCallGenNatRepackSigW64+0x2f0>
xor    %ecx,%ecx
cmp    $0x3b,%al
sete   %cl
add    %rcx,%r14
jmp    1172 <BASM_XCallGenNatRepackSigW64+0x62>
lea    0x30(,%r12,8),%esi
lea    0xce3(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
lea    0x0(,%rbx,8),%esi
lea    0xce1(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
add    $0x1,%r12d
add    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r14),%eax
test   %al,%al
je     1411 <BASM_XCallGenNatRepackSigW64+0x301>
cmp    $0x3b,%al
je     1411 <BASM_XCallGenNatRepackSigW64+0x301>
add    $0x1,%r14
jmp    1460 <BASM_XCallGenNatRepackSigW64+0x350>
lea    0x30(,%r12,8),%esi
lea    0xc91(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
lea    0x0(,%rbx,8),%esi
lea    0xc8f(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
add    $0x1,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%r14),%eax
add    $0x1,%r14
cmp    $0x50,%al
je     14b0 <BASM_XCallGenNatRepackSigW64+0x3a0>
add    $0x1,%ebx
lea    -0x61(%rax),%ecx
cmp    $0x1a,%cl
jb     1172 <BASM_XCallGenNatRepackSigW64+0x62>
add    $0xffffffffffffffff,%r14
cmp    $0x58,%al
jne    1172 <BASM_XCallGenNatRepackSigW64+0x62>
mov    $0x58,%al
test   %al,%al
je     1411 <BASM_XCallGenNatRepackSigW64+0x301>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0x3b,%al
je     1411 <BASM_XCallGenNatRepackSigW64+0x301>
movzbl 0x1(%r14),%eax
add    $0x1,%r14
test   %al,%al
jne    14f0 <BASM_XCallGenNatRepackSigW64+0x3e0>
jmp    1411 <BASM_XCallGenNatRepackSigW64+0x301>
lea    0x30(,%r12,8),%esi
lea    0xc33(%rip),%rdi
xor    %eax,%eax
call   1030 <basm_print@plt>
lea    0x0(,%rbx,8),%esi
lea    0xc34(%rip),%rdi
jmp    1164 <BASM_XCallGenNatRepackSigW64+0x54>
mov    %ebx,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@BASM_XCallGenNatRepackSigW64.gregs = internal global [4 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 ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i32 0, i32 0)]
@.str = [4 x i8] c"rcx\00"
@.str.1 = [4 x i8] c"rdx\00"
@.str.2 = [3 x i8] c"r8\00"
@.str.3 = [3 x i8] c"r9\00"
@BASM_XCallGenNatRepackSigW64.xregs = internal global [4 x i8*] [i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i32 0, i32 0), 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)]
@.str.4 = [5 x i8] c"xmm0\00"
@.str.5 = [5 x i8] c"xmm1\00"
@.str.6 = [5 x i8] c"xmm2\00"
@.str.7 = [5 x i8] c"xmm3\00"
@.str.8 = [18 x i8] c"mov [rsp+%d], %s\0A\00"
@.str.9 = [19 x i8] c"mov eax, [rbp+%d]\0A\00"
@.str.10 = [19 x i8] c"mov [rsp+%d], eax\0A\00"
@.str.11 = [19 x i8] c"mov rax, [rbp+%d]\0A\00"
@.str.12 = [19 x i8] c"mov [rsp+%d], rax\0A\00"
@.str.13 = [20 x i8] c"movsd [rsp+%d], %s\0A\00"
@.str.14 = [22 x i8] c"movsd xmm4, [rbp+%d]\0A\00"
@.str.15 = [22 x i8] c"movsd [rsp+%d], xmm4\0A\00"
@.str.16 = [21 x i8] c"movdqa [rsp+%d], %s\0A\00"
@.str.17 = [23 x i8] c"movdqa xmm4, [rbp+%d]\0A\00"
@.str.18 = [23 x i8] c"movdqa [rsp+%d], xmm4\0A\00"
@.str.19 = [20 x i8] c"movss [rsp+%d], %s\0A\00"
@.str.20 = [22 x i8] c"movss xmm4, [rbp+%d]\0A\00"
@.str.21 = [22 x i8] c"movss [rsp+%d], xmm4\0A\00"
define i32 @BASM_XCallGenNatRepackSigW64(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
store i32 48, i32* %8
%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
%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 = %493, %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 %494
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 %492 [
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 %363
i32 102, label %413
i32 107, label %413
i32 103, label %442
i32 110, label %442
i32 111, label %442
]
35: ; preds = %30, %30, %30, %30, %30, %30, %30, %30, %30
%36 = load i32, i32* %6
%37 = icmp slt i32 %36, 4
br i1 %37, label %38, label %50
38: ; preds = %35
%39 = load i32, i32* %4
%40 = mul nsw i32 %39, 8
%41 = load i32, i32* %6
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [4 x i8*], [4 x i8*]* @BASM_XCallGenNatRepackSigW64.gregs, i64 0, i64 %42
%44 = load i8*, i8** %43
%45 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.8, i64 0, i64 0), i32 %40, i8* %44)
%46 = load i32, i32* %4
%47 = add nsw i32 %46, 1
store i32 %47, i32* %4
%48 = load i32, i32* %6
%49 = add nsw i32 %48, 1
store i32 %49, i32* %6
br label %493
50: ; preds = %35
%51 = load i32, i32* %7
%52 = mul nsw i32 %51, 8
%53 = load i32, i32* %8
%54 = add nsw i32 %52, %53
%55 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.9, i64 0, i64 0), i32 %54)
%56 = load i32, i32* %4
%57 = mul nsw i32 %56, 8
%58 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.10, 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* %7
%62 = add nsw i32 %61, 1
store i32 %62, i32* %7
br label %493
63: ; preds = %30, %30, %30, %30
%64 = load i32, i32* %6
%65 = icmp slt i32 %64, 4
br i1 %65, label %66, label %78
66: ; preds = %63
%67 = load i32, i32* %4
%68 = mul nsw i32 %67, 8
%69 = load i32, i32* %6
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [4 x i8*], [4 x i8*]* @BASM_XCallGenNatRepackSigW64.gregs, i64 0, i64 %70
%72 = load i8*, i8** %71
%73 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.8, i64 0, i64 0), i32 %68, i8* %72)
%74 = load i32, i32* %4
%75 = add nsw i32 %74, 1
store i32 %75, i32* %4
%76 = load i32, i32* %6
%77 = add nsw i32 %76, 1
store i32 %77, i32* %6
br label %493
78: ; preds = %63
%79 = load i32, i32* %7
%80 = mul nsw i32 %79, 8
%81 = load i32, i32* %8
%82 = add nsw i32 %80, %81
%83 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.11, i64 0, i64 0), i32 %82)
%84 = load i32, i32* %4
%85 = mul nsw i32 %84, 8
%86 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.12, 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* %7
%90 = add nsw i32 %89, 1
store i32 %90, i32* %7
br label %493
91: ; preds = %30
%92 = load i32, i32* %6
%93 = icmp slt i32 %92, 4
br i1 %93, label %94, label %106
94: ; preds = %91
%95 = load i32, i32* %4
%96 = mul nsw i32 %95, 8
%97 = load i32, i32* %6
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [4 x i8*], [4 x i8*]* @BASM_XCallGenNatRepackSigW64.gregs, i64 0, i64 %98
%100 = load i8*, i8** %99
%101 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.8, i64 0, i64 0), i32 %96, i8* %100)
%102 = load i32, i32* %4
%103 = add nsw i32 %102, 1
store i32 %103, i32* %4
%104 = load i32, i32* %6
%105 = add nsw i32 %104, 1
store i32 %105, i32* %6
br label %493
106: ; preds = %91
%107 = load i32, i32* %7
%108 = mul nsw i32 %107, 8
%109 = load i32, i32* %8
%110 = add nsw i32 %108, %109
%111 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.11, i64 0, i64 0), i32 %110)
%112 = load i32, i32* %4
%113 = mul nsw i32 %112, 8
%114 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.12, 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* %7
%118 = add nsw i32 %117, 1
store i32 %118, i32* %7
br label %493
119: ; preds = %30
%120 = load i32, i32* %6
%121 = icmp slt i32 %120, 4
br i1 %121, label %122, label %134
122: ; preds = %119
%123 = load i32, i32* %4
%124 = mul nsw i32 %123, 8
%125 = load i32, i32* %6
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [4 x i8*], [4 x i8*]* @BASM_XCallGenNatRepackSigW64.gregs, i64 0, i64 %126
%128 = load i8*, i8** %127
%129 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.8, i64 0, i64 0), i32 %124, i8* %128)
%130 = load i32, i32* %4
%131 = add nsw i32 %130, 1
store i32 %131, i32* %4
%132 = load i32, i32* %6
%133 = add nsw i32 %132, 1
store i32 %133, i32* %6
br label %147
134: ; preds = %119
%135 = load i32, i32* %7
%136 = mul nsw i32 %135, 8
%137 = load i32, i32* %8
%138 = add nsw i32 %136, %137
%139 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.11, i64 0, i64 0), i32 %138)
%140 = load i32, i32* %4
%141 = mul nsw i32 %140, 8
%142 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.12, 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* %7
%146 = add nsw i32 %145, 1
store i32 %146, i32* %7
br label %147
147: ; preds = %134, %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 %493
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 %493
200: ; preds = %30
%201 = load i32, i32* %6
%202 = icmp slt i32 %201, 4
br i1 %202, label %203, label %215
203: ; preds = %200
%204 = load i32, i32* %4
%205 = mul nsw i32 %204, 8
%206 = load i32, i32* %6
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [4 x i8*], [4 x i8*]* @BASM_XCallGenNatRepackSigW64.gregs, i64 0, i64 %207
%209 = load i8*, i8** %208
%210 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.8, i64 0, i64 0), i32 %205, i8* %209)
%211 = load i32, i32* %4
%212 = add nsw i32 %211, 1
store i32 %212, i32* %4
%213 = load i32, i32* %6
%214 = add nsw i32 %213, 1
store i32 %214, i32* %6
br label %228
215: ; preds = %200
%216 = load i32, i32* %7
%217 = mul nsw i32 %216, 8
%218 = load i32, i32* %8
%219 = add nsw i32 %217, %218
%220 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.11, i64 0, i64 0), i32 %219)
%221 = load i32, i32* %4
%222 = mul nsw i32 %221, 8
%223 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.12, 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* %7
%227 = add nsw i32 %226, 1
store i32 %227, i32* %7
br label %228
228: ; preds = %215, %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 %493
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 %493
281: ; preds = %30
%282 = load i32, i32* %6
%283 = icmp slt i32 %282, 4
br i1 %283, label %284, label %296
284: ; preds = %281
%285 = load i32, i32* %4
%286 = mul nsw i32 %285, 8
%287 = load i32, i32* %6
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds [4 x i8*], [4 x i8*]* @BASM_XCallGenNatRepackSigW64.gregs, i64 0, i64 %288
%290 = load i8*, i8** %289
%291 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.8, i64 0, i64 0), i32 %286, i8* %290)
%292 = load i32, i32* %4
%293 = add nsw i32 %292, 1
store i32 %293, i32* %4
%294 = load i32, i32* %6
%295 = add nsw i32 %294, 1
store i32 %295, i32* %6
br label %309
296: ; preds = %281
%297 = load i32, i32* %7
%298 = mul nsw i32 %297, 8
%299 = load i32, i32* %8
%300 = add nsw i32 %298, %299
%301 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.11, i64 0, i64 0), i32 %300)
%302 = load i32, i32* %4
%303 = mul nsw i32 %302, 8
%304 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.12, 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* %7
%308 = add nsw i32 %307, 1
store i32 %308, i32* %7
br label %309
309: ; preds = %296, %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 %493
334: ; preds = %30
%335 = load i32, i32* %6
%336 = icmp slt i32 %335, 4
br i1 %336, label %337, label %349
337: ; preds = %334
%338 = load i32, i32* %4
%339 = mul nsw i32 %338, 8
%340 = load i32, i32* %6
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds [4 x i8*], [4 x i8*]* @BASM_XCallGenNatRepackSigW64.xregs, i64 0, i64 %341
%343 = load i8*, i8** %342
%344 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.13, i64 0, i64 0), i32 %339, i8* %343)
%345 = load i32, i32* %4
%346 = add nsw i32 %345, 1
store i32 %346, i32* %4
%347 = load i32, i32* %6
%348 = add nsw i32 %347, 1
store i32 %348, i32* %6
br label %362
349: ; preds = %334
%350 = load i32, i32* %7
%351 = mul nsw i32 %350, 8
%352 = load i32, i32* %8
%353 = add nsw i32 %351, %352
%354 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.14, i64 0, i64 0), i32 %353)
%355 = load i32, i32* %4
%356 = mul nsw i32 %355, 8
%357 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.15, 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* %7
%361 = add nsw i32 %360, 1
store i32 %361, i32* %7
br label %362
362: ; preds = %349, %337
br label %493
363: ; preds = %30
%364 = load i32, i32* %6
%365 = icmp slt i32 %364, 4
br i1 %365, label %366, label %385
366: ; preds = %363
%367 = load i32, i32* %4
%368 = and i32 %367, 1
%369 = icmp ne i32 %368, 0
br i1 %369, label %370, label %373
370: ; preds = %366
%371 = load i32, i32* %4
%372 = add nsw i32 %371, 1
store i32 %372, i32* %4
br label %373
373: ; preds = %370, %366
%374 = load i32, i32* %4
%375 = mul nsw i32 %374, 8
%376 = load i32, i32* %6
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds [4 x i8*], [4 x i8*]* @BASM_XCallGenNatRepackSigW64.xregs, i64 0, i64 %377
%379 = load i8*, i8** %378
%380 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.16, i64 0, i64 0), i32 %375, i8* %379)
%381 = load i32, i32* %4
%382 = add nsw i32 %381, 2
store i32 %382, i32* %4
%383 = load i32, i32* %6
%384 = add nsw i32 %383, 1
store i32 %384, i32* %6
br label %412
385: ; preds = %363
%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* %7
%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* %7
%398 = add nsw i32 %397, 1
store i32 %398, i32* %7
br label %399
399: ; preds = %396, %392
%400 = load i32, i32* %7
%401 = mul nsw i32 %400, 8
%402 = load i32, i32* %8
%403 = add nsw i32 %401, %402
%404 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.17, i64 0, i64 0), i32 %403)
%405 = load i32, i32* %4
%406 = mul nsw i32 %405, 8
%407 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.18, i64 0, i64 0), i32 %406)
%408 = load i32, i32* %4
%409 = add nsw i32 %408, 2
store i32 %409, i32* %4
%410 = load i32, i32* %7
%411 = add nsw i32 %410, 2
store i32 %411, i32* %7
br label %412
412: ; preds = %399, %373
br label %493
413: ; preds = %30, %30
%414 = load i32, i32* %6
%415 = icmp slt i32 %414, 4
br i1 %415, label %416, label %428
416: ; preds = %413
%417 = load i32, i32* %4
%418 = mul nsw i32 %417, 8
%419 = load i32, i32* %6
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds [4 x i8*], [4 x i8*]* @BASM_XCallGenNatRepackSigW64.xregs, i64 0, i64 %420
%422 = load i8*, i8** %421
%423 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.19, i64 0, i64 0), i32 %418, i8* %422)
%424 = load i32, i32* %4
%425 = add nsw i32 %424, 1
store i32 %425, i32* %4
%426 = load i32, i32* %6
%427 = add nsw i32 %426, 1
store i32 %427, i32* %6
br label %441
428: ; preds = %413
%429 = load i32, i32* %7
%430 = mul nsw i32 %429, 8
%431 = load i32, i32* %8
%432 = add nsw i32 %430, %431
%433 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.20, i64 0, i64 0), i32 %432)
%434 = load i32, i32* %4
%435 = mul nsw i32 %434, 8
%436 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.21, i64 0, i64 0), i32 %435)
%437 = load i32, i32* %4
%438 = add nsw i32 %437, 1
store i32 %438, i32* %4
%439 = load i32, i32* %7
%440 = add nsw i32 %439, 1
store i32 %440, i32* %7
br label %441
441: ; preds = %428, %416
br label %493
442: ; preds = %30, %30, %30
%443 = load i32, i32* %6
%444 = icmp slt i32 %443, 4
br i1 %444, label %445, label %464
445: ; preds = %442
%446 = load i32, i32* %4
%447 = and i32 %446, 1
%448 = icmp ne i32 %447, 0
br i1 %448, label %449, label %452
449: ; preds = %445
%450 = load i32, i32* %4
%451 = add nsw i32 %450, 1
store i32 %451, i32* %4
br label %452
452: ; preds = %449, %445
%453 = load i32, i32* %4
%454 = mul nsw i32 %453, 8
%455 = load i32, i32* %6
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds [4 x i8*], [4 x i8*]* @BASM_XCallGenNatRepackSigW64.xregs, i64 0, i64 %456
%458 = load i8*, i8** %457
%459 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.16, i64 0, i64 0), i32 %454, i8* %458)
%460 = load i32, i32* %4
%461 = add nsw i32 %460, 2
store i32 %461, i32* %4
%462 = load i32, i32* %6
%463 = add nsw i32 %462, 1
store i32 %463, i32* %6
br label %491
464: ; preds = %442
%465 = load i32, i32* %4
%466 = and i32 %465, 1
%467 = icmp ne i32 %466, 0
br i1 %467, label %468, label %471
468: ; preds = %464
%469 = load i32, i32* %4
%470 = add nsw i32 %469, 1
store i32 %470, i32* %4
br label %471
471: ; preds = %468, %464
%472 = load i32, i32* %7
%473 = and i32 %472, 1
%474 = icmp ne i32 %473, 0
br i1 %474, label %475, label %478
475: ; preds = %471
%476 = load i32, i32* %7
%477 = add nsw i32 %476, 1
store i32 %477, i32* %7
br label %478
478: ; preds = %475, %471
%479 = load i32, i32* %7
%480 = mul nsw i32 %479, 8
%481 = load i32, i32* %8
%482 = add nsw i32 %480, %481
%483 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.17, i64 0, i64 0), i32 %482)
%484 = load i32, i32* %4
%485 = mul nsw i32 %484, 8
%486 = call i32 (i8*, i32, ...) @basm_print(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.18, i64 0, i64 0), i32 %485)
%487 = load i32, i32* %4
%488 = add nsw i32 %487, 2
store i32 %488, i32* %4
%489 = load i32, i32* %7
%490 = add nsw i32 %489, 2
store i32 %490, i32* %7
br label %491
491: ; preds = %478, %452
br label %493
492: ; preds = %30
br label %493
493: ; preds = %492, %491, %441, %412, %362, %333, %280, %247, %199, %166, %106, %94, %78, %66, %50, %38
br label %18
494: ; preds = %28
%495 = load i8*, i8** %3
%496 = load i8, i8* %495
%497 = sext i8 %496 to i32
%498 = icmp ne i32 %497, 0
br i1 %498, label %499, label %507
499: ; preds = %494
%500 = load i8*, i8** %3
%501 = load i8, i8* %500
%502 = sext i8 %501 to i32
%503 = icmp eq i32 %502, 41
br i1 %503, label %504, label %507
504: ; preds = %499
%505 = load i8*, i8** %3
%506 = getelementptr inbounds i8, i8* %505, i32 1
store i8* %506, i8** %3
br label %507
507: ; preds = %504, %499, %494
%508 = load i32, i32* %4
ret i32 %508
}

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