LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32i386.c
// Function: i386_reloc_elf2vlink
static uint8_t i386_reloc_elf2vlink(uint8_t rtype,struct RelocInsert *ri)
/* Determine vlink internal reloc type from ELF reloc type and fill in
   reloc-insert description informations.
   All fields of the RelocInsert structure are preset to zero. */
{
  /* Reloc conversion table for V.4-ABI */
  static struct ELF2vlink convertV4[] = {
    R_NONE,0,0,-1,
    R_ABS,0,32,-1,              /* R_386_32 */
    R_PC,0,32,-1,               /* R_386_PC32 */
    R_GOT,0,32,-1,              /* R_386_GOT32 */
    R_PLT,0,32,-1,              /* R_386_PLT32 */
    R_COPY,0,32,-1,             /* R_386_COPY */
    R_GLOBDAT,0,32,-1,          /* R_386_GLOB_DAT */
    R_JMPSLOT,0,0,-1,           /* R_386_JMP_SLOT */
    R_LOADREL,0,32,-1,          /* R_386_RELATIVE */
    R_GOTOFF,0,32,-1,           /* R_386_GOTOFF */
    R_GOTPC,0,32,-1             /* R_386_GOTPC */
  };

  if (rtype <= R_386_GOTPC) {
    ri->bpos = convertV4[rtype].bpos;
    ri->bsiz = convertV4[rtype].bsiz;
    ri->mask = convertV4[rtype].mask;
    rtype = convertV4[rtype].rtype;
  }
  else
    rtype = R_NONE;

  return (rtype);
}

