LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm.c
// Function: emit_bcdef
static void emit_bcdef(BuildCtx *ctx)
{
  int i;
  fprintf(ctx->fp, "/* This is a generated file. DO NOT EDIT! */\n\n");
  fprintf(ctx->fp, "LJ_DATADEF const uint16_t lj_bc_ofs[] = {\n");
  for (i = 0; i < ctx->npc; i++) {
    if (i != 0)
      fprintf(ctx->fp, ",\n");
    fprintf(ctx->fp, "%d", ctx->bc_ofs[i]);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0xd8e0(%rip), %rsi      # 0x159d9
movb $0x0, %al
callq 0x5110
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0xd8f8(%rip), %rsi      # 0x15a08
movb $0x0, %al
callq 0x5110
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x8180
cmpl $0x0, 0xc(%rsp)
je 0x814b
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0xdf70(%rip), %rsi      # 0x160b4
movb $0x0, %al
callq 0x5110
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0xe233(%rip), %rsi      # 0x1639f
movb $0x0, %al
callq 0x5110
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x811f
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm.c
// Function: sym_decorate
static const char *sym_decorate(BuildCtx *ctx,
				const char *prefix, const char *suffix)
{
  char name[256];
  char *p;
#if LJ_64
  const char *symprefix = ctx->mode == BUILD_machasm ? "_" : "";
#elif LJ_TARGET_XBOX360
  const char *symprefix = "";
#else
  const char *symprefix = ctx->mode != BUILD_elfasm ? "_" : "";
#endif
  sprintf(name, "%s%s%s", symprefix, prefix, suffix);
  p = strchr(name, '@');
  if (p) {
#if LJ_TARGET_X86ORX64
    if (!LJ_64 && (ctx->mode == BUILD_coffasm || ctx->mode == BUILD_peobj))
      name[0] = '@';
    else
      *p = '\0';
#elif (LJ_TARGET_PPC  || LJ_TARGET_PPCSPE) && !LJ_TARGET_CONSOLE
    /* Keep @plt. */
#else
    *p = '\0';
#endif
  }
  p = (char *)malloc(strlen(name)+1);  /* MSVC doesn't like strdup. */
  strcpy(p, name);
  return p;
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x120(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0xd51d(%rip), %rax      # 0x15a5e
leaq 0xdbf7(%rip), %rcx      # 0x1613f
cmpl $0x2, %edx
cmoveq %rcx, %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
movq (%rsp), %rdx
movq 0x118(%rsp), %rcx
movq 0x110(%rsp), %r8
leaq 0xbdcd(%rip), %rsi      # 0x14340
movb $0x0, %al
callq 0x5180
leaq 0x10(%rsp), %rdi
movl $0x40, %esi
callq 0x50b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x859e
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x50a0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x5130
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5060
movq 0x8(%rsp), %rax
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm.c
// Function: parsemode
static BuildMode parsemode(const char *mode)
{
  int i;
  for (i = 0; modenames[i]; i++)
    if (!strcmp(mode, modenames[i]))
      return (BuildMode)i;
  usage();
  return (BuildMode)-1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movslq 0x4(%rsp), %rcx
leaq 0x10f83(%rip), %rax     # 0x19580
cmpq $0x0, (%rax,%rcx,8)
je 0x863c
movq 0x8(%rsp), %rdi
movslq 0x4(%rsp), %rcx
leaq 0x10f6b(%rip), %rax     # 0x19580
movq (%rax,%rcx,8), %rsi
callq 0x50f0
cmpl $0x0, %eax
jne 0x862d
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x8649
jmp 0x862f
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x85f1
callq 0x8660
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm.c
// Function: usage
static void usage(void)
{
  int i;
  fprintf(stderr, LUAJIT_VERSION " VM builder.\n");
  fprintf(stderr, LUAJIT_COPYRIGHT ", " LUAJIT_URL "\n");
  fprintf(stderr, "Target architecture: " LJ_ARCH_NAME "\n\n");
  fprintf(stderr, "Usage: buildvm -m mode [-o outfile] [infiles...]\n\n");
  fprintf(stderr, "Available modes:\n");
  for (i = 0; i < BUILD__MAX; i++)
    fprintf(stderr, "  %s\n", modenames[i]);
  exit(1);
}

// Assembly:
pushq %rax
movq 0x11990(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0xbf36(%rip), %rsi      # 0x145a8
movb $0x0, %al
callq 0x5110
movq 0x11978(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0xbf38(%rip), %rsi      # 0x145c2
movb $0x0, %al
callq 0x5110
movq 0x11960(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0xbf57(%rip), %rsi      # 0x145f9
movb $0x0, %al
callq 0x5110
movq 0x11948(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0xbf5a(%rip), %rsi      # 0x14614
movb $0x0, %al
callq 0x5110
movq 0x11930(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0xbf75(%rip), %rsi      # 0x14647
movb $0x0, %al
callq 0x5110
movl $0x0, 0x4(%rsp)
cmpl $0xb, 0x4(%rsp)
jge 0x871d
movq 0x11909(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
movslq 0x4(%rsp), %rcx
leaq 0x10e82(%rip), %rax     # 0x19580
movq (%rax,%rcx,8), %rdx
leaq 0xbf50(%rip), %rsi      # 0x14659
movb $0x0, %al
callq 0x5110
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x86e1
movl $0x1, %edi
callq 0x5190
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm.c
// Function: sym_insert
static void sym_insert(BuildCtx *ctx, int32_t ofs,
		       const char *prefix, const char *suffix)
{
  ptrdiff_t i = ctx->nsym++;
  while (i > 0) {
    if (ctx->sym[i-1].ofs <= ofs)
      break;
    ctx->sym[i] = ctx->sym[i-1];
    i--;
  }
  ctx->sym[i].ofs = ofs;
  ctx->sym[i].name = sym_decorate(ctx, prefix, suffix);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movl 0x40(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x40(%rcx)
cltq
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jle 0x883f
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movq (%rsp), %rcx
subq $0x1, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl 0x1c(%rsp), %eax
jg 0x87f7
jmp 0x883f
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movq (%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x20(%rsp), %rcx
movq 0x58(%rcx), %rcx
movq (%rsp), %rdx
subq $0x1, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
addq $-0x1, %rax
movq %rax, (%rsp)
jmp 0x87cd
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movq (%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x8510
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movq (%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm.c
// Function: lower
static const char *lower(char *buf, const char *s)
{
  char *p = buf;
  while (*s) {
    *p++ = (*s >= 'A' && *s <= 'Z') ? *s+0x20 : *s;
    s++;
  }
  *p = '\0';
  return buf;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0xbc4e
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
jl 0xbc19
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5a, %eax
jg 0xbc19
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
addl $0x20, %eax
movl %eax, -0x1c(%rsp)
jmp 0xbc25
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movb %al, %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0xbbe4
movq -0x18(%rsp), %rax
movb $0x0, (%rax)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_asm.c
// Function: emit_asm_align
static void emit_asm_align(BuildCtx *ctx, int bits)
{
  switch (ctx->mode) {
  case BUILD_elfasm:
  case BUILD_coffasm:
    fprintf(ctx->fp, "\t.p2align %d\n", bits);
    break;
  case BUILD_machasm:
    fprintf(ctx->fp, "\t.align %d\n", bits);
    break;
  default:
    break;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rsp)
subl $0x2, %eax
jb 0xbfbb
jmp 0xbfb0
movl 0x8(%rsp), %eax
subl $0x2, %eax
je 0xbfd8
jmp 0xbff5
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0xc(%rsp), %edx
leaq 0x9f18(%rip), %rsi      # 0x15ee7
movb $0x0, %al
callq 0x5110
jmp 0xbff7
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0xc(%rsp), %edx
leaq 0x9f09(%rip), %rsi      # 0x15ef5
movb $0x0, %al
callq 0x5110
jmp 0xbff7
jmp 0xbff7
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_asm.c
// Function: emit_asm_label
static void emit_asm_label(BuildCtx *ctx, const char *name, int size, int isfunc)
{
  switch (ctx->mode) {
  case BUILD_elfasm:
#if LJ_TARGET_PS3
    if (!strncmp(name, "lj_vm_", 6) &&
	strcmp(name, ctx->beginsym) &&
	!strstr(name, "hook")) {
      fprintf(ctx->fp,
	"\n\t.globl %s\n"
	"\t.section \".opd\",\"aw\"\n"
	"%s:\n"
	"\t.long .%s,.TOC.@tocbase32\n"
	"\t.size %s,8\n"
	"\t.previous\n"
	"\t.globl .%s\n"
	"\t.hidden .%s\n"
	"\t.type .%s, " ELFASM_PX "function\n"
	"\t.size .%s, %d\n"
	".%s:\n",
	name, name, name, name, name, name, name, name, size, name);
      break;
    }
#endif
    fprintf(ctx->fp,
      "\n\t.globl %s\n"
      "\t.hidden %s\n"
      "\t.type %s, " ELFASM_PX "%s\n"
      "\t.size %s, %d\n"
      "%s:\n",
      name, name, name, isfunc ? "function" : "object", name, size, name);
    break;
  case BUILD_coffasm:
    fprintf(ctx->fp, "\n\t.globl %s\n", name);
    if (isfunc)
      fprintf(ctx->fp, "\t.def %s; .scl 3; .type 32; .endef\n", name);
    fprintf(ctx->fp, "%s:\n", name);
    break;
  case BUILD_machasm:
    fprintf(ctx->fp,
      "\n\t.private_extern %s\n"
      "%s:\n", name, name);
    break;
  default:
    break;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
testl %eax, %eax
je 0xc045
jmp 0xc028
movl 0x1c(%rsp), %eax
subl $0x1, %eax
je 0xc0a6
jmp 0xc033
movl 0x1c(%rsp), %eax
subl $0x2, %eax
je 0xc103
jmp 0xc126
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x28(%rsp), %r8
movl 0x20(%rsp), %esi
leaq 0x9ed3(%rip), %r9       # 0x15f3b
leaq 0x9b6b(%rip), %rax      # 0x15bda
cmpl $0x0, %esi
cmovneq %rax, %r9
movq 0x28(%rsp), %r11
movl 0x24(%rsp), %r10d
movq 0x28(%rsp), %rax
leaq 0x9e75(%rip), %rsi      # 0x15f01
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x5110
jmp 0xc128
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0x9e87(%rip), %rsi      # 0x15f42
movb $0x0, %al
callq 0x5110
cmpl $0x0, 0x20(%rsp)
je 0xc0e5
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0x9e71(%rip), %rsi      # 0x15f4f
movb $0x0, %al
callq 0x5110
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0x9e3c(%rip), %rsi      # 0x15f36
movb $0x0, %al
callq 0x5110
jmp 0xc128
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rdx
movq 0x28(%rsp), %rcx
leaq 0x9e56(%rip), %rsi      # 0x15f73
movb $0x0, %al
callq 0x5110
jmp 0xc128
jmp 0xc128
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_asm.c
// Function: emit_asm_reloc_mach
static void emit_asm_reloc_mach(BuildCtx *ctx, uint8_t *cp, int n,
				const char *sym)
{
  const char *opname = NULL;
  if (--n < 0) goto err;
  if (cp[n] == 0xe8) {
    opname = "call";
  } else if (cp[n] == 0xe9) {
    opname = "jmp";
  } else if (cp[n] >= 0x80 && cp[n] <= 0x8f && n > 0 && cp[n-1] == 0x0f) {
    opname = jccnames[cp[n]-0x80];
    n--;
  } else {
err:
    fprintf(stderr, "Error: unsupported opcode for %s symbol relocation.\n",
	    sym);
    exit(1);
  }
  emit_asm_bytes(ctx, cp, n);
  fprintf(ctx->fp, "\t%s %s\n", opname, sym);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
movq $0x0, (%rsp)
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, %eax
jge 0xc164
jmp 0xc22b
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xe8, %eax
jne 0xc189
leaq 0x8257(%rip), %rax      # 0x143d7
movq %rax, (%rsp)
jmp 0xc256
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xe9, %eax
jne 0xc1ae
leaq 0x9de8(%rip), %rax      # 0x15f8d
movq %rax, (%rsp)
jmp 0xc254
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x80, %eax
jl 0xc229
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x8f, %eax
jg 0xc229
cmpl $0x0, 0x14(%rsp)
jle 0xc229
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xf, %eax
jne 0xc229
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movzbl (%rax,%rcx), %eax
subl $0x80, %eax
movslq %eax, %rcx
leaq 0xda0c(%rip), %rax      # 0x19c20
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xc252
jmp 0xc22b
movq 0xddc6(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x9d50(%rip), %rsi      # 0x15f91
movb $0x0, %al
callq 0x5110
movl $0x1, %edi
callq 0x5190
jmp 0xc254
jmp 0xc256
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0xc290
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0x9d44(%rip), %rsi      # 0x15fc6
movb $0x0, %al
callq 0x5110
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_asm.c
// Function: emit_asm_bytes
static void emit_asm_bytes(BuildCtx *ctx, uint8_t *p, int n)
{
  int i;
  for (i = 0; i < n; i++) {
    if ((i & 15) == 0)
      fprintf(ctx->fp, "\t.byte %d", p[i]);
    else
      fprintf(ctx->fp, ",%d", p[i]);
    if ((i & 15) == 15) putc('\n', ctx->fp);
  }
  if ((n & 15) != 0) putc('\n', ctx->fp);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0xc339
movl (%rsp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0xc2e7
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0x9d29(%rip), %rsi      # 0x16007
movb $0x0, %al
callq 0x5110
jmp 0xc30b
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0x9d0d(%rip), %rsi      # 0x16011
movb $0x0, %al
callq 0x5110
movl (%rsp), %eax
andl $0xf, %eax
cmpl $0xf, %eax
jne 0xc329
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movl $0xa, %edi
callq 0x5100
jmp 0xc32b
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0xc2a9
movl 0x4(%rsp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0xc358
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movl $0xa, %edi
callq 0x5100
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_asm.c
// Function: emit_asm_reloc
static void emit_asm_reloc(BuildCtx *ctx, int type, const char *sym)
{
  switch (ctx->mode) {
  case BUILD_elfasm:
    if (type)
      fprintf(ctx->fp, "\t.long %s-.-4\n", sym);
    else
      fprintf(ctx->fp, "\t.long %s\n", sym);
    break;
  case BUILD_coffasm:
    fprintf(ctx->fp, "\t.def %s; .scl 3; .type 32; .endef\n", sym);
    if (type)
      fprintf(ctx->fp, "\t.long %s-.-4\n", sym);
    else
      fprintf(ctx->fp, "\t.long %s\n", sym);
    break;
  default:  /* BUILD_machasm for relative relocations handled below. */
    fprintf(ctx->fp, "\t.long %s\n", sym);
    break;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0xc392
jmp 0xc384
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0xc3d5
jmp 0xc434
cmpl $0x0, 0x1c(%rsp)
je 0xc3b7
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x9c67(%rip), %rsi      # 0x16015
movb $0x0, %al
callq 0x5110
jmp 0xc3d3
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x9c58(%rip), %rsi      # 0x16024
movb $0x0, %al
callq 0x5110
jmp 0xc450
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x9b65(%rip), %rsi      # 0x15f4f
movb $0x0, %al
callq 0x5110
cmpl $0x0, 0x1c(%rsp)
je 0xc416
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x9c08(%rip), %rsi      # 0x16015
movb $0x0, %al
callq 0x5110
jmp 0xc432
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x9bf9(%rip), %rsi      # 0x16024
movb $0x0, %al
callq 0x5110
jmp 0xc450
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x9bdb(%rip), %rsi      # 0x16024
movb $0x0, %al
callq 0x5110
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_peobj.c
// Function: emit_peobj_sym
static void emit_peobj_sym(BuildCtx *ctx, const char *name, uint32_t value,
			   int sect, int type, int scl)
{
  PEsym sym;
  size_t len = strlen(name);
  if (!strtab) {  /* Pass 1: only calculate string table length. */
    if (len > 8) strtabofs += len+1;
    return;
  }
  if (len <= 8) {
    memcpy(sym.n.name, name, len);
    memset(sym.n.name+len, 0, 8-len);
  } else {
    sym.n.nameref[0] = 0;
    sym.n.nameref[1] = (uint32_t)strtabofs;
    memcpy(strtab + strtabofs, name, len);
    strtab[strtabofs+len] = 0;
    strtabofs += len+1;
  }
  sym.value = value;
  sym.sect = (int16_t)(sect+1);  /* 1-based section number. */
  sym.type = (uint16_t)type;
  sym.scl = (uint8_t)scl;
  sym.naux = 0;
  owrite(ctx, &sym, PEOBJ_SYM_SIZE);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movl %r9d, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x50a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0xd491(%rip)      # 0x1a1a8
jne 0xcd3d
cmpq $0x8, 0x8(%rsp)
jbe 0xcd38
movq 0x8(%rsp), %rax
addq $0x1, %rax
addq 0xd47f(%rip), %rax      # 0x1a1b0
movq %rax, 0xd478(%rip)      # 0x1a1b0
jmp 0xce12
cmpq $0x8, 0x8(%rsp)
ja 0xcd76
leaq 0x14(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x5120
leaq 0x14(%rsp), %rdi
addq 0x8(%rsp), %rdi
movl $0x8, %edx
subq 0x8(%rsp), %rdx
xorl %esi, %esi
callq 0x50c0
jmp 0xcdd4
movl $0x0, 0x14(%rsp)
movq 0xd42b(%rip), %rax      # 0x1a1b0
movl %eax, 0x18(%rsp)
movq 0xd418(%rip), %rdi      # 0x1a1a8
addq 0xd419(%rip), %rdi      # 0x1a1b0
movq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x5120
movq 0xd3fb(%rip), %rax      # 0x1a1a8
movq 0xd3fc(%rip), %rcx      # 0x1a1b0
addq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
addq 0xd3e3(%rip), %rax      # 0x1a1b0
movq %rax, 0xd3dc(%rip)      # 0x1a1b0
movl 0x34(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movw %ax, 0x20(%rsp)
movl 0x2c(%rsp), %eax
movw %ax, 0x22(%rsp)
movl 0x28(%rsp), %eax
movb %al, 0x24(%rsp)
movb $0x0, 0x25(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x14(%rsp), %rsi
movl $0x12, %edx
callq 0x7500
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_peobj.c
// Function: emit_peobj_sym_sect
static void emit_peobj_sym_sect(BuildCtx *ctx, PEsection *pesect, int sect)
{
  PEsym sym;
  PEsymaux aux;
  if (!strtab) return;  /* Pass 1: no output. */
  memcpy(sym.n.name, pesect[sect].name, 8);
  sym.value = 0;
  sym.sect = (int16_t)(sect+1);  /* 1-based section number. */
  sym.type = PEOBJ_TYPE_NULL;
  sym.scl = PEOBJ_SCL_STATIC;
  sym.naux = 1;
  owrite(ctx, &sym, PEOBJ_SYM_SIZE);
  memset(&aux, 0, sizeof(PEsymaux));
  aux.size = pesect[sect].size;
  aux.nreloc = pesect[sect].nreloc;
  owrite(ctx, &aux, PEOBJ_SYM_SIZE);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
cmpq $0x0, 0xd36e(%rip)      # 0x1a1a8
jne 0xce41
jmp 0xceea
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movw %ax, 0x2c(%rsp)
movw $0x0, 0x2e(%rsp)
movb $0x3, 0x30(%rsp)
movb $0x1, 0x31(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x12, %edx
callq 0x7500
leaq 0xc(%rsp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x50c0
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movw 0x20(%rax), %ax
movw %ax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x12, %edx
callq 0x7500
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_lib.c
// Function: libdef_endmodule
static void libdef_endmodule(BuildCtx *ctx)
{
  if (modstate != 0) {
    char line[80];
    const uint8_t *p;
    int n;
    if (modstate == 1)
      fprintf(ctx->fp, "  (lua_CFunction)0");
    fprintf(ctx->fp, "\n};\n");
    fprintf(ctx->fp, "static const uint8_t %s%s[] = {\n",
	    LABEL_PREFIX_LIBINIT, modname);
    line[0] = '\0';
    for (n = 0, p = obuf; p < optr; p++) {
      n += sprintf(line+n, "%d,", *p);
      if (n >= 75) {
	fprintf(ctx->fp, "%s\n", line);
	n = 0;
	line[0] = '\0';
      }
    }
    fprintf(ctx->fp, "%s%d\n};\n#endif\n\n", line, LIBINIT_END);
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
cmpl $0x0, 0xcc2c(%rip)      # 0x1a1cc
je 0xd6b7
cmpl $0x1, 0xcc1f(%rip)      # 0x1a1cc
jne 0xd5c6
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x8e79(%rip), %rsi      # 0x16438
movb $0x0, %al
callq 0x5110
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x8e75(%rip), %rsi      # 0x1644b
movb $0x0, %al
callq 0x5110
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x8e63(%rip), %rsi      # 0x16450
leaq 0x8e7d(%rip), %rdx      # 0x16471
leaq 0xebf5(%rip), %rcx      # 0x1c1f0
movb $0x0, %al
callq 0x5110
movb $0x0, 0x10(%rsp)
movl $0x0, 0x4(%rsp)
leaq 0xcbca(%rip), %rax      # 0x1a1e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0xebb9(%rip), %rax      # 0x1c1e0
jae 0xd696
leaq 0x10(%rsp), %rdi
movslq 0x4(%rsp), %rax
addq %rax, %rdi
movq 0x8(%rsp), %rax
movzbl (%rax), %edx
leaq 0x8e39(%rip), %rsi      # 0x1647e
movb $0x0, %al
callq 0x5180
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
cmpl $0x4b, 0x4(%rsp)
jl 0xd684
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x10(%rsp), %rdx
leaq 0x6feb(%rip), %rsi      # 0x1465b
movb $0x0, %al
callq 0x5110
movl $0x0, 0x4(%rsp)
movb $0x0, 0x10(%rsp)
jmp 0xd686
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xd61b
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x10(%rsp), %rdx
leaq 0x8dd7(%rip), %rsi      # 0x16482
movl $0xff, %ecx
movb $0x0, %al
callq 0x5110
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_lib.c
// Function: libdef_module
static void libdef_module(BuildCtx *ctx, char *p, int arg)
{
  UNUSED(arg);
  if (ctx->mode == BUILD_libdef) {
    libdef_endmodule(ctx);
    optr = obuf;
    *optr++ = (uint8_t)ffid;
    *optr++ = (uint8_t)ffasmfunc;
    *optr++ = 0;  /* Hash table size. */
    modstate = 1;
    fprintf(ctx->fp, "#ifdef %sMODULE_%s\n", LIBDEF_PREFIX, p);
    fprintf(ctx->fp, "#undef %sMODULE_%s\n", LIBDEF_PREFIX, p);
    fprintf(ctx->fp, "static const lua_CFunction %s%s[] = {\n",
	    LABEL_PREFIX_LIBCF, p);
  }
  modnamelen = strlen(p);
  if (modnamelen > sizeof(modname)-1) {
    fprintf(stderr, "Error: module name too long: '%s'\n", p);
    exit(1);
  }
  strcpy(modname, p);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x7, 0x8(%rax)
jne 0xd7c2
movq 0x10(%rsp), %rdi
callq 0xd590
leaq 0xcaee(%rip), %rax      # 0x1a1e0
movq %rax, 0xeae7(%rip)      # 0x1c1e0
movl 0xcac1(%rip), %eax      # 0x1a1c0
movb %al, %cl
movq 0xead8(%rip), %rax      # 0x1c1e0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0xeaca(%rip)      # 0x1c1e0
movb %cl, (%rax)
movl 0xcaaa(%rip), %eax      # 0x1a1c8
movb %al, %cl
movq 0xeab9(%rip), %rax      # 0x1c1e0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0xeaab(%rip)      # 0x1c1e0
movb %cl, (%rax)
movq 0xeaa2(%rip), %rax      # 0x1c1e0
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xea94(%rip)      # 0x1c1e0
movb $0x0, (%rax)
movl $0x1, 0xca73(%rip)      # 0x1a1cc
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rcx
leaq 0x8b20(%rip), %rsi      # 0x1628e
leaq 0x89c5(%rip), %rdx      # 0x1613a
movb $0x0, %al
callq 0x5110
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rcx
leaq 0x8b11(%rip), %rsi      # 0x162a2
leaq 0x89a2(%rip), %rdx      # 0x1613a
movb $0x0, %al
callq 0x5110
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rcx
leaq 0x8b02(%rip), %rsi      # 0x162b6
leaq 0x8b22(%rip), %rdx      # 0x162dd
movb $0x0, %al
callq 0x5110
movq 0x8(%rsp), %rdi
callq 0x50a0
movq %rax, 0xea15(%rip)      # 0x1c1e8
cmpq $0x4f, 0xea0d(%rip)     # 0x1c1e8
jbe 0xd804
movq 0xc814(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x8af5(%rip), %rsi      # 0x162e8
movb $0x0, %al
callq 0x5110
movl $0x1, %edi
callq 0x5190
movq 0x8(%rsp), %rsi
leaq 0xe9e0(%rip), %rdi      # 0x1c1f0
callq 0x5060
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_lib.c
// Function: libdef_rec
static void libdef_rec(BuildCtx *ctx, char *p, int arg)
{
  UNUSED(arg);
  if (ctx->mode == BUILD_recdef) {
    char *q;
    uint32_t n;
    for (; recffid+1 < ffid; recffid++)
      fprintf(ctx->fp, ",\n0");
    recffid = ffid;
    if (*p == '.') p = funcname;
    q = strchr(p, ' ');
    if (q) *q++ = '\0';
    n = find_rec(p);
    if (q)
      fprintf(ctx->fp, ",\n0x%02x00+(%s)", n, q);
    else
      fprintf(ctx->fp, ",\n0x%02x00", n);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x8, 0x8(%rax)
jne 0xdc46
jmp 0xdb63
movl 0xc65b(%rip), %eax      # 0x1a1c4
addl $0x1, %eax
cmpl 0xc64e(%rip), %eax      # 0x1a1c0
jge 0xdb9c
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x8868(%rip), %rsi      # 0x163ec
movb $0x0, %al
callq 0x5110
movl 0xc633(%rip), %eax      # 0x1a1c4
addl $0x1, %eax
movl %eax, 0xc62a(%rip)      # 0x1a1c4
jmp 0xdb63
movl 0xc61e(%rip), %eax      # 0x1a1c0
movl %eax, 0xc61c(%rip)      # 0x1a1c4
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xdbc1
leaq 0xe684(%rip), %rax      # 0x1c240
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x20, %esi
callq 0x50b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xdbf1
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movb $0x0, (%rax)
movq 0x18(%rsp), %rdi
callq 0xe200
movl %eax, 0x4(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xdc29
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x4(%rsp), %edx
movq 0x8(%rsp), %rcx
leaq 0x87d0(%rip), %rsi      # 0x163f0
movb $0x0, %al
callq 0x5110
jmp 0xdc44
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x4(%rsp), %edx
leaq 0x87c3(%rip), %rsi      # 0x16400
movb $0x0, %al
callq 0x5110
jmp 0xdc46
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_lib.c
// Function: libdef_set
static void libdef_set(BuildCtx *ctx, char *p, int arg)
{
  UNUSED(arg);
  if (ctx->mode == BUILD_libdef) {
    if (p[0] == '!' && p[1] == '\0') p[0] = '\0';  /* Set env. */
    libdef_name(p, LIBINIT_STRING);
    *optr++ = LIBINIT_SET;
    obuf[2]++;  /* Bump hash table size. */
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x7, 0x8(%rax)
jne 0xdf85
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x21, %eax
jne 0xdf50
movq 0x8(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0xdf50
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x8(%rsp), %rdi
movl $0xc0, %esi
callq 0xdfb0
movq 0xe27a(%rip), %rax      # 0x1c1e0
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xe26c(%rip)      # 0x1c1e0
movb $-0x6, (%rax)
movb 0xc265(%rip), %al       # 0x1a1e2
addb $0x1, %al
movb %al, 0xc25d(%rip)       # 0x1a1e2
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_lib.c
// Function: libdef_name
static void libdef_name(const char *p, int kind)
{
  size_t n = strlen(p);
  if (kind != LIBINIT_STRING) {
    if (n > modnamelen && p[modnamelen] == '_' &&
	!strncmp(p, modname, modnamelen)) {
      p += modnamelen+1;
      n -= modnamelen+1;
    }
  }
  if (n > LIBINIT_MAXSTR) {
    fprintf(stderr, "Error: string too long: '%s'\n",  p);
    exit(1);
  }
  if (optr+1+n+2 > obuf+sizeof(obuf)) {  /* +2 for caller. */
    fprintf(stderr, "Error: output buffer overflow\n");
    exit(1);
  }
  *optr++ = (uint8_t)(n | kind);
  memcpy(optr, p, n);
  optr += n;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x50a0
movq %rax, (%rsp)
cmpl $0xc0, 0xc(%rsp)
je 0xe041
movq (%rsp), %rax
cmpq 0xe208(%rip), %rax      # 0x1c1e8
jbe 0xe03f
movq 0x10(%rsp), %rax
movq 0xe1fa(%rip), %rcx      # 0x1c1e8
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
jne 0xe03f
movq 0x10(%rsp), %rdi
movq 0xe1e5(%rip), %rdx      # 0x1c1e8
leaq 0xe1e6(%rip), %rsi      # 0x1c1f0
callq 0x5050
cmpl $0x0, %eax
jne 0xe03f
movq 0xe1cd(%rip), %rax      # 0x1c1e8
addq $0x1, %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xe1b8(%rip), %rcx      # 0x1c1e8
addq $0x1, %rcx
movq (%rsp), %rax
subq %rcx, %rax
movq %rax, (%rsp)
jmp 0xe041
cmpq $0x39, (%rsp)
jbe 0xe06f
movq 0xbfa9(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x8344(%rip), %rsi      # 0x163a2
movb $0x0, %al
callq 0x5110
movl $0x1, %edi
callq 0x5190
movq 0xe16a(%rip), %rax      # 0x1c1e0
addq $0x1, %rax
addq (%rsp), %rax
addq $0x2, %rax
leaq 0xc157(%rip), %rcx      # 0x1a1e0
addq $0x2000, %rcx           # imm = 0x2000
cmpq %rcx, %rax
jbe 0xe0b7
movq 0xbf5c(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x8292(%rip), %rsi      # 0x16338
movb $0x0, %al
callq 0x5110
movl $0x1, %edi
callq 0x5190
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
orq %rcx, %rax
movb %al, %cl
movq 0xe114(%rip), %rax      # 0x1c1e0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0xe106(%rip)      # 0x1c1e0
movb %cl, (%rax)
movq 0xe0fd(%rip), %rdi      # 0x1c1e0
movq 0x10(%rsp), %rsi
movq (%rsp), %rdx
callq 0x5120
movq (%rsp), %rax
addq 0xe0e4(%rip), %rax      # 0x1c1e0
movq %rax, 0xe0dd(%rip)      # 0x1c1e0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_lib.c
// Function: find_ffofs
static int find_ffofs(BuildCtx *ctx, const char *name)
{
  int i;
  for (i = 0; i < ctx->nglob; i++) {
    const char *gl = ctx->globnames[i];
    if (gl[0] == 'f' && gl[1] == 'f' && gl[2] == '_' && !strcmp(gl+3, name)) {
      return (int)((uint8_t *)ctx->glob[i] - ctx->code);
    }
  }
  fprintf(stderr, "Error: undefined fast function %s%s\n",
	  LABEL_PREFIX_FF, name);
  exit(1);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x3c(%rcx), %eax
jge 0xe1c5
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x66, %eax
jne 0xe1b3
movq 0x8(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x66, %eax
jne 0xe1b3
movq 0x8(%rsp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x5f, %eax
jne 0xe1b3
movq 0x8(%rsp), %rdi
addq $0x3, %rdi
movq 0x18(%rsp), %rsi
callq 0x50f0
cmpl $0x0, %eax
jne 0xe1b3
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
movq 0x28(%rcx), %rcx
subq %rcx, %rax
addq $0x28, %rsp
retq
jmp 0xe1b5
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xe126
movq 0xbe2c(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
movq 0x18(%rsp), %rcx
leaq 0x81e5(%rip), %rsi      # 0x163c0
leaq 0x8203(%rip), %rdx      # 0x163e5
movb $0x0, %al
callq 0x5110
movl $0x1, %edi
callq 0x5190
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_lib.c
// Function: find_rec
static uint32_t find_rec(char *name)
{
  char *p = (char *)obuf;
  uint32_t n;
  for (n = 2; *p; n++) {
    if (strcmp(p, name) == 0)
      return n;
    p += strlen(p)+1;
  }
  if (p+strlen(name)+1 >= (char *)obuf+sizeof(obuf)) {
    fprintf(stderr, "Error: output buffer overflow\n");
    exit(1);
  }
  strcpy(p, name);
  return n;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
leaq 0xbfd0(%rip), %rax      # 0x1a1e0
movq %rax, 0x10(%rsp)
movl $0x2, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0xe26d
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x50f0
cmpl $0x0, %eax
jne 0xe248
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xe2da
movq 0x10(%rsp), %rdi
callq 0x50a0
addq $0x1, %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xe21d
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x50a0
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
addq $0x1, %rax
leaq 0xbf4b(%rip), %rcx      # 0x1a1e0
addq $0x2000, %rcx           # imm = 0x2000
cmpq %rcx, %rax
jb 0xe2c3
movq 0xbd50(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x8086(%rip), %rsi      # 0x16338
movb $0x0, %al
callq 0x5110
movl $0x1, %edi
callq 0x5190
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5060
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_lib.c
// Function: memcpy_endian
static void memcpy_endian(void *dst, void *src, size_t n)
{
  union { uint8_t b; uint32_t u; } host_endian;
  host_endian.u = 1;
  if (host_endian.b == LJ_ENDIAN_SELECT(1, 0)) {
    memcpy(dst, src, n);
  } else {
    size_t i;
    for (i = 0; i < n; i++)
      ((uint8_t *)dst)[i] = ((uint8_t *)src)[n-i-1];
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movzbl 0xc(%rsp), %eax
cmpl $0x1, %eax
jne 0xe32b
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x5120
jmp 0xe36f
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0xe36d
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
subq (%rsp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %dl
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0xe333
jmp 0xe36f
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_fold.c
// Function: foldrule
static void foldrule(char *p)
{
  uint32_t op = nexttoken(&p, 0, 0);
  uint32_t left = nexttoken(&p, 0, 0x7f);
  uint32_t right = nexttoken(&p, 1, 0x3ff);
  uint32_t key = (funcidx << 24) | (op << 17) | (left << 10) | right;
  uint32_t i;
  if (nkeys >= BUILD_MAX_FOLD) {
    fprintf(stderr, "Error: too many fold rules, increase BUILD_MAX_FOLD.\n");
    exit(1);
  }
  /* Simple insertion sort to detect duplicates. */
  for (i = nkeys; i > 0; i--) {
    if ((foldkeys[i-1]&0xffffff) < (key & 0xffffff))
      break;
    if ((foldkeys[i-1]&0xffffff) == (key & 0xffffff)) {
      fprintf(stderr, "Error: duplicate fold definition at line %d\n", lineno);
      exit(1);
    }
    foldkeys[i] = foldkeys[i-1];
  }
  foldkeys[i] = key;
  nkeys++;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xe9c0
movl %eax, 0x1c(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x7f, %edx
callq 0xe9c0
movl %eax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0xe9c0
movl %eax, 0x14(%rsp)
movl 0xdb86(%rip), %eax      # 0x1c294
shll $0x18, %eax
movl 0x1c(%rsp), %ecx
shll $0x11, %ecx
orl %ecx, %eax
movl 0x18(%rsp), %ecx
shll $0xa, %ecx
orl %ecx, %eax
orl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
cmpl $0x1000, 0xdb63(%rip)   # imm = 0x1000
jb 0xe759
movq 0xb8ba(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x7ddb(%rip), %rsi      # 0x16523
movb $0x0, %al
callq 0x5110
movl $0x1, %edi
callq 0x5190
movl 0xdb39(%rip), %eax      # 0x1c298
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jbe 0xe820
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xdb20(%rip), %rax      # 0x1c2a0
movl (%rax,%rcx,4), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl 0x10(%rsp), %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
cmpl %ecx, %eax
jae 0xe79b
jmp 0xe820
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xdaf3(%rip), %rax      # 0x1c2a0
movl (%rax,%rcx,4), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl 0x10(%rsp), %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
cmpl %ecx, %eax
jne 0xe7eb
movq 0xb82e(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
movl 0xdabd(%rip), %edx      # 0x1c290
leaq 0x7d7f(%rip), %rsi      # 0x16559
movb $0x0, %al
callq 0x5110
movl $0x1, %edi
callq 0x5190
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xdaa3(%rip), %rax      # 0x1c2a0
movl (%rax,%rcx,4), %edx
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0xda93(%rip), %rax      # 0x1c2a0
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xe763
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0xda6f(%rip), %rax      # 0x1c2a0
movl %edx, (%rax,%rcx,4)
movl 0xda5e(%rip), %eax      # 0x1c298
addl $0x1, %eax
movl %eax, 0xda55(%rip)      # 0x1c298
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_fold.c
// Function: makehash
static void makehash(BuildCtx *ctx)
{
  uint32_t htab[BUILD_MAX_FOLD*2+1];
  uint32_t sz, r;
  /* Search for the smallest hash table with an odd size. */
  for (sz = (nkeys|1); sz < BUILD_MAX_FOLD*2; sz += 2) {
    /* First try all shift hash combinations. */
    for (r = 0; r < 32*32; r++) {
      if (tryhash(htab, sz, r, 0)) {
	printhash(ctx, htab, sz);
	fprintf(ctx->fp,
		"#define fold_hashkey(k)\t(((((k)<<%u)-(k))<<%u)%%%u)\n\n",
		r>>5, r&31, sz);
	return;
      }
    }
    /* Then try all rotate hash combinations. */
    for (r = 0; r < 32*32; r++) {
      if (tryhash(htab, sz, r, 1)) {
	printhash(ctx, htab, sz);
	fprintf(ctx->fp,
	  "#define fold_hashkey(k)\t(lj_rol(lj_rol((k),%u)-(k),%u)%%%u)\n\n",
		r>>5, r&31, sz);
	return;
      }
    }
  }
  fprintf(stderr, "Error: search for perfect hash failed\n");
  exit(1);
}

// Assembly:
subq $0x8028, %rsp           # imm = 0x8028
movq %rdi, 0x8020(%rsp)
movl 0xda33(%rip), %eax      # 0x1c298
orl $0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x2000, 0xc(%rsp)      # imm = 0x2000
jae 0xe990
movl $0x0, 0x8(%rsp)
cmpl $0x400, 0x8(%rsp)       # imm = 0x400
jae 0xe8fc
leaq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
xorl %ecx, %ecx
callq 0xee40
cmpl $0x0, %eax
je 0xe8ed
movq 0x8020(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0xf150
movq 0x8020(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x8(%rsp), %edx
shrl $0x5, %edx
movl 0x8(%rsp), %ecx
andl $0x1f, %ecx
movl 0xc(%rsp), %r8d
leaq 0x7cf8(%rip), %rsi      # 0x165d9
movb $0x0, %al
callq 0x5110
jmp 0xe9b2
jmp 0xe8ef
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xe882
movl $0x0, 0x8(%rsp)
cmpl $0x400, 0x8(%rsp)       # imm = 0x400
jae 0xe97e
leaq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
movl $0x1, %ecx
callq 0xee40
cmpl $0x0, %eax
je 0xe96f
movq 0x8020(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0xf150
movq 0x8020(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x8(%rsp), %edx
shrl $0x5, %edx
movl 0x8(%rsp), %ecx
andl $0x1f, %ecx
movl 0xc(%rsp), %r8d
leaq 0x7ca9(%rip), %rsi      # 0x1660f
movb $0x0, %al
callq 0x5110
jmp 0xe9b2
jmp 0xe971
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xe904
jmp 0xe980
movl 0xc(%rsp), %eax
addl $0x2, %eax
movl %eax, 0xc(%rsp)
jmp 0xe86c
movq 0xb661(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x7cac(%rip), %rsi      # 0x1664d
movb $0x0, %al
callq 0x5110
movl $0x1, %edi
callq 0x5190
addq $0x8028, %rsp           # imm = 0x8028
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm_fold.c
// Function: printhash
static void printhash(BuildCtx *ctx, uint32_t *htab, uint32_t sz)
{
  uint32_t i;
  fprintf(ctx->fp, "static const uint32_t fold_hash[%d] = {\n0x%08x",
	  sz+1, htab[0]);
  for (i = 1; i < sz+1; i++)
    fprintf(ctx->fp, ",\n0x%08x", htab[i]);
  fprintf(ctx->fp, "\n};\n\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x4(%rsp), %edx
addl $0x1, %edx
movq 0x8(%rsp), %rax
movl (%rax), %ecx
leaq 0x74f4(%rip), %rsi      # 0x16674
movb $0x0, %al
callq 0x5110
movl $0x1, (%rsp)
movl (%rsp), %eax
movl 0x4(%rsp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jae 0xf1c9
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
movl (%rsp), %ecx
movl (%rax,%rcx,4), %edx
leaq 0x74ec(%rip), %rsi      # 0x166a3
movb $0x0, %al
callq 0x5110
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0xf18e
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x702e(%rip), %rsi      # 0x16207
movb $0x0, %al
callq 0x5110
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stevenmherring[P]DNS/sequential-trie.c
// Function: new_leaf
struct trie_node * new_leaf (const char *string, size_t strlen, int32_t ip4_address) {
  struct trie_node *new_node = malloc(sizeof(struct trie_node));
  if (!new_node) {
    printf ("WARNING: Node memory allocation failed.  Results may be bogus.\n");
    return NULL;
  }
  assert(strlen < 64);
  assert(strlen > 0);
  new_node->next = NULL;
  new_node->strlen = strlen;
  strncpy(new_node->key, string, strlen);
  new_node->key[strlen] = '\0';
  new_node->ip4_address = ip4_address;
  new_node->children = NULL;

  return new_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x58, %edi
callq 0x10f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x12d3
leaq 0x1d45(%rip), %rdi      # 0x3004
movb $0x0, %al
callq 0x1070
movq $0x0, -0x8(%rbp)
jmp 0x137b
cmpq $0x40, -0x18(%rbp)
jae 0x12dc
jmp 0x12fb
leaq 0x1e52(%rip), %rdi      # 0x3135
leaq 0x1d5a(%rip), %rsi      # 0x3044
movl $0x1c, %edx
leaq 0x1d60(%rip), %rcx      # 0x3056
callq 0x1080
cmpq $0x0, -0x18(%rbp)
jbe 0x1304
jmp 0x1323
leaq 0x1d85(%rip), %rdi      # 0x3090
leaq 0x1d32(%rip), %rsi      # 0x3044
movl $0x1d, %edx
leaq 0x1d38(%rip), %rcx      # 0x3056
callq 0x1080
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1050
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, 0x18(%rax,%rcx)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stevenmherring[P]DNS/sequential-trie.c
// Function: compare_keys
int compare_keys (const char *string1, int len1, const char *string2, int len2, int *pKeylen) {
  int keylen, offset1, offset2;
  keylen = len1 < len2 ? len1 : len2;
  offset1 = len1 - keylen;
  offset2 = len2 - keylen;
  assert (keylen > 0);
  if (pKeylen)
  *pKeylen = keylen;
  return strncmp(&string1[offset1], &string2[offset2], keylen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x13ba
movl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x13c0
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x13e0
jmp 0x13ff
leaq 0x1cb4(%rip), %rdi      # 0x309b
leaq 0x1c56(%rip), %rsi      # 0x3044
movl $0x2d, %edx
leaq 0x1cac(%rip), %rcx      # 0x30a6
callq 0x1080
cmpq $0x0, -0x28(%rbp)
je 0x140f
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movslq -0x30(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x34(%rbp), %rax
addq %rax, %rsi
movslq -0x2c(%rbp), %rdx
callq 0x1060
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stevenmherring[P]DNS/sequential-trie.c
// Function: search
struct trie_node *
_search (struct trie_node *node, const char *string, size_t strlen) {

  int keylen, cmp;

  // First things first, check if we are NULL
  if (node == NULL) return NULL;

  assert(node->strlen < 64);

  // See if this key is a substring of the string passed in
  cmp = compare_keys(node->key, node->strlen, string, strlen, &keylen);
  if (cmp == 0) {
    // Yes, either quit, or recur on the children

    // If this key is longer than our search string, the key isn't here
    if (node->strlen > keylen) {
      return NULL;
    } else if (strlen > keylen) {
      // Recur on children list
      return _search(node->children, string, strlen - keylen);
    } else {
      assert (strlen == keylen);

      return node;
    }

  } else if (cmp < 0) {
    // No, look right (the node's key is "less" than the search key)
    return _search(node->next, string, strlen);
  } else {
    // Quit early
    return 0;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x14a8
movq $0x0, -0x8(%rbp)
jmp 0x15aa
movq -0x10(%rbp), %rax
cmpl $0x40, 0x8(%rax)
jae 0x14b4
jmp 0x14d3
leaq 0x1c74(%rip), %rdi      # 0x312f
leaq 0x1b82(%rip), %rsi      # 0x3044
movl $0x47, %edx
leaq 0x1c73(%rip), %rcx      # 0x3141
callq 0x1080
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movl %eax, %ecx
leaq -0x24(%rbp), %r8
callq 0x1390
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x1582
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x24(%rbp), %eax
jbe 0x151b
movq $0x0, -0x8(%rbp)
jmp 0x15aa
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x154a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movslq -0x24(%rbp), %rax
subq %rax, %rdx
callq 0x1480
movq %rax, -0x8(%rbp)
jmp 0x15aa
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq %rcx, %rax
jne 0x1559
jmp 0x1578
leaq 0x1c25(%rip), %rdi      # 0x3185
leaq 0x1add(%rip), %rsi      # 0x3044
movl $0x55, %edx
leaq 0x1bce(%rip), %rcx      # 0x3141
callq 0x1080
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15aa
cmpl $0x0, -0x28(%rbp)
jge 0x15a2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1480
movq %rax, -0x8(%rbp)
jmp 0x15aa
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)