// Assembly:
movb %dil, %al
movb %al, -0x1(%rsp)
movq %rsi, -0x10(%rsp)
movzbl -0x1(%rsp), %eax
cmpl $0xa, %eax
jg 0x2a38d
movzbl -0x1(%rsp), %eax
movl %eax, %ecx
leaq 0x16b08(%rip), %rax     # 0x40e20
shlq $0x4, %rcx
addq %rcx, %rax
movw 0x2(%rax), %cx
movq -0x10(%rsp), %rax
movw %cx, 0x8(%rax)
movzbl -0x1(%rsp), %eax
movl %eax, %ecx
leaq 0x16ae6(%rip), %rax     # 0x40e20
shlq $0x4, %rcx
addq %rcx, %rax
movw 0x4(%rax), %cx
movq -0x10(%rsp), %rax
movw %cx, 0xa(%rax)
movzbl -0x1(%rsp), %eax
movl %eax, %ecx
leaq 0x16ac4(%rip), %rax     # 0x40e20
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movzbl -0x1(%rsp), %eax
movl %eax, %ecx
leaq 0x16aa2(%rip), %rax     # 0x40e20
shlq $0x4, %rcx
addq %rcx, %rax
movb (%rax), %al
movb %al, -0x1(%rsp)
jmp 0x2a392
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32i386.c
// Function: i386_reloc_vlink2elf
static uint8_t i386_reloc_vlink2elf(struct Reloc *r)
/* Try to map vlink-internal representation to a valid ELF reloc type */
{
  struct RelocInsert *ri;

  if (ri = r->insert) {
    if (ri->bpos==0 && ri->bsiz==32 &&
        (ri->mask & 0xffffffff)==0xffffffff && ri->next==NULL) {
      switch (r->rtype) {
        case R_ABS: return R_386_32;
        case R_PC: return R_386_PC32;
        case R_GOT: return R_386_GOT32;
        case R_PLT: return R_386_PLT32;
        case R_COPY: return R_386_COPY;
        case R_GLOBDAT: return R_386_GLOB_DAT;
        case R_JMPSLOT: return R_386_JMP_SLOT;
        case R_GOTOFF: return R_386_GOTOFF;
        case R_GOTPC: return R_386_GOTPC;
      }
    }
  }

  return R_NONE;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, %rax
je 0x2a478
movq -0x18(%rsp), %rax
movzwl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0x2a476
movq -0x18(%rsp), %rax
movzwl 0xa(%rax), %eax
cmpl $0x20, %eax
jne 0x2a476
movq -0x18(%rsp), %rcx
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq 0x10(%rcx), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jne 0x2a476
movq -0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x2a476
movq -0x10(%rsp), %rax
movzbl 0x38(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rsp)
subl $0xe, %eax
ja 0x2a474
movq -0x20(%rsp), %rax
leaq 0xc7e0(%rip), %rcx      # 0x36c0c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rsp)
jmp 0x2a47d
movb $0x2, -0x1(%rsp)
jmp 0x2a47d
movb $0x3, -0x1(%rsp)
jmp 0x2a47d
movb $0x4, -0x1(%rsp)
jmp 0x2a47d
movb $0x5, -0x1(%rsp)
jmp 0x2a47d
movb $0x6, -0x1(%rsp)
jmp 0x2a47d
movb $0x7, -0x1(%rsp)
jmp 0x2a47d
movb $0x9, -0x1(%rsp)
jmp 0x2a47d
movb $0xa, -0x1(%rsp)
jmp 0x2a47d
jmp 0x2a476
jmp 0x2a478
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32arm.c
// Function: armle_readconv
static void armle_readconv(struct GlobalVars *gv,struct LinkFile *lf)
/* Read ELF-ARM little-endian executable / object / shared obj. */
{
  if (lf->type == ID_LIBARCH) {
    struct ar_info ai;

    if (ar_init(&ai,(char *)lf->data,lf->length,lf->filename)) {
      while (ar_extract(&ai)) {
        lf->objname = allocstring(ai.name);
        elf32_check_ar_type(fff[lf->format],lf->pathname,
                            (struct Elf32_Ehdr *)ai.data,
                            ELFCLASS32,ELFDATA2LSB,ELF_VER,1,EM_ARM);
        elf32_parse(gv,lf,(struct Elf32_Ehdr *)ai.data,armle_reloc_elf2vlink);
      }
    }
    else
      ierror("armle_readconv(): archive %s corrupted since last access",
             lf->pathname);
  }
  else {
    lf->objname = lf->filename;
    elf32_parse(gv,lf,(struct Elf32_Ehdr *)lf->data,armle_reloc_elf2vlink);
  }
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq 0x148(%rsp), %rax
movzbl 0x39(%rax), %eax
cmpl $0x8, %eax
jne 0x2a60b
movq 0x148(%rsp), %rax
movq 0x28(%rax), %rsi
movq 0x148(%rsp), %rax
movq 0x30(%rax), %rdx
movq 0x148(%rsp), %rax
movq 0x18(%rax), %rcx
leaq 0x10(%rsp), %rdi
callq 0x13d60
cmpl $0x0, %eax
je 0x2a5ef
jmp 0x2a545
leaq 0x10(%rsp), %rdi
callq 0x13e00
cmpl $0x0, %eax
je 0x2a5ed
leaq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x72d0
movq %rax, %rcx
movq 0x148(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x148(%rsp), %rax
movzbl 0x38(%rax), %eax
movl %eax, %ecx
leaq 0x154a6(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rdi
movq 0x148(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x138(%rsp), %rdx
movl $0x1, %r9d
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x1, (%rsp)
movl $0x28, 0x8(%rsp)
movb $0x0, %al
callq 0x1f3b0
movq 0x150(%rsp), %rdi
movq 0x148(%rsp), %rsi
movq 0x138(%rsp), %rdx
leaq 0x12d(%rip), %rcx       # 0x2a710
callq 0x20700
jmp 0x2a545
jmp 0x2a609
movq 0x148(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0xc783(%rip), %rdi      # 0x36d85
movb $0x0, %al
callq 0x8ae0
jmp 0x2a64b
movq 0x148(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x148(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x150(%rsp), %rdi
movq 0x148(%rsp), %rsi
movq 0x148(%rsp), %rax
movq 0x28(%rax), %rdx
leaq 0xca(%rip), %rcx        # 0x2a710
callq 0x20700
addq $0x158, %rsp            # imm = 0x158
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_lnksym
struct Symbol *aout_lnksym(struct GlobalVars *gv,struct Section *sec,
                           struct Reloc *xref)
/* Check for common a.out linker symbols. */
{
  struct Symbol *sym;
  int i;

  if (!gv->dest_object) {
    for (i=0; i<AOUTSTD_LNKSYMS; i++) {
      if (!strcmp(aout_symnames[i],xref->xrefname)) {
        sym = addlnksymbol(gv,aout_symnames[i],0,SYM_ABS,
                           SYMF_LNKSYM,SYMI_OBJECT,SYMB_GLOBAL,0);
        sym->extra = i; /* for easy ident. in aout_setlnksym */
        switch (i) {
          case GOTSYM:
            gv->got_base_name = aout_symnames[i];
            sym->type = SYM_RELOC;
            break;
          case PLTSYM:
            gv->got_base_name = aout_symnames[i];
            sym->type = SYM_RELOC;
            break;
          case DYNAMICSYM:
            break;
        }
        return (sym);  /* new linker symbol created */
      }
    }
  }
  return (NULL);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
cmpl $0x0, 0x54(%rax)
jne 0x2af8b
movl $0x0, 0x1c(%rsp)
cmpl $0x3, 0x1c(%rsp)
jge 0x2af89
movslq 0x1c(%rsp), %rcx
leaq 0x1637f(%rip), %rax     # 0x41210
movq (%rax,%rcx,8), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x5130
cmpl $0x0, %eax
jne 0x2af77
movq 0x38(%rsp), %rdi
movslq 0x1c(%rsp), %rcx
leaq 0x16353(%rip), %rax     # 0x41210
movq (%rax,%rcx,8), %rsi
movq %rsp, %rax
movl $0x0, 0x8(%rax)
movl $0x2, (%rax)
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %r9d
movl %r9d, %ecx
movl %r9d, %r8d
callq 0x101f0
movq %rax, 0x20(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x48(%rax)
movl 0x1c(%rsp), %eax
movl %eax, 0x18(%rsp)
testl %eax, %eax
je 0x2af1b
jmp 0x2af05
movl 0x18(%rsp), %eax
subl $0x1, %eax
je 0x2af42
jmp 0x2af10
movl 0x18(%rsp), %eax
subl $0x2, %eax
je 0x2af69
jmp 0x2af6b
movslq 0x1c(%rsp), %rcx
leaq 0x162e9(%rip), %rax     # 0x41210
movq (%rax,%rcx,8), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x230(%rax)
movq 0x20(%rsp), %rax
movb $0x2, 0x40(%rax)
jmp 0x2af6b
movslq 0x1c(%rsp), %rcx
leaq 0x162c2(%rip), %rax     # 0x41210
movq (%rax,%rcx,8), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x230(%rax)
movq 0x20(%rsp), %rax
movb $0x2, 0x40(%rax)
jmp 0x2af6b
jmp 0x2af6b
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x2af94
jmp 0x2af79
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2ae7a
jmp 0x2af8b
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_setlnksym
void aout_setlnksym(struct GlobalVars *gv,struct Symbol *xdef)
/* Initialize common a.out linker symbol structure during resolve_xref() */
{
  struct FFFuncs *tf = fff[gv->dest_format];

  if (xdef->flags & SYMF_LNKSYM) {
    switch (xdef->extra) {
      case GOTSYM:
      case PLTSYM:
      case DYNAMICSYM:
        /* @@@ FIXME! NOW! */
        break;
    }
    xdef->flags &= ~SYMF_LNKSYM;  /* do not init again */
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x14a74(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movzbl 0x41(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2aff6
movq -0x10(%rsp), %rax
movl 0x48(%rax), %eax
subl $0x2, %eax
ja 0x2afe7
jmp 0x2afe5
jmp 0x2afe7
movq -0x10(%rsp), %rax
movzbl 0x41(%rax), %ecx
andl $-0x2, %ecx
movb %cl, 0x41(%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_check_ar_type
static void aout_check_ar_type(struct FFFuncs *ff,const char *name,
                               struct aout_hdr *hdr)
/* check all library archive members before conversion */
{
  if (GETMID(hdr)==ff->id || GETMID(hdr)==0) {
    switch (GETMAGIC(hdr)) {
      case NMAGIC:
      case ZMAGIC:
        if (GETFLAGS(hdr)&EX_DPMASK == (EX_DYNAMIC|EX_PIC))
          error(39,name,ff->tname); /* no shared objects in lib archives */
        else
          error(40,name,ff->tname); /* no executables in lib archives */
        return;
      case QMAGIC:
        error(84,name); /* QMAGIC is deprecated */
      case OMAGIC:
        return;
      default:
        break;
    }
  }
  error(41,name,ff->tname);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x7a00
shrl $0x10, %eax
andl $0x3ff, %eax            # imm = 0x3FF
movq 0x20(%rsp), %rcx
cmpl 0xa4(%rcx), %eax
je 0x2c14d
movq 0x10(%rsp), %rdi
callq 0x7a00
shrl $0x10, %eax
andl $0x3ff, %eax            # imm = 0x3FF
cmpl $0x0, %eax
jne 0x2c1f3
movq 0x10(%rsp), %rdi
callq 0x7a00
movzwl %ax, %eax
movl %eax, 0xc(%rsp)
subl $0xcc, %eax
je 0x2c1dc
jmp 0x2c167
movl 0xc(%rsp), %eax
subl $0x107, %eax            # imm = 0x107
je 0x2c1ed
jmp 0x2c174
movl 0xc(%rsp), %eax
subl $0x108, %eax            # imm = 0x108
je 0x2c18e
jmp 0x2c181
movl 0xc(%rsp), %eax
subl $0x10b, %eax            # imm = 0x10B
jne 0x2c1ef
jmp 0x2c18e
movq 0x10(%rsp), %rdi
callq 0x7a00
shrl $0x1a, %eax
andl $0x3f, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2c1c1
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
movl $0x27, %edi
movb $0x0, %al
callq 0x8c00
jmp 0x2c1da
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
movl $0x28, %edi
movb $0x0, %al
callq 0x8c00
jmp 0x2c20c
movq 0x18(%rsp), %rsi
movl $0x54, %edi
movb $0x0, %al
callq 0x8c00
jmp 0x2c20c
jmp 0x2c1f1
jmp 0x2c1f3
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
movl $0x29, %edi
movb $0x0, %al
callq 0x8c00
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_make_sections
static void aout_make_sections(struct ObjectUnit *ou,struct aout_hdr *hdr,
                               int be)
/* creates up to three sections from an a.out file */
{
  struct FFFuncs *ff = fff[ou->lnkfile->format];
  uint32_t size;

  if (size = read32(be,hdr->a_text))
    aout_create_section(ou,ff,TEXTNAME,((uint8_t *)hdr)+aout_txtoffset(hdr,be),
                        size,ST_CODE);

  if (size = read32(be,&hdr->a_data))
    aout_create_section(ou,ff,DATANAME,((uint8_t *)hdr)+aout_datoffset(hdr,be),
                        size,ST_DATA);

  if (size = read32(be,&hdr->a_bss))
    aout_create_section(ou,ff,BSSNAME,((uint8_t *)hdr)+aout_bssoffset(hdr,be),
                        size,ST_UDATA);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rax
movzbl 0x38(%rax), %eax
movl %eax, %ecx
leaq 0x137e8(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movq %rax, 0x58(%rsp)
movl 0x64(%rsp), %edi
movq 0x68(%rsp), %rsi
addq $0x4, %rsi
callq 0x8060
movl %eax, 0x54(%rsp)
cmpl $0x0, %eax
je 0x2c2c5
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0x2f150
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl %eax, %eax
addq %rax, %rcx
movl 0x54(%rsp), %eax
movl %eax, %r8d
leaq 0x92e6(%rip), %rdx      # 0x355a0
movl $0x1, %r9d
callq 0x2f030
movl 0x64(%rsp), %edi
movq 0x68(%rsp), %rsi
addq $0x8, %rsi
callq 0x8060
movl %eax, 0x54(%rsp)
cmpl $0x0, %eax
je 0x2c339
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x68(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0x2f160
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl %eax, %eax
addq %rax, %rcx
movl 0x54(%rsp), %eax
movl %eax, %r8d
leaq 0x9278(%rip), %rdx      # 0x355a6
movl $0x2, %r9d
callq 0x2f030
movl 0x64(%rsp), %edi
movq 0x68(%rsp), %rsi
addq $0xc, %rsi
callq 0x8060
movl %eax, 0x54(%rsp)
cmpl $0x0, %eax
je 0x2c3ad
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0x2f1d0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl %eax, %eax
addq %rax, %rcx
movl 0x54(%rsp), %eax
movl %eax, %r8d
leaq 0x920a(%rip), %rdx      # 0x355ac
movl $0x3, %r9d
callq 0x2f030
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aoutstd_readconv
void aoutstd_readconv(struct GlobalVars *gv,struct LinkFile *lf)
/* Read a.out executable / object / shared obj. with standard relocs */
{
  if (lf->type == ID_LIBARCH) {
    if (ar_init(&ai,(char *)lf->data,lf->length,lf->filename)) {
      while (ar_extract(&ai)) {
        lf->objname = allocstring(ai.name);
        aoutstd_read(gv,lf,(struct aout_hdr *)ai.data);
      }
    }
    else
      ierror("aoutstd_readconv(): archive %s corrupted since last access",
             lf->pathname);
  }
  else {
    lf->objname = lf->filename;
    aoutstd_read(gv,lf,(struct aout_hdr *)lf->data);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl 0x39(%rax), %eax
cmpl $0x8, %eax
jne 0x2d0be
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
leaq 0x17d46(%rip), %rdi     # 0x44d98
callq 0x13d60
cmpl $0x0, %eax
je 0x2d0a5
jmp 0x2d05e
leaq 0x17d33(%rip), %rdi     # 0x44d98
callq 0x13e00
cmpl $0x0, %eax
je 0x2d0a3
leaq 0x17d22(%rip), %rdi     # 0x44d98
addq $0x20, %rdi
callq 0x72d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x17e24(%rip), %rdx     # 0x44ec0
callq 0x2bd90
jmp 0x2d05e
jmp 0x2d0bc
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x9efb(%rip), %rdi      # 0x36fb0
movb $0x0, %al
callq 0x8ae0
jmp 0x2d0e8
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdx
callq 0x2bd90
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_initwrite
void aout_initwrite(struct GlobalVars *gv,struct LinkedSection **sections)
{
  static const char *fn = "aout_initwrite(): ";
  struct LinkedSection *ls;

  initlist(&aoutstrlist.l);
  aoutstrlist.hashtab = alloczero(STRHTABSIZE*sizeof(struct StrTabNode *));
  aoutstrlist.nextoffset = 4;  /* first string is always at offset 4 */
  initlist(&aoutsymlist.l);
  aoutsymlist.hashtab = alloczero(SYMHTABSIZE*sizeof(struct SymbolNode *));
  aoutsymlist.nextindex = 0;
  initlist(&treloclist);
  initlist(&dreloclist);

  get_text_data_bss(gv,sections);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x17dbb(%rip), %rdi     # 0x44ed0
callq 0x7330
movl $0x80000, %edi          # imm = 0x80000
callq 0x7290
movq %rax, 0x17dbd(%rip)     # 0x44ee8
movl $0x4, 0x17dbb(%rip)     # 0x44ef0
leaq 0x17dbc(%rip), %rdi     # 0x44ef8
callq 0x7330
movl $0x80000, %edi          # imm = 0x80000
callq 0x7290
movq %rax, 0x17dbe(%rip)     # 0x44f10
movl $0x0, 0x17dbc(%rip)     # 0x44f18
leaq 0x17dbd(%rip), %rdi     # 0x44f20
callq 0x7330
leaq 0x17dc9(%rip), %rdi     # 0x44f38
callq 0x7330
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x133b0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_addsymlist
void aout_addsymlist(struct GlobalVars *gv,struct LinkedSection **ls,
                     uint8_t bind,uint8_t type,int be)
/* add all symbols with specified bind and type to the a.out symbol list */
{
  int i;

  for (i=0; i<3; i++) {
    if (ls[i]) {
      struct Symbol *sym = (struct Symbol *)ls[i]->symbols.first;
      struct Symbol *nextsym;

      while (nextsym = (struct Symbol *)sym->n.next) {
        uint8_t syminfo = aout_getinfo(sym);
        uint8_t symbind = aout_getbind(sym);

        if (symbind == bind && (!type || (syminfo == type))) {
          if (!discard_symbol(gv,sym)) {
            remnode(&sym->n);
            /* add new symbol(s) */
            aout_symconvert(gv,sym,symbind,syminfo,ls,i,be);
          }
        }
        sym = nextsym;
      }
    }
  }
}

// Assembly:
subq $0x48, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb %cl, 0x37(%rsp)
movb %al, 0x36(%rsp)
movl %r8d, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
cmpl $0x3, 0x2c(%rsp)
jge 0x2d2b8
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2d2a6
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xb0(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x2d2a4
movq 0x20(%rsp), %rdi
callq 0x2d2c0
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2d330
movb %al, 0x16(%rsp)
movzbl 0x16(%rsp), %eax
movzbl 0x37(%rsp), %ecx
cmpl %ecx, %eax
jne 0x2d295
cmpb $0x0, 0x36(%rsp)
je 0x2d247
movzbl 0x17(%rsp), %eax
movzbl 0x36(%rsp), %ecx
cmpl %ecx, %eax
jne 0x2d295
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x13660
cmpl $0x0, %eax
jne 0x2d293
movq 0x20(%rsp), %rdi
callq 0x7530
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movb 0x16(%rsp), %dl
movb 0x17(%rsp), %cl
movq 0x38(%rsp), %r8
movl 0x2c(%rsp), %r9d
movl 0x30(%rsp), %eax
movzbl %dl, %edx
movzbl %cl, %ecx
movl %eax, (%rsp)
callq 0x2d3a0
jmp 0x2d295
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x2d1f1
jmp 0x2d2a6
jmp 0x2d2a8
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2d1b7
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_getinfo
static uint8_t aout_getinfo(struct Symbol *sym)
{
  uint8_t type;

  switch (sym->info) {
    case SYMI_NOTYPE:
    case SYMI_FILE:
    case SYMI_SECTION:  /* this will be ignored later */
      type = AUX_UNKNOWN;
      break;
    case SYMI_OBJECT:
      type = AUX_OBJECT;
      break;
    case SYMI_FUNC:
      type = AUX_FUNC;
      break;
    default:
      ierror("aout_getinfo(): Illegal symbol info: %d",(int)sym->info);
      break;
  }
  return (type);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl 0x42(%rax), %eax
movq %rax, (%rsp)
subq $0x4, %rax
ja 0x2d305
movq (%rsp), %rax
leaq 0x9be9(%rip), %rcx      # 0x36ed0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, 0xf(%rsp)
jmp 0x2d31c
movb $0x1, 0xf(%rsp)
jmp 0x2d31c
movb $0x2, 0xf(%rsp)
jmp 0x2d31c
movq 0x10(%rsp), %rax
movzbl 0x42(%rax), %esi
leaq 0x9e19(%rip), %rdi      # 0x3712e
movb $0x0, %al
callq 0x8ae0
movb 0xf(%rsp), %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_getbind
static uint8_t aout_getbind(struct Symbol *sym)
{
  uint8_t bind;

  switch (sym->bind) {
    case SYMB_LOCAL:
      bind = BIND_LOCAL;
      break;
    case SYMB_GLOBAL:
      bind = BIND_GLOBAL;
      break;
    case SYMB_WEAK:
      bind = BIND_WEAK;
      break;
    default:
      ierror("aout_getbind(): Illegal symbol binding: %d",(int)sym->bind);
      break;
  }
  return (bind);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl 0x43(%rax), %eax
movl %eax, 0x8(%rsp)
subl $0x1, %eax
je 0x2d363
jmp 0x2d34d
movl 0x8(%rsp), %eax
subl $0x2, %eax
je 0x2d36a
jmp 0x2d358
movl 0x8(%rsp), %eax
subl $0x3, %eax
je 0x2d371
jmp 0x2d378
movb $0x0, 0xf(%rsp)
jmp 0x2d38f
movb $0x1, 0xf(%rsp)
jmp 0x2d38f
movb $0x2, 0xf(%rsp)
jmp 0x2d38f
movq 0x10(%rsp), %rax
movzbl 0x43(%rax), %esi
leaq 0x9dce(%rip), %rdi      # 0x37156
movb $0x0, %al
callq 0x8ae0
movb 0xf(%rsp), %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_debugsyms
void aout_debugsyms(struct GlobalVars *gv,bool be)
/* add debug stab-entries to symbol table, sorted by ObjectUnits */
{
  struct ObjectUnit *obj;
  struct StabDebug *stab;

  if (gv->strip_symbols < STRIP_DEBUG) {
    for (obj=(struct ObjectUnit *)gv->selobjects.first;
         obj->n.next!=NULL; obj=(struct ObjectUnit *)obj->n.next) {
      for (stab=(struct StabDebug *)obj->stabs.first;
           stab->n.next!=NULL; stab=(struct StabDebug *)stab->n.next) {
        aout_addsym(stab->name.ptr,stab->n_value,stab->n_othr&0xf,
                    (stab->n_othr>>4)&0xf,stab->n_type,stab->n_desc,be);
      }
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movzbl 0x6c(%rax), %eax
cmpl $0x1, %eax
jge 0x2d6da
movq 0x20(%rsp), %rax
movq 0x138(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2d6d8
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2d6c4
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rax
movl 0x24(%rax), %esi
movq 0x8(%rsp), %rax
movsbl 0x21(%rax), %eax
andl $0xf, %eax
movb %al, %dl
movq 0x8(%rsp), %rax
movsbl 0x21(%rax), %eax
sarl $0x4, %eax
andl $0xf, %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movb 0x20(%rax), %r8b
movq 0x8(%rsp), %rax
movw 0x22(%rax), %r9w
movl 0x1c(%rsp), %eax
movzbl %dl, %edx
movzbl %cl, %ecx
movzbl %r8b, %r8d
movswl %r9w, %r9d
movl %eax, (%rsp)
callq 0x2d6e0
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2d64d
jmp 0x2d6c6
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x2d630
jmp 0x2d6da
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_addsym
static uint32_t aout_addsym(const char *name,uint32_t value,uint8_t bind,
                           uint8_t info,uint8_t type,int16_t desc,int be)
/* add a new symbol, return its symbol table index */
{
  struct SymbolNode **chain;
  struct SymbolNode *sym;

  if (name == NULL)
    name = noname;

  chain = &aoutsymlist.hashtab[elf_hash(name)%SYMHTABSIZE];
  while (sym = *chain)
    chain = &sym->hashchain;
  /* new symbol table entry */
  *chain = sym = alloczero(sizeof(struct SymbolNode));

  sym->name = name;
  sym->index = aoutsymlist.nextindex++;
  write32(be,&sym->s.n_strx,aout_addstr(name));
  sym->s.n_type = type;
  /* @@@ GNU binutils don't use BIND_LOCAL/GLOBAL in a.out files! We do! */
  sym->s.n_other = ((bind&0xf)<<4) | (info&0xf);
  write16(be,&sym->s.n_desc,desc);
  write32(be,&sym->s.n_value,value);
  addtail(&aoutsymlist.l,&sym->n);
  return (sym->index);
}

// Assembly:
subq $0x58, %rsp
movl %r8d, 0x20(%rsp)
movl %ecx, %eax
movl 0x20(%rsp), %ecx
movl %eax, 0x24(%rsp)
movl %edx, %eax
movl 0x24(%rsp), %edx
movl %eax, 0x28(%rsp)
movl %esi, %eax
movl 0x28(%rsp), %esi
movl %eax, 0x2c(%rsp)
movq %rdi, %r8
movl 0x2c(%rsp), %edi
movw %r9w, %ax
movl 0x60(%rsp), %r9d
movq %r8, 0x50(%rsp)
movl %edi, 0x4c(%rsp)
movb %sil, 0x4b(%rsp)
movb %dl, 0x4a(%rsp)
movb %cl, 0x49(%rsp)
movw %ax, 0x46(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x2d746
leaq 0x7f0f(%rip), %rax      # 0x35650
movq %rax, 0x50(%rsp)
movq 0x177c3(%rip), %rax     # 0x44f10
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
callq 0x8760
movq %rax, %rcx
movq 0x18(%rsp), %rax
andq $0xffff, %rcx           # imm = 0xFFFF
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x2d79a
movq 0x30(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x38(%rsp)
jmp 0x2d777
movl $0x30, %edi
callq 0x7290
movq %rax, %rcx
movq %rcx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movq 0x50(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x17750(%rip), %ecx     # 0x44f18
movl %ecx, %eax
addl $0x1, %eax
movl %eax, 0x17745(%rip)     # 0x44f18
movq 0x30(%rsp), %rax
movl %ecx, 0x2c(%rax)
movl 0x60(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
callq 0x2f360
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
movl %eax, %edx
callq 0x8130
movb 0x49(%rsp), %cl
movq 0x30(%rsp), %rax
movb %cl, 0x24(%rax)
movzbl 0x4b(%rsp), %eax
andl $0xf, %eax
shll $0x4, %eax
movzbl 0x4a(%rsp), %ecx
andl $0xf, %ecx
orl %ecx, %eax
movb %al, %cl
movq 0x30(%rsp), %rax
movb %cl, 0x25(%rax)
movl 0x60(%rsp), %edi
movq 0x30(%rsp), %rsi
addq $0x20, %rsi
addq $0x6, %rsi
movzwl 0x46(%rsp), %edx
callq 0x80e0
movl 0x60(%rsp), %edi
movq 0x30(%rsp), %rsi
addq $0x20, %rsi
addq $0x8, %rsi
movl 0x4c(%rsp), %edx
callq 0x8130
movq 0x30(%rsp), %rsi
leaq 0x17681(%rip), %rdi     # 0x44ef8
callq 0x7470
movq 0x30(%rsp), %rax
movl 0x2c(%rax), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: detect_movei_relocs
static void detect_movei_relocs(struct Reloc *first)
/* Search for possible MOVEI RISC relocations and flag them by the
   internal type R_AOUT_MOVEI. */
{
  struct Reloc *r;
  struct RelocInsert *ri;

  for (r=first; r->n.next!=NULL; r=(struct Reloc *)r->n.next) {
    if (r->rtype==R_ABS && (ri = r->insert)) {
      if (ri->bpos==0 && !ri->next && ri->bsiz==16 && ri->mask==0xffff0000) {
        /* Found a MOVEI reloc candidate. The 16-bit word to the left needs
           another 16-bit reloc with mask=0xffff and the same addend
           to confirm it! */
        unsigned long off = r->offset - 2;
        struct Reloc *r2;

        for (r2=first; r2->n.next!=NULL; r2=(struct Reloc *)r2->n.next) {
          if (r2->offset==off && r2->rtype==R_ABS && (ri = r2->insert)) {
            if (ri->bpos==0 && !ri->next && ri->bsiz==16 && ri->mask==0xffff) {
              /* MOVEI reloc with swapped words found */
              r2->rtype = R_AOUT_MOVEI;
              r->rtype = R_NONE;
              break;
            }
          }
        }
      }
    }
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2ddd4
movq -0x10(%rsp), %rax
movzbl 0x38(%rax), %eax
cmpl $0x1, %eax
jne 0x2ddc0
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, %rax
je 0x2ddc0
movq -0x18(%rsp), %rax
movzwl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0x2ddbe
movq -0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x2ddbe
movq -0x18(%rsp), %rax
movzwl 0xa(%rax), %eax
cmpl $0x10, %eax
jne 0x2ddbe
movq -0x18(%rsp), %rax
movl $0xffff0000, %ecx       # imm = 0xFFFF0000
cmpq %rcx, 0x10(%rax)
jne 0x2ddbe
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
subq $0x2, %rax
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2ddbc
movq -0x28(%rsp), %rax
movq 0x20(%rax), %rax
cmpq -0x20(%rsp), %rax
jne 0x2dda8
movq -0x28(%rsp), %rax
movzbl 0x38(%rax), %eax
cmpl $0x1, %eax
jne 0x2dda8
movq -0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, %rax
je 0x2dda8
movq -0x18(%rsp), %rax
movzwl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0x2dda6
movq -0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x2dda6
movq -0x18(%rsp), %rax
movzwl 0xa(%rax), %eax
cmpl $0x10, %eax
jne 0x2dda6
movq -0x18(%rsp), %rax
cmpq $0xffff, 0x10(%rax)     # imm = 0xFFFF
jne 0x2dda6
movq -0x28(%rsp), %rax
movb $0x11, 0x38(%rax)
movq -0x10(%rsp), %rax
movb $0x0, 0x38(%rax)
jmp 0x2ddbc
jmp 0x2dda8
jmp 0x2ddaa
movq -0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x2dd1b
jmp 0x2ddbe
jmp 0x2ddc0
jmp 0x2ddc2
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
jmp 0x2dc7f
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_sectindex
static int aout_sectindex(struct LinkedSection **sections,
                          struct LinkedSection *ls)
/* return index (0,1,2 = .text,.data,.bss) of 'ls' */
{
  int sec;

  for (sec=0; sec<3; sec++) {
    if (sections[sec] == ls)
      break;
  }
  if (sec>=3)
    ierror("aout_sectindex(): Section %s not found in list",ls->name);
  return (sec);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x3, 0x4(%rsp)
jge 0x2de23
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq 0x8(%rsp), %rax
jne 0x2de14
jmp 0x2de23
jmp 0x2de16
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2ddf6
cmpl $0x3, 0x4(%rsp)
jl 0x2de41
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
leaq 0x93a2(%rip), %rdi      # 0x371dc
movb $0x0, %al
callq 0x8ae0
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_addreloclist
static void aout_addreloclist(struct list *rlst,int32_t raddr,uint32_t rindex,
                              uint32_t rinfo,int be)
/* add new relocation_info to .text or .data reloc-list */
{
  struct RelocNode *rn = alloc(sizeof(struct RelocNode));

  write32(be,&rn->r.r_address,(uint32_t)raddr);
  writebf32(be,&rn->r.r_info,RELB_symbolnum,RELS_symbolnum,rindex);
  writebf32(be,&rn->r.r_info,RELB_reloc,RELS_reloc,rinfo);
  addtail(rlst,&rn->n);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movl $0x18, %edi
callq 0x71f0
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
movl 0x1c(%rsp), %edx
callq 0x8130
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
addq $0x4, %rsi
movl 0x18(%rsp), %r8d
xorl %edx, %edx
movl $0x18, %ecx
callq 0x8370
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
addq $0x4, %rsi
movl 0x14(%rsp), %r8d
movl $0x18, %edx
movl $0x8, %ecx
callq 0x8370
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x7470
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_findsym
static int aout_findsym(const char *name,bool be)
/* find a symbol by its name, return symbol table index or -1 */
{
  struct SymbolNode **chain = &aoutsymlist.hashtab[elf_hash(name)%SYMHTABSIZE];
  struct SymbolNode *sym;

  while (sym = *chain) {
    if (!strcmp(name,sym->name))
      return ((int)sym->index);
    chain = &sym->hashchain;
  }
  return (-1);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x1700c(%rip), %rax     # 0x44f10
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x8760
movq %rax, %rcx
movq 0x8(%rsp), %rax
andq $0xffff, %rcx           # imm = 0xFFFF
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x2df77
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x5130
cmpl $0x0, %eax
jne 0x2df67
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x34(%rsp)
jmp 0x2df7f
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
jmp 0x2df2e
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_header
void aout_header(FILE *f,uint32_t mag,uint32_t mid,uint32_t flag,
                 uint32_t tsize,uint32_t dsize,uint32_t bsize,uint32_t syms,
                 uint32_t entry,uint32_t trsize,uint32_t drsize,int be)
/* write an a.out header */
{
  struct aout_hdr h;

  SETMIDMAG(&h,mag,mid,flag);
  write32(be,h.a_text,tsize);
  write32(be,h.a_data,dsize);
  write32(be,h.a_bss,bsize);
  write32(be,h.a_syms,syms);
  write32(be,h.a_entry,entry);
  write32(be,h.a_trsize,trsize);
  write32(be,h.a_drsize,drsize);
  fwritex(f,&h,sizeof(struct aout_hdr));
}

// Assembly:
subq $0x48, %rsp
movl 0x78(%rsp), %eax
movl 0x70(%rsp), %eax
movl 0x68(%rsp), %eax
movl 0x60(%rsp), %eax
movl 0x58(%rsp), %eax
movl 0x50(%rsp), %eax
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movl %r8d, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
leaq 0xc(%rsp), %rdi
movl 0x34(%rsp), %esi
andl $0x3f, %esi
shll $0x1a, %esi
movl 0x38(%rsp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
shll $0x10, %eax
orl %eax, %esi
movl 0x3c(%rsp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
orl %eax, %esi
callq 0x7b30
movl 0x78(%rsp), %edi
leaq 0xc(%rsp), %rsi
addq $0x4, %rsi
movl 0x30(%rsp), %edx
callq 0x8130
movl 0x78(%rsp), %edi
leaq 0xc(%rsp), %rsi
addq $0x8, %rsi
movl 0x2c(%rsp), %edx
callq 0x8130
movl 0x78(%rsp), %edi
leaq 0xc(%rsp), %rsi
addq $0xc, %rsi
movl 0x50(%rsp), %edx
callq 0x8130
movl 0x78(%rsp), %edi
leaq 0xc(%rsp), %rsi
addq $0x10, %rsi
movl 0x58(%rsp), %edx
callq 0x8130
movl 0x78(%rsp), %edi
leaq 0xc(%rsp), %rsi
addq $0x14, %rsi
movl 0x60(%rsp), %edx
callq 0x8130
movl 0x78(%rsp), %edi
leaq 0xc(%rsp), %rsi
addq $0x18, %rsi
movl 0x68(%rsp), %edx
callq 0x8130
movl 0x78(%rsp), %edi
leaq 0xc(%rsp), %rsi
addq $0x1c, %rsi
movl 0x70(%rsp), %edx
callq 0x8130
movq 0x40(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x20, %edx
callq 0x8470
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_pagedsection
void aout_pagedsection(struct GlobalVars *gv,FILE *f,
                       struct LinkedSection **ls,int sec)
/* write .text and .data section aligned to page boundaries */
{
  if (ls[sec]) {
    fwritex(f,ls[sec]->data,ls[sec]->size);
    fwritegap(f,aout_getpagedsize(gv,ls,sec) -
              (sec ? ls[sec]->size : ls[sec]->size+sizeof(struct aout_hdr)));
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2e3dd
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x78(%rax), %rsi
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x48(%rax), %rdx
callq 0x8470
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
callq 0x2e0b0
movl %eax, %eax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x2e3ad
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x48(%rax), %rax
movq %rax, (%rsp)
jmp 0x2e3c7
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x48(%rax), %rax
addq $0x20, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rsp), %rax
subq %rax, %rsi
callq 0x86c0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_writestrings
void aout_writestrings(FILE *f,int be)
{
  if (aoutstrlist.nextoffset > 4) {
    struct StrTabNode *stn;
    uint32_t len;

    write32(be,&len,aoutstrlist.nextoffset);
    fwritex(f,&len,4);
    while (stn = (struct StrTabNode *)remhead(&aoutstrlist.l))
      fwritex(f,stn->str,strlen(stn->str)+1);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
cmpl $0x4, 0x16a0c(%rip)     # 0x44ef0
jbe 0x2e565
movl 0x2c(%rsp), %edi
movl 0x16a00(%rip), %edx     # 0x44ef0
leaq 0x1c(%rsp), %rsi
callq 0x8130
movq 0x30(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
movl $0x4, %edx
callq 0x8470
leaq 0x169bb(%rip), %rdi     # 0x44ed0
callq 0x74d0
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x2e563
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x50c0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x8470
jmp 0x2e50e
jmp 0x2e565
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: isPIC
static bool isPIC(struct LinkedSection **secs)
/* check if all sections contain position independant code (PIC) */
{
  int i;

  for (i=0; i<3; i++) {
    if (secs[i]) {
      struct Reloc *r;

      for (r=(struct Reloc *)secs[i]->relocs.first; r->n.next!=NULL;
           r=(struct Reloc *)r->n.next) {
        if (r->rtype == R_ABS)
          return (FALSE);
      }
      for (r=(struct Reloc *)secs[i]->xrefs.first; r->n.next!=NULL;
           r=(struct Reloc *)r->n.next) {
        if (r->rtype == R_ABS)
          return (FALSE);
      }
    }
  }
  return (TRUE);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x3, -0x14(%rsp)
jge 0x2ecdd
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2eccb
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x80(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2ec7b
movq -0x20(%rsp), %rax
movzbl 0x38(%rax), %eax
cmpl $0x1, %eax
jne 0x2ec6a
movl $0x0, -0x4(%rsp)
jmp 0x2ece5
jmp 0x2ec6c
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x2ec47
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x98(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2ecc9
movq -0x20(%rsp), %rax
movzbl 0x38(%rax), %eax
cmpl $0x1, %eax
jne 0x2ecb8
movl $0x0, -0x4(%rsp)
jmp 0x2ece5
jmp 0x2ecba
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x2ec95
jmp 0x2eccb
jmp 0x2eccd
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x2ec0d
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_create_section
static void aout_create_section(struct ObjectUnit *ou,struct FFFuncs *ff,
                                const char *sec_name,uint8_t *data,
                                unsigned long size,uint8_t type)
{
  struct LinkFile *lf = ou->lnkfile;
  uint8_t flags=0,protection;

  if (type != ST_UDATA) {
    if (data+size > lf->data+lf->length)  /* illegal section offset */
      error(49,lf->pathname,sec_name,lf->objname);
  }

  switch (type) {
    case ST_CODE:
      protection = SP_READ|SP_EXEC;
      break;
    case ST_DATA:
      protection = SP_READ|SP_WRITE;
      break;
    case ST_UDATA:
      protection = SP_READ|SP_WRITE;
      flags = SF_UNINITIALIZED;
      break;
  }
  add_section(ou,sec_name,data,size,type,flags|SF_ALLOC,
              protection,MIN_ALIGNMENT,FALSE);
}

// Assembly:
subq $0x58, %rsp
movb %r9b, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movzbl 0x2f(%rsp), %eax
cmpl $0x3, %eax
je 0x2f0b7
movq 0x38(%rsp), %rax
addq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rsp), %rdx
addq 0x30(%rdx), %rcx
cmpq %rcx, %rax
jbe 0x2f0b5
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x40(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rcx
movl $0x31, %edi
movb $0x0, %al
callq 0x8c00
jmp 0x2f0b7
movzbl 0x2f(%rsp), %eax
movl %eax, 0x18(%rsp)
subl $0x1, %eax
je 0x2f0dd
jmp 0x2f0c7
movl 0x18(%rsp), %eax
subl $0x2, %eax
je 0x2f0e4
jmp 0x2f0d2
movl 0x18(%rsp), %eax
subl $0x3, %eax
je 0x2f0eb
jmp 0x2f0f5
movb $0x5, 0x1e(%rsp)
jmp 0x2f0f5
movb $0x3, 0x1e(%rsp)
jmp 0x2f0f5
movb $0x3, 0x1e(%rsp)
movb $0x2, 0x1f(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movb 0x2f(%rsp), %r8b
movzbl 0x1f(%rsp), %eax
orl $0x1, %eax
xorl %r9d, %r9d
movzbl %r8b, %r8d
movzbl %al, %r9d
movzbl 0x1e(%rsp), %eax
movl %eax, (%rsp)
movl $0x2, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x12660
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: check_strtab
static void check_strtab(struct LinkFile *lf,struct aout_hdr *hdr,int be)
{
  char *strtab = ((char *)hdr) + aout_stroffset(hdr,be);

  if (((uint8_t *)strtab < lf->data) || ((uint8_t *)strtab +
       read32(be,(uint32_t *)strtab) > (lf->data + lf->length)))
    error(85,lf->pathname,"string",lf->objname);  /* illegal offset */
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x2efb0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x2f296
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x8060
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq 0x30(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq 0x30(%rsp), %rdx
addq 0x30(%rdx), %rcx
cmpq %rcx, %rax
jbe 0x2f2bb
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rcx
movl $0x55, %edi
leaq 0x708a(%rip), %rdx      # 0x3633e
movb $0x0, %al
callq 0x8c00
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: get_symname
static char *get_symname(struct LinkFile *lf,struct aout_hdr *hdr,int be,
                         int32_t offset)
{
  char *symname = ((char *)hdr) + aout_stroffset(hdr,be) + offset;

  if (((uint8_t *)symname < lf->data) ||
      ((uint8_t *)symname > (lf->data + lf->length)))  /* illegal offset? */
    error(87,lf->pathname,offset,lf->objname);

  return (symname);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x2efb0
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x2f331
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rsp), %rdx
addq 0x30(%rdx), %rcx
cmpq %rcx, %rax
jbe 0x2f353
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x10(%rsp), %edx
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rcx
movl $0x57, %edi
movb $0x0, %al
callq 0x8c00
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aout.c
// Function: aout_addstr
static uint32_t aout_addstr(const char *s)
/* add a new symbol name to the string table and return its offset */
{
  struct StrTabNode **chain = &aoutstrlist.hashtab[elf_hash(s)%STRHTABSIZE];
  struct StrTabNode *sn;

  if (*s == '\0')
    return (0);

  /* search string in hash table */
  while (sn = *chain) {
    if (!strcmp(s,sn->str))
      return (sn->offset);  /* it's already in, return offset */
    chain = &sn->hashchain;
  }

  /* new string table entry */
  *chain = sn = alloc(sizeof(struct StrTabNode));
  sn->hashchain = NULL;
  sn->str = s;
  sn->offset = aoutstrlist.nextoffset;
  addtail(&aoutstrlist.l,&sn->n);
  aoutstrlist.nextoffset += (uint32_t)strlen(s) + 1;
  return (sn->offset);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x15b78(%rip), %rax     # 0x44ee8
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x8760
movq %rax, %rcx
movq (%rsp), %rax
andq $0xffff, %rcx           # imm = 0xFFFF
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2f3b2
movl $0x0, 0x24(%rsp)
jmp 0x2f479
jmp 0x2f3b4
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2f400
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x5130
cmpl $0x0, %eax
jne 0x2f3f0
movq 0x8(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x2f479
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
jmp 0x2f3b4
movl $0x28, %edi
callq 0x71f0
movq %rax, %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x15ab5(%rip), %ecx     # 0x44ef0
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x8(%rsp), %rsi
leaq 0x15a81(%rip), %rdi     # 0x44ed0
callq 0x7470
movq 0x18(%rsp), %rdi
callq 0x50c0
addl $0x1, %eax
addl 0x15a89(%rip), %eax     # 0x44ef0
movl %eax, 0x15a83(%rip)     # 0x44ef0
movq 0x8(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_aoutmint.c
// Function: find_aout_sym
static struct nlist32 *find_aout_sym(const char *name)
/* returns pointer to aout symbol table entry */
{
  struct SymbolNode **chain = &aoutsymlist.hashtab[elf_hash(name)%SYMHTABSIZE];
  struct SymbolNode *sym;

  while (sym = *chain) {
    if (!strcmp(name,sym->name))
      return &sym->s;
    chain = &sym->hashchain;
  }
  return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
leaq 0x15258(%rip), %rax     # 0x44ef8
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x8760
movq %rax, %rcx
movq (%rsp), %rax
andq $0xffff, %rcx           # imm = 0xFFFF
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2fd17
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x5130
cmpl $0x0, %eax
jne 0x2fd07
movq 0x8(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x20(%rsp)
jmp 0x2fd20
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
jmp 0x2fccc
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)