LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_shdr
struct Elf32_Shdr *elf32_shdr(struct LinkFile *lf,struct Elf32_Ehdr *ehdr,
                              uint16_t idx)
/* return pointer to section header #idx */
{
  bool be = (ehdr->e_ident[EI_DATA] == ELFDATA2MSB);
  struct Elf32_Shdr *shdr;

  if (idx < read16(be,ehdr->e_shnum)) {
    shdr = (struct Elf32_Shdr *)(((char *)ehdr) + ((read32(be,ehdr->e_shoff) +
           (uint32_t)read16(be,ehdr->e_shentsize) * (uint32_t)idx)));
    if (((uint8_t *)shdr < lf->data) ||
        (((uint8_t *)shdr)+read16(be,ehdr->e_shentsize) > lf->data+lf->length))
      /* section header #x has illegal offset */
      error(44,lf->pathname,(int)idx,lf->objname);
    return shdr;
  }
  else  /* Invalid ELF section header index */
    error(43,lf->pathname,(int)idx,lf->objname);
  return NULL;  /* not reached, for compiler's sake */
}

// Assembly:
subq $0x48, %rsp
movw %dx, %ax
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movw %ax, 0x2e(%rsp)
movq 0x30(%rsp), %rax
movzbl 0x5(%rax), %eax
cmpl $0x2, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x28(%rsp)
movzwl 0x2e(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x28(%rsp), %edi
movq 0x30(%rsp), %rsi
addq $0x30, %rsi
callq 0x8010
movw %ax, %cx
movl 0x1c(%rsp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jge 0x1f921
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x28(%rsp), %edi
movq 0x30(%rsp), %rsi
addq $0x20, %rsi
callq 0x8060
movl %eax, 0xc(%rsp)
movl 0x28(%rsp), %edi
movq 0x30(%rsp), %rsi
addq $0x2e, %rsi
callq 0x8010
movl 0xc(%rsp), %ecx
movw %ax, %dx
movq 0x10(%rsp), %rax
movzwl %dx, %edx
movzwl 0x2e(%rsp), %esi
imull %esi, %edx
addl %edx, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x1f8f2
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x28(%rsp), %edi
movq 0x30(%rsp), %rsi
addq $0x2e, %rsi
callq 0x8010
movw %ax, %cx
movq (%rsp), %rax
movzwl %cx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq 0x38(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq 0x38(%rsp), %rdx
addq 0x30(%rdx), %rcx
cmpq %rcx, %rax
jbe 0x1f915
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
movzwl 0x2e(%rsp), %edx
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rcx
movl $0x2c, %edi
movb $0x0, %al
callq 0x8c00
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1f94d
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
movzwl 0x2e(%rsp), %edx
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rcx
movl $0x2b, %edi
movb $0x0, %al
callq 0x8c00
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_strtab
char *elf32_strtab(struct LinkFile *lf,struct Elf32_Ehdr *ehdr,int idx)
/* returns a pointer to the string table */
{
  static char *tabname = "string";
  bool be = (ehdr->e_ident[EI_DATA] == ELFDATA2MSB);
  struct Elf32_Shdr *shdr;
  char *stab;

  shdr = elf32_shdr(lf,ehdr,idx);
  if (read32(be,shdr->sh_type) != SHT_STRTAB)
     error(50,lf->pathname,tabname,lf->objname);  /* illegal type */
  stab = ((char *)ehdr) + read32(be,shdr->sh_offset);
  if (((uint8_t *)stab < lf->data) || 
      ((uint8_t *)stab + read32(be,shdr->sh_size) > lf->data + lf->length))
    error(51,lf->pathname,tabname,lf->objname);  /* illegal offset */
  return stab;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x28(%rsp), %rax
movzbl 0x5(%rax), %eax
cmpl $0x2, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %eax
movzwl %ax, %edx
callq 0x1f7f0
movq %rax, 0x18(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
addq $0x4, %rsi
callq 0x8060
cmpl $0x3, %eax
je 0x1f9e1
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x2097c(%rip), %rdx     # 0x40348
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rcx
movl $0x32, %edi
movb $0x0, %al
callq 0x8c00
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
addq $0x10, %rsi
callq 0x8060
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x1fa5b
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
addq $0x14, %rsi
callq 0x8060
movl %eax, %ecx
movq (%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 0x1fa80
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x208dd(%rip), %rdx     # 0x40348
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rcx
movl $0x33, %edi
movb $0x0, %al
callq 0x8c00
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_symtab
struct Elf32_Sym *elf32_symtab(struct LinkFile *lf,struct Elf32_Ehdr *ehdr,
                               int idx)
/* returns a pointer to the symbol table */
{
  static char *tabname = "symbol";
  bool be = (ehdr->e_ident[EI_DATA] == ELFDATA2MSB);
  struct Elf32_Shdr *shdr;
  struct Elf32_Sym *symtab;
  uint32_t shtype;

  shdr = elf32_shdr(lf,ehdr,idx);
  shtype = read32(be,shdr->sh_type);
  if (shtype!=SHT_SYMTAB && shtype!=SHT_DYNSYM)
     error(50,lf->pathname,tabname,lf->objname);  /* illegal type */
  symtab = (struct Elf32_Sym *)((uint8_t *)ehdr + read32(be,shdr->sh_offset));
  if (((uint8_t *)symtab < lf->data) || 
      ((uint8_t *)symtab + read32(be,shdr->sh_size) > lf->data + lf->length))
    error(51,lf->pathname,tabname,lf->objname);  /* illegal offset */
  return symtab;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x38(%rsp), %rax
movzbl 0x5(%rax), %eax
cmpl $0x2, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %eax
movzwl %ax, %edx
callq 0x1f7f0
movq %rax, 0x28(%rsp)
movl 0x30(%rsp), %edi
movq 0x28(%rsp), %rsi
addq $0x4, %rsi
callq 0x8060
movl %eax, 0x1c(%rsp)
cmpl $0x2, 0x1c(%rsp)
je 0x1fb1e
cmpl $0xb, 0x1c(%rsp)
je 0x1fb1e
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x20847(%rip), %rdx     # 0x40350
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rcx
movl $0x32, %edi
movb $0x0, %al
callq 0x8c00
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x30(%rsp), %edi
movq 0x28(%rsp), %rsi
addq $0x10, %rsi
callq 0x8060
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x1fb9a
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x30(%rsp), %edi
movq 0x28(%rsp), %rsi
addq $0x14, %rsi
callq 0x8060
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq 0x40(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq 0x40(%rsp), %rdx
addq 0x30(%rdx), %rcx
cmpq %rcx, %rax
jbe 0x1fbbf
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x207a6(%rip), %rdx     # 0x40350
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rcx
movl $0x33, %edi
movb $0x0, %al
callq 0x8c00
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_lnksym
struct Symbol *elf32_lnksym(struct GlobalVars *gv,struct Section *sec,
                            struct Reloc *xref)
/* Check for common ELF32 linker symbols. */
{
  int i;

  if (!gv->dest_object) {
    for (i=0; i<(sizeof(elf32_symnames)/sizeof(elf32_symnames[0])); i++) {
      if (!strcmp(elf32_symnames[i],xref->xrefname))
        return elf32_makelnksym(gv,i);  /* new linker symbol created */
    }
  }
  return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x54(%rax)
jne 0x2202a
movl $0x0, 0x4(%rsp)
movslq 0x4(%rsp), %rax
cmpq $0x7, %rax
jae 0x22028
movslq 0x4(%rsp), %rcx
leaq 0x1e2f3(%rip), %rax     # 0x402e0
movq (%rax,%rcx,8), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x5130
cmpl $0x0, %eax
jne 0x22019
movq 0x18(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x22040
movq %rax, 0x20(%rsp)
jmp 0x22033
jmp 0x2201b
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x21fd6
jmp 0x2202a
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_makelnksym
static struct Symbol *elf32_makelnksym(struct GlobalVars *gv,int idx)
{
  struct Symbol *sym = addlnksymbol(gv,elf32_symnames[idx],0,SYM_ABS,
                                    SYMF_LNKSYM,SYMI_OBJECT,SYMB_GLOBAL,0);

  sym->extra = idx;  /* for easy ident. in elf32_setlnksym */
  switch (idx) {
    case SDABASE:
    case SDA2BASE:
      sym->type = SYM_RELOC;
      sym->value = (lword)fff[gv->dest_format]->baseoff;
      break;
    case GLOBOFFSTAB:
      sym->value = fff[gv->dest_format]->gotoff;
      gv->got_base_name = elf32_symnames[idx];
      break;
    case PROCLINKTAB:
      gv->plt_base_name = elf32_symnames[idx];
      break;
  }
  return sym;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rcx
leaq 0x1e282(%rip), %rax     # 0x402e0
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 0x2c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x48(%rax)
movl 0x2c(%rsp), %eax
movl %eax, 0x1c(%rsp)
subl $0x2, %eax
jb 0x220c0
jmp 0x220a7
movl 0x1c(%rsp), %eax
subl $0x4, %eax
je 0x220f1
jmp 0x220b2
movl 0x1c(%rsp), %eax
subl $0x5, %eax
je 0x22135
jmp 0x22151
movq 0x20(%rsp), %rax
movb $0x2, 0x40(%rax)
movq 0x30(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x1d955(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movslq 0x9c(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x30(%rax)
jmp 0x22151
movq 0x30(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x1d92d(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movslq 0xa0(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x30(%rax)
movslq 0x2c(%rsp), %rcx
leaq 0x1e1bd(%rip), %rax     # 0x402e0
movq (%rax,%rcx,8), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x230(%rax)
jmp 0x22151
movslq 0x2c(%rsp), %rcx
leaq 0x1e19f(%rip), %rax     # 0x402e0
movq (%rax,%rcx,8), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x238(%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_adddynsym
void elf32_adddynsym(struct Symbol *sym)
{
  if (sym->flags & SYMF_DYNIMPORT) {
    elf32_addsym(&elf32dsymlist,&elf32dstrlist,sym->name,0,0,
                 STB_GLOBAL,STT_NOTYPE,SHN_UNDEF);
  }
  else if (sym->flags & SYMF_DYNEXPORT) {
    struct DynSymNode *dsn = alloc(sizeof(struct DynSymNode));

    /* section index and value need to be fixed later for these entries! */
    dsn->idx = elf32_addsym(&elf32dsymlist,&elf32dstrlist,sym->name,0,
                            sym->size,elf32_getbind(sym),elf32_getinfo(sym),0);
    dsn->sym = sym;
    addtail(&dynsym_list,&dsn->n);
  }
  else
    ierror("elf32_adddynsym(): <%s> was not flagged as dynamic",sym->name);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movzbl 0x41(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x22666
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdx
leaq 0x1dbd6(%rip), %rdi     # 0x40210
leaq 0x1dc2f(%rip), %rsi     # 0x40270
xorl %r8d, %r8d
movl $0x1, %r9d
movl %r8d, %ecx
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x22910
jmp 0x22738
movq 0x30(%rsp), %rax
movzbl 0x41(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x2271f
movl $0x20, %edi
callq 0x71f0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x44(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x22b30
movb %al, 0x27(%rsp)
movq 0x30(%rsp), %rdi
callq 0x22ba0
movq 0x18(%rsp), %rdx
movl 0x20(%rsp), %r8d
movb 0x27(%rsp), %r9b
leaq 0x1db3c(%rip), %rdi     # 0x40210
leaq 0x1db95(%rip), %rsi     # 0x40270
xorl %ecx, %ecx
movzbl %r9b, %r9d
movzbl %al, %eax
movl %eax, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x22910
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rsi
leaq 0x22578(%rip), %rdi     # 0x44c90
callq 0x7470
jmp 0x22736
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rsi
leaq 0x13c87(%rip), %rdi     # 0x363b6
movb $0x0, %al
callq 0x8ae0
jmp 0x22738
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_getbind
uint8_t elf32_getbind(struct Symbol *sym)
{
  uint8_t bind = STB_GLOBAL;

  switch (sym->bind) {
    case SYMB_LOCAL:
      bind = STB_LOCAL;
      break;
    case SYMB_GLOBAL:
      bind = STB_GLOBAL;
      break;
    case SYMB_WEAK:
      bind = STB_WEAK;
      break;
    default:
      ierror("elf32_getbind(): Illegal symbol binding: %d",(int)sym->bind);
      break;
  }
  return bind;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movb $0x1, 0xf(%rsp)
movq 0x10(%rsp), %rax
movzbl 0x43(%rax), %eax
movl %eax, 0x8(%rsp)
subl $0x1, %eax
je 0x22b68
jmp 0x22b52
movl 0x8(%rsp), %eax
subl $0x2, %eax
je 0x22b6f
jmp 0x22b5d
movl 0x8(%rsp), %eax
subl $0x3, %eax
je 0x22b76
jmp 0x22b7d
movb $0x0, 0xf(%rsp)
jmp 0x22b94
movb $0x1, 0xf(%rsp)
jmp 0x22b94
movb $0x2, 0xf(%rsp)
jmp 0x22b94
movq 0x10(%rsp), %rax
movzbl 0x43(%rax), %esi
leaq 0x1396c(%rip), %rdi     # 0x364f9
movb $0x0, %al
callq 0x8ae0
movb 0xf(%rsp), %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_getinfo
uint8_t elf32_getinfo(struct Symbol *sym)
{
  uint8_t type = STT_NOTYPE;

  switch (sym->info) {
    case SYMI_NOTYPE:
      break;  /* @@@ Is this allowed? */
    case SYMI_OBJECT:
      type = STT_OBJECT;
      break;
    case SYMI_FUNC:
      type = STT_FUNC;
      break;
    case SYMI_SECTION:
      ierror("elf32_getinfo(): STT_SECTION symbol detected");
      type = STT_SECTION;
      break;
    case SYMI_FILE:
      type = STT_FILE;
      break;
    default:
      ierror("elf32_getinfo(): Illegal symbol info: %d",(int)sym->info);
      break;
  }
  return type;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x10(%rsp), %rax
movzbl 0x42(%rax), %eax
movq %rax, (%rsp)
subq $0x4, %rax
ja 0x22c01
movq (%rsp), %rax
leaq 0x1360c(%rip), %rcx     # 0x361d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x22c18
movb $0x1, 0xf(%rsp)
jmp 0x22c18
movb $0x2, 0xf(%rsp)
jmp 0x22c18
leaq 0x138b7(%rip), %rdi     # 0x364a3
movb $0x0, %al
callq 0x8ae0
movb $0x3, 0xf(%rsp)
jmp 0x22c18
movb $0x4, 0xf(%rsp)
jmp 0x22c18
movq 0x10(%rsp), %rax
movzbl 0x42(%rax), %esi
leaq 0x138bf(%rip), %rdi     # 0x364d0
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_elf32.c
// Function: elf32_bssentry
struct Symbol *elf32_bssentry(struct GlobalVars *gv,const char *secname,
                              struct Symbol *xdef)
/* Allocate space for a copy-object in a .bss or .sbss section and create
   a R_COPY relocation to the original symbol in the shared object. */
{
  struct Symbol *newxdef;

  if (gv->dynobj == NULL)
    ierror("elf32_bssentry(): no dynobj");
  newxdef = bss_entry(gv->dynobj,secname,xdef);

  if (newxdef) {
    /* entry in BSS was done, so we need a R_COPY relocation */
    struct Reloc *r;

    xdef = newxdef;
    r = newreloc(gv,xdef->relsect,xdef->name,NULL,0,0,R_COPY,0);
    r->relocsect.symbol = xdef;
    addreloc(xdef->relsect,r,0,32,-1);  /* mask/size irrelevant for R_COPY */
    elf32_dynreloc(xdef->relsect->obj,r,gv->reloctab_format==RTAB_ADDEND);
  }

  return xdef;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x1e0(%rax)
jne 0x23130
leaq 0x1330d(%rip), %rdi     # 0x36436
movb $0x0, %al
callq 0x8ae0
movq 0x30(%rsp), %rax
movq 0x1e0(%rax), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x13890
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x231fc
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdx
xorl %eax, %eax
movl %eax, %r9d
xorl %r8d, %r8d
movq %r9, %rcx
movl $0xe, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x10850
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
movl $0x20, %ecx
movq $-0x1, %r8
callq 0x109b0
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x30(%rsp), %rax
movzbl 0x6e(%rax), %eax
cmpl $0x2, %eax
sete %al
andb $0x1, %al
movzbl %al, %edx
callq 0x22f30
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_dynamicentry
void elf32_dynamicentry(struct GlobalVars *gv,uint32_t tag,uint32_t val,
                        struct Section *relsec)
/* store another entry into the .dynamic section, make new relocation with
   relsec in value-field, when nonzero */
{
  if (dynamic) {
    bool be = elf32_endianess == _BIG_ENDIAN_;
    struct Elf32_Dyn dyn;
    unsigned long offs = dynamic->size;

    write32(be,dyn.d_tag,tag);
    write32(be,dyn.d_val,val);
    dynamic->data = re_alloc(dynamic->data,
                             dynamic->size+sizeof(struct Elf32_Dyn));
    memcpy(dynamic->data+offs,&dyn,sizeof(struct Elf32_Dyn));
    dynamic->size += sizeof(struct Elf32_Dyn);

    if (relsec) {
      /* we need a 32-bit R_ABS relocation for d_val */
      struct Reloc *r;
      int o = offsetof(struct Elf32_Dyn,d_val);

      r = newreloc(gv,dynamic,NULL,relsec,0,
                   offs+offsetof(struct Elf32_Dyn,d_val),R_ABS,(lword)val);
      r->flags |= RELF_INTERNAL;  /* just for calculating the address */
      addreloc(dynamic,r,0,32,-1);
    }
  }
  else
    ierror("elf32_dynamicentry(): .dynamic was never created");
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
cmpq $0x0, 0x21a7a(%rip)     # 0x44ca8
je 0x23354
movsbl 0x1d095(%rip), %eax     # 0x402d0
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x3c(%rsp)
movq 0x21a57(%rip), %rax     # 0x44ca8
movq 0x48(%rax), %rax
movq %rax, 0x28(%rsp)
movl 0x3c(%rsp), %edi
leaq 0x34(%rsp), %rsi
movl 0x4c(%rsp), %edx
callq 0x8130
movl 0x3c(%rsp), %edi
leaq 0x34(%rsp), %rsi
addq $0x4, %rsi
movl 0x48(%rsp), %edx
callq 0x8130
movq 0x21a1f(%rip), %rax     # 0x44ca8
movq 0x40(%rax), %rdi
movq 0x21a14(%rip), %rax     # 0x44ca8
movq 0x48(%rax), %rsi
addq $0x8, %rsi
callq 0x7240
movq %rax, %rcx
movq 0x219fd(%rip), %rax     # 0x44ca8
movq %rcx, 0x40(%rax)
movq 0x219f2(%rip), %rax     # 0x44ca8
movq 0x40(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x34(%rsp), %rdx
movq %rdx, (%rax,%rcx)
movq 0x219d9(%rip), %rax     # 0x44ca8
movq 0x48(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x48(%rax)
cmpq $0x0, 0x40(%rsp)
je 0x23352
movl $0x4, 0x1c(%rsp)
movq 0x50(%rsp), %rdi
movq 0x219b1(%rip), %rsi     # 0x44ca8
movq 0x40(%rsp), %rcx
movq 0x28(%rsp), %r9
addq $0x4, %r9
movl 0x48(%rsp), %eax
xorl %edx, %edx
xorl %r8d, %r8d
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x10850
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl 0x39(%rax), %ecx
orl $0x10, %ecx
movb %cl, 0x39(%rax)
movq 0x2196e(%rip), %rdi     # 0x44ca8
movq 0x20(%rsp), %rsi
xorl %edx, %edx
movl $0x20, %ecx
movq $-0x1, %r8
callq 0x109b0
jmp 0x23362
leaq 0x130f7(%rip), %rdi     # 0x36452
movb $0x0, %al
callq 0x8ae0
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_makehash
static void elf32_makehash(struct GlobalVars *gv)
/* Allocate and populate .hash section. */
{
  bool be = elf32_endianess == _BIG_ENDIAN_;
  size_t nsyms = elf32dsymlist.nextindex;
  size_t nbuckets = elf32_num_buckets(nsyms);
  struct Section *hashsec = find_sect_name(gv->dynobj,hash_name);

  if (hashsec) {
    struct SymbolNode *sn;
    uint32_t *hdata;

    /* .hash layout: nbuckets, nsyms, [buckets], [sym-indexes] */
    hashsec->size = (2 + nbuckets + nsyms) * sizeof(uint32_t);
    hashsec->data = alloczero(hashsec->size);
    hdata = (uint32_t *)hashsec->data;
    write32(be,&hdata[0],nbuckets);
    write32(be,&hdata[1],nsyms);
    for (sn=(struct SymbolNode *)elf32dsymlist.l.first;
         sn->n.next!=NULL; sn=(struct SymbolNode *)sn->n.next) {
      uint32_t *i = &hdata[2 + elf_hash(sn->name) % nbuckets];
      uint32_t j;

      while (j = read32(be,i))
        i = &hdata[2 + nbuckets + j];
      write32(be,i,sn->index);
    }      
  }
  else
    ierror("elf32_makehash(): no %s",hash_name);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movsbl 0x1cb30(%rip), %eax     # 0x402d0
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x4c(%rsp)
movl 0x1ca83(%rip), %eax     # 0x40238
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x27350
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq 0x1e0(%rax), %rdi
leaq 0x12a6f(%rip), %rsi     # 0x3624b
callq 0x12040
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x2391b
movq 0x38(%rsp), %rcx
addq $0x2, %rcx
addq 0x40(%rsp), %rcx
shlq $0x2, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x7290
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x20(%rsp)
movl 0x4c(%rsp), %edi
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rax
movl %eax, %edx
callq 0x8130
movl 0x4c(%rsp), %edi
movq 0x20(%rsp), %rsi
addq $0x4, %rsi
movq 0x40(%rsp), %rax
movl %eax, %edx
callq 0x8130
movq 0x1c9a6(%rip), %rax     # 0x40210
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
je 0x23919
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8760
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x38(%rsp)
movq 0x8(%rsp), %rax
movq %rdx, %rcx
addq $0x2, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0x4c(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x8060
movl %eax, 0x14(%rsp)
cmpl $0x0, %eax
je 0x238f1
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
addq $0x2, %rcx
movl 0x14(%rsp), %edx
addq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
jmp 0x238b7
movl 0x4c(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rax
movl 0x30(%rax), %edx
callq 0x8130
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x2386f
jmp 0x23930
leaq 0x12ebb(%rip), %rdi     # 0x367dd
leaq 0x12922(%rip), %rsi     # 0x3624b
movb $0x0, %al
callq 0x8ae0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_putstrtab
static void elf32_putstrtab(uint8_t *p,struct StrTabList *sl)
/* write all StrTabList nodes sequentially into memory */
{
  struct StrTabNode *stn;

  while (stn = (struct StrTabNode *)remhead(&sl->l)) {
    const char *s;
    char c;

    s = stn->str;
    do {
      c = *s++;
      *p++ = c;
    } while (c);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x74d0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x239a8
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movb (%rax), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %cl
movq 0x20(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rsp)
movb %cl, (%rax)
cmpb $0x0, 0x7(%rsp)
jne 0x23971
jmp 0x2394e
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_headersize
unsigned long elf32_headersize(struct GlobalVars *gv)
{
  int segcnt = 0;
  struct Phdr *p = gv->phdrlist;

  while (p) {
    if (p->flags & PHDR_USED)
      segcnt++;
    p = p->next;
  }
  return sizeof(struct Elf32_Ehdr) + segcnt * sizeof(struct Elf32_Phdr);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq 0x1f8(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0x23a01
movq -0x18(%rsp), %rax
movzwl 0x24(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x239f2
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x239ce
movslq -0xc(%rsp), %rax
shlq $0x5, %rax
addq $0x34, %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_addstrlist
static uint32_t elf32_addstrlist(struct StrTabList *sl,const char *s)
/* add a new string to an ELF string table and return its index */
{
  struct StrTabNode **chain,*sn;

  if (sl->hashtab == NULL) {
    /* initialize an unused string list */
    initlist(&sl->l);
    sl->hashtab = alloczero(sl->htabsize * sizeof(struct StrTabNode *));
    elf32_addstrlist(sl,noname);
  }
  chain = &sl->hashtab[elf_hash(s) % sl->htabsize];

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

  /* new string table entry */
  *chain = sn = alloc(sizeof(struct StrTabNode));
  sn->hashchain = NULL;
  sn->str = s;
  sn->index = sl->nextindex;
  addtail(&sl->l,&sn->n);
  sl->nextindex += (uint32_t)strlen(s) + 1;

  return sn->index;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x23a63
movq 0x28(%rsp), %rdi
callq 0x7330
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
shlq $0x3, %rdi
callq 0x7290
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rdi
leaq 0x11bf2(%rip), %rsi     # 0x35650
callq 0x23a10
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x8760
movq 0x28(%rsp), %rcx
xorl %edx, %edx
divq 0x20(%rcx)
movq 0x8(%rsp), %rax
shlq $0x3, %rdx
addq %rdx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x23ae3
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x5130
cmpl $0x0, %eax
jne 0x23ad3
movq 0x10(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x34(%rsp)
jmp 0x23b5d
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
jmp 0x23a97
movl $0x28, %edi
callq 0x71f0
movq %rax, %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rax
movl 0x28(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x7470
movq 0x20(%rsp), %rdi
callq 0x50c0
movl %eax, %ecx
addl $0x1, %ecx
movq 0x28(%rsp), %rax
addl 0x28(%rax), %ecx
movl %ecx, 0x28(%rax)
movq 0x10(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_getshndx
uint16_t elf32_getshndx(struct GlobalVars *gv,
                        struct Symbol *sym,uint8_t symtype)
{
  uint16_t shndx = SHN_UNDEF;

  switch (sym->type) {
    case SYM_INDIR:
      /* can't reproduce unsupported symbol type */
      error(33,fff[gv->dest_format]->tname,sym->name,sym_bind[sym->bind],
            sym_type[sym->type],sym_info[sym->info]);
    case SYM_UNDEF:
      shndx = SHN_UNDEF;
      break;
    case SYM_ABS:
      shndx = SHN_ABS;
      break;
    case SYM_RELOC:
      if (symtype > STT_FUNC)
        ierror("elf32_getshndx(): %s is relocatable, but not a "
               "function or object (type %d)",sym->name,(int)symtype);
      shndx = (uint16_t)sym->relsect->lnksec->index;
      break;
    case SYM_COMMON:
      shndx = SHN_COMMON;
      break;
    default:
      ierror("elf32_getshndx(): Illegal symbol type: %d",(int)sym->type);
      break;
  }
  return shndx;
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movw $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rax
movzbl 0x40(%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x4, %rax
ja 0x23c80
movq 0x8(%rsp), %rax
leaq 0x12679(%rip), %rcx     # 0x36228
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x1be66(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x18(%rsp), %rax
movzbl 0x43(%rax), %eax
movl %eax, %ecx
leaq 0x1bf94(%rip), %rax     # 0x3fb80
movq (%rax,%rcx,8), %rcx
movq 0x18(%rsp), %rax
movzbl 0x40(%rax), %eax
movl %eax, %edi
leaq 0x1bf1e(%rip), %rax     # 0x3fb20
movq (%rax,%rdi,8), %r8
movq 0x18(%rsp), %rax
movzbl 0x42(%rax), %eax
movl %eax, %edi
leaq 0x1bf38(%rip), %rax     # 0x3fb50
movq (%rax,%rdi,8), %r9
movl $0x21, %edi
movb $0x0, %al
callq 0x8c00
movw $0x0, 0x14(%rsp)
jmp 0x23c97
movw $0xfff1, 0x14(%rsp)     # imm = 0xFFF1
jmp 0x23c97
movzbl 0x17(%rsp), %eax
cmpl $0x2, %eax
jle 0x23c60
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rsi
movzbl 0x17(%rsp), %edx
leaq 0x128cc(%rip), %rdi     # 0x36525
movb $0x0, %al
callq 0x8ae0
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %rax
movl 0x10(%rax), %eax
movw %ax, 0x14(%rsp)
jmp 0x23c97
movw $0xfff2, 0x14(%rsp)     # imm = 0xFFF2
jmp 0x23c97
movq 0x18(%rsp), %rax
movzbl 0x40(%rax), %esi
leaq 0x128e1(%rip), %rdi     # 0x36571
movb $0x0, %al
callq 0x8ae0
movw 0x14(%rsp), %ax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_writephdrs
void elf32_writephdrs(struct GlobalVars *gv,FILE *f)
/* write 32-bit ELF Program Header (PHDR) */
{
  bool be = elf32_endianess == _BIG_ENDIAN_;
  long gapsize = file_hdr_gap;
  struct Elf32_Phdr phdr;
  struct Phdr *p;

  for (p=gv->phdrlist; p; p=p->next) {
    if (p->flags & PHDR_USED) {
      if (p->start!=ADDR_NONE && p->start_vma!=ADDR_NONE) {
        write32(be,phdr.p_type,p->type);
        write32(be,phdr.p_offset,p->offset);
        write32(be,phdr.p_vaddr,p->start_vma);
        write32(be,phdr.p_paddr,p->start);
        write32(be,phdr.p_filesz,p->file_end - p->start);
        write32(be,phdr.p_memsz,p->mem_end - p->start);
        write32(be,phdr.p_flags,p->flags & PHDR_PFMASK);
        write32(be,phdr.p_align,1L<<p->alignment);
        fwritex(f,&phdr,sizeof(struct Elf32_Phdr));
      }
      else
        gapsize += sizeof(struct Elf32_Phdr);
    }
  }
  fwritegap(f,gapsize);  /* gap at the end, for unused PHDRs */
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movsbl 0x1c3eb(%rip), %eax     # 0x402d0
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movq 0x20dd5(%rip), %rax     # 0x44cd0
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq 0x1f8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2407b
movq (%rsp), %rax
movzwl 0x24(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x24069
movq (%rsp), %rax
cmpq $-0x1, 0x30(%rax)
je 0x24059
movq (%rsp), %rax
cmpq $-0x1, 0x28(%rax)
je 0x24059
movl 0x34(%rsp), %edi
leaq 0x8(%rsp), %rsi
movq (%rsp), %rax
movl 0x20(%rax), %edx
callq 0x8130
movl 0x34(%rsp), %edi
leaq 0x8(%rsp), %rsi
addq $0x4, %rsi
movq (%rsp), %rax
movq 0x48(%rax), %rax
movl %eax, %edx
callq 0x8130
movl 0x34(%rsp), %edi
leaq 0x8(%rsp), %rsi
addq $0x8, %rsi
movq (%rsp), %rax
movq 0x28(%rax), %rax
movl %eax, %edx
callq 0x8130
movl 0x34(%rsp), %edi
leaq 0x8(%rsp), %rsi
addq $0xc, %rsi
movq (%rsp), %rax
movq 0x30(%rax), %rax
movl %eax, %edx
callq 0x8130
movl 0x34(%rsp), %edi
leaq 0x8(%rsp), %rsi
addq $0x10, %rsi
movq (%rsp), %rax
movq 0x38(%rax), %rax
movq (%rsp), %rcx
subq 0x30(%rcx), %rax
movl %eax, %edx
callq 0x8130
movl 0x34(%rsp), %edi
leaq 0x8(%rsp), %rsi
addq $0x14, %rsi
movq (%rsp), %rax
movq 0x40(%rax), %rax
movq (%rsp), %rcx
subq 0x30(%rcx), %rax
movl %eax, %edx
callq 0x8130
movl 0x34(%rsp), %edi
leaq 0x8(%rsp), %rsi
addq $0x18, %rsi
movq (%rsp), %rax
movzwl 0x24(%rax), %edx
andl $0xf, %edx
callq 0x8130
movl 0x34(%rsp), %edi
leaq 0x8(%rsp), %rsi
addq $0x1c, %rsi
movq (%rsp), %rax
movzbl 0x26(%rax), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movl %eax, %edx
callq 0x8130
movq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x20, %edx
callq 0x8470
jmp 0x24067
movq 0x28(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x28(%rsp)
jmp 0x24069
jmp 0x2406b
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x23f10
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x86c0
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_addsymlist
void elf32_addsymlist(struct GlobalVars *gv,struct SymTabList *sl,
                      uint8_t bind,uint8_t type)
/* add all symbols with specified bind and type to the ELF symbol list */
{
  struct LinkedSection *ls = (struct LinkedSection *)gv->lnksec.first;
  struct LinkedSection *nextls;
  struct Symbol *nextsym,*sym;

  while (nextls = (struct LinkedSection *)ls->n.next) {
    sym = (struct Symbol *)ls->symbols.first;

    while (nextsym = (struct Symbol *)sym->n.next) {
      uint8_t symtype = elf32_getinfo(sym);
      uint8_t symbind = elf32_getbind(sym);

      if (symbind == bind && (!type || (symtype == type))) {
        if (!discard_symbol(gv,sym)) {
          remnode(&sym->n);
          elf32_addsym(sl,&elf32stringlist,sym->name,(uint32_t)sym->value,
                       sym->size,symbind,symtype,
                       elf32_getshndx(gv,sym,symtype));
        }
      }
      sym = nextsym;
    }
    ls = nextls;
  }
}

// Assembly:
subq $0x68, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb %cl, 0x57(%rsp)
movb %al, 0x56(%rsp)
movq 0x60(%rsp), %rax
movq 0x1c0(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, %rax
je 0x24574
movq 0x48(%rsp), %rax
movq 0xb0(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0x24565
movq 0x30(%rsp), %rdi
callq 0x22ba0
movb %al, 0x2f(%rsp)
movq 0x30(%rsp), %rdi
callq 0x22b30
movb %al, 0x2e(%rsp)
movzbl 0x2e(%rsp), %eax
movzbl 0x57(%rsp), %ecx
cmpl %ecx, %eax
jne 0x24556
cmpb $0x0, 0x56(%rsp)
je 0x244a1
movzbl 0x2f(%rsp), %eax
movzbl 0x56(%rsp), %ecx
cmpl %ecx, %eax
jne 0x24556
movq 0x60(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x13660
cmpl $0x0, %eax
jne 0x24554
movq 0x30(%rsp), %rdi
callq 0x7530
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
movl 0x44(%rax), %eax
movl %eax, 0x28(%rsp)
movb 0x2e(%rsp), %al
movb %al, 0x2c(%rsp)
movb 0x2f(%rsp), %al
movb %al, 0x2d(%rsp)
movq 0x60(%rsp), %rdi
movq 0x30(%rsp), %rsi
movzbl 0x2f(%rsp), %edx
callq 0x23b70
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl 0x24(%rsp), %ecx
movl 0x28(%rsp), %r8d
movb 0x2c(%rsp), %r9b
movb 0x2d(%rsp), %r10b
leaq 0x1bd04(%rip), %rsi     # 0x40240
movzbl %r9b, %r9d
movzbl %r10b, %r10d
movl %r10d, (%rsp)
movzwl %ax, %eax
movl %eax, 0x8(%rsp)
callq 0x22910
jmp 0x24556
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x24443
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
jmp 0x2441b
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: conv_perm_to_elf
static uint16_t conv_perm_to_elf(uint8_t secperm)
/* converts vlink section permissions to ELF segment permissions */
{
  uint16_t elfperm = 0;

  if (secperm & SP_READ)
    elfperm |= PF_R;
  if (secperm & SP_WRITE)
    elfperm |= PF_W;
  if (secperm & SP_EXEC)
    elfperm |= PF_X;

  return elfperm;
}

// Assembly:
movb %dil, %al
movb %al, -0x1(%rsp)
movw $0x0, -0x4(%rsp)
movzbl -0x1(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x24d58
movzwl -0x4(%rsp), %eax
orl $0x4, %eax
movw %ax, -0x4(%rsp)
movzbl -0x1(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x24d72
movzwl -0x4(%rsp), %eax
orl $0x2, %eax
movw %ax, -0x4(%rsp)
movzbl -0x1(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x24d8c
movzwl -0x4(%rsp), %eax
orl $0x1, %eax
movw %ax, -0x4(%rsp)
movw -0x4(%rsp), %ax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_addshdr
static struct ShdrNode *elf32_addshdr(uint32_t name,uint32_t type,
                                      uint32_t flags,uint32_t addr,
                                      uint32_t offset,uint32_t size,
                                      uint32_t link,uint32_t info,
                                      uint32_t align,uint32_t entsize,bool be)
{
  struct ShdrNode *shn = elf32_newshdr();

  write32(be,shn->s.sh_name,name);
  write32(be,shn->s.sh_type,type);
  write32(be,shn->s.sh_flags,flags);
  write32(be,shn->s.sh_addr,addr);
  write32(be,shn->s.sh_offset,offset);
  write32(be,shn->s.sh_size,size);
  write32(be,shn->s.sh_link,link);
  write32(be,shn->s.sh_info,info);
  write32(be,shn->s.sh_addralign,align);
  write32(be,shn->s.sh_entsize,entsize);
  return shn;
}

// Assembly:
subq $0x28, %rsp
movl 0x50(%rsp), %eax
movl 0x48(%rsp), %eax
movl 0x40(%rsp), %eax
movl 0x38(%rsp), %eax
movl 0x30(%rsp), %eax
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl %r9d, 0x10(%rsp)
callq 0x265f0
movq %rax, 0x8(%rsp)
movl 0x50(%rsp), %edi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
movl 0x24(%rsp), %edx
callq 0x8130
movl 0x50(%rsp), %edi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
addq $0x4, %rsi
movl 0x20(%rsp), %edx
callq 0x8130
movl 0x50(%rsp), %edi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
addq $0x8, %rsi
movl 0x1c(%rsp), %edx
callq 0x8130
movl 0x50(%rsp), %edi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
addq $0xc, %rsi
movl 0x18(%rsp), %edx
callq 0x8130
movl 0x50(%rsp), %edi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
addq $0x10, %rsi
movl 0x14(%rsp), %edx
callq 0x8130
movl 0x50(%rsp), %edi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
addq $0x14, %rsi
movl 0x10(%rsp), %edx
callq 0x8130
movl 0x50(%rsp), %edi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
addq $0x18, %rsi
movl 0x30(%rsp), %edx
callq 0x8130
movl 0x50(%rsp), %edi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
addq $0x1c, %rsi
movl 0x38(%rsp), %edx
callq 0x8130
movl 0x50(%rsp), %edi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
addq $0x20, %rsi
movl 0x40(%rsp), %edx
callq 0x8130
movl 0x50(%rsp), %edi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
addq $0x24, %rsi
movl 0x48(%rsp), %edx
callq 0x8130
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_makeshstrtab
void elf32_makeshstrtab(void)
/* creates .shstrtab */
{
  bool be = elf32_endianess == _BIG_ENDIAN_;

  elf32_addshdr(shstrtabidx,SHT_STRTAB,0,0,elf32offset,
                elf32shstrlist.nextindex,0,0,1,0,be);
  elf32offset += elf32shstrlist.nextindex;
  elf32offset += align(elf32offset,2);
}

// Assembly:
subq $0x38, %rsp
movsbl 0x1a715(%rip), %eax     # 0x402d0
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movl 0x1f130(%rip), %edi     # 0x44d00
movq 0x1f121(%rip), %rax     # 0x44cf8
movl %eax, %r8d
movl 0x1a6e7(%rip), %r9d     # 0x402c8
movl 0x34(%rsp), %eax
movl $0x3, %esi
xorl %ecx, %ecx
movl %ecx, %edx
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x25a40
movl 0x1a6ac(%rip), %eax     # 0x402c8
addq 0x1f0d5(%rip), %rax     # 0x44cf8
movq %rax, 0x1f0ce(%rip)     # 0x44cf8
movq 0x1f0c7(%rip), %rdi     # 0x44cf8
movl $0x2, %esi
callq 0x87f0
addq 0x1f0b6(%rip), %rax     # 0x44cf8
movq %rax, 0x1f0af(%rip)     # 0x44cf8
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_makestrtab
void elf32_makestrtab(void)
/* creates .strtab */
{
  bool be = elf32_endianess == _BIG_ENDIAN_;

  elf32_addshdr(strtabidx,SHT_STRTAB,0,0,elf32offset,
                elf32stringlist.nextindex,0,0,1,0,be);
  elf32offset += elf32stringlist.nextindex;
  elf32offset += align(elf32offset,2);
}

// Assembly:
subq $0x38, %rsp
movsbl 0x1a675(%rip), %eax     # 0x402d0
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movl 0x1f094(%rip), %edi     # 0x44d04
movq 0x1f081(%rip), %rax     # 0x44cf8
movl %eax, %r8d
movl 0x1a5e7(%rip), %r9d     # 0x40268
movl 0x34(%rsp), %eax
movl $0x3, %esi
xorl %ecx, %ecx
movl %ecx, %edx
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x25a40
movl 0x1a5ac(%rip), %eax     # 0x40268
addq 0x1f035(%rip), %rax     # 0x44cf8
movq %rax, 0x1f02e(%rip)     # 0x44cf8
movq 0x1f027(%rip), %rdi     # 0x44cf8
movl $0x2, %esi
callq 0x87f0
addq 0x1f016(%rip), %rax     # 0x44cf8
movq %rax, 0x1f00f(%rip)     # 0x44cf8
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_makestabstr
void elf32_makestabstr(void)
/* create .stabstr */
{
  if (stabdebugidx) {
    bool be = elf32_endianess == _BIG_ENDIAN_;
    uint32_t size = 0;
    struct StabCompUnit *cu;

    for (cu=(struct StabCompUnit *)elf32stabcompunits.first;
         cu->n.next!=NULL; cu=(struct StabCompUnit *)cu->n.next)
      size += cu->strtab.nextindex;

    if (stabshdr) {
      /* patch sh_link field of .stab */
      write32(be,stabshdr->s.sh_link,elf32shdridx);
    }
    elf32_addshdr(stabdebugidx,SHT_STRTAB,0,0,elf32offset,size,0,0,1,0,be);
    elf32offset += size;
  }
}

// Assembly:
subq $0x38, %rsp
cmpl $0x0, 0x1f00d(%rip)     # 0x44d08
je 0x25dd9
movsbl 0x1a5c8(%rip), %eax     # 0x402d0
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movq 0x1efea(%rip), %rax     # 0x44d10
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
je 0x25d55
movq 0x28(%rsp), %rax
movl 0x60(%rax), %eax
addl 0x30(%rsp), %eax
movl %eax, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x25d2b
cmpq $0x0, 0x1efcb(%rip)     # 0x44d28
je 0x25d7d
movl 0x34(%rsp), %edi
movq 0x1efbe(%rip), %rsi     # 0x44d28
addq $0x10, %rsi
addq $0x18, %rsi
movl 0x1ef78(%rip), %edx     # 0x44cf0
callq 0x8130
movl 0x1ef85(%rip), %edi     # 0x44d08
movq 0x1ef6e(%rip), %rax     # 0x44cf8
movl %eax, %r8d
movl 0x30(%rsp), %r9d
movl 0x34(%rsp), %eax
movl $0x3, %esi
xorl %ecx, %ecx
movl %ecx, %edx
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x25a40
movl 0x30(%rsp), %eax
addq 0x1ef26(%rip), %rax     # 0x44cf8
movq %rax, 0x1ef1f(%rip)     # 0x44cf8
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_makesymtab
void elf32_makesymtab(uint32_t strtabindex)
/* creates .symtab */
{
  bool be = elf32_endianess == _BIG_ENDIAN_;

  elf32_addshdr(symtabidx,SHT_SYMTAB,0,0,elf32offset,
                elf32symlist.nextindex * sizeof(struct Elf32_Sym),
                strtabindex,elf32symlist.global_index,4,
                sizeof(struct Elf32_Sym),be);
  elf32offset += elf32symlist.nextindex * sizeof(struct Elf32_Sym);
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movsbl 0x1a4e1(%rip), %eax     # 0x402d0
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x30(%rsp)
movl 0x1ef2c(%rip), %edi     # 0x44d30
movq 0x1eeed(%rip), %rax     # 0x44cf8
movl %eax, %r8d
movl 0x1a3f4(%rip), %eax     # 0x40208
shlq $0x4, %rax
movl %eax, %r9d
movl 0x34(%rsp), %r11d
movl 0x1a3e5(%rip), %r10d    # 0x4020c
movl 0x30(%rsp), %eax
movl $0x2, %esi
xorl %ecx, %ecx
movl %ecx, %edx
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl $0x4, 0x10(%rsp)
movl $0x10, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x25a40
movl 0x1a3ac(%rip), %eax     # 0x40208
shlq $0x4, %rax
addq 0x1ee91(%rip), %rax     # 0x44cf8
movq %rax, 0x1ee8a(%rip)     # 0x44cf8
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: newCompUnit
static struct StabCompUnit *newCompUnit(void)
{
  struct StabCompUnit *scu = alloczero(sizeof(struct StabCompUnit));

  initlist(&scu->stabs);
  scu->strtab.htabsize = STABHTABSIZE;
  return scu;
}

// Assembly:
pushq %rax
movl $0x68, %edi
callq 0x7290
movq %rax, (%rsp)
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x7330
movq (%rsp), %rax
movq $0x1000, 0x58(%rax)     # imm = 0x1000
movq (%rsp), %rax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: write_nlist
static void write_nlist(bool be,struct nlist32 *n,long strx,
                        uint8_t type,int8_t othr,int16_t desc,uint32_t val)
{
  write32(be,&n->n_strx,strx);
  n->n_type = type;
  n->n_other = othr;
  write16(be,&n->n_desc,desc);
  write32(be,&n->n_value,val);
}

// Assembly:
subq $0x38, %rsp
movl %r8d, (%rsp)
movl %ecx, %eax
movl (%rsp), %ecx
movl %eax, 0x4(%rsp)
movq %rdx, %rax
movl 0x4(%rsp), %edx
movq %rax, 0x8(%rsp)
movq %rsi, %rax
movq 0x8(%rsp), %rsi
movq %rax, 0x10(%rsp)
movl %edi, %r8d
movq 0x10(%rsp), %rdi
movw %r9w, %ax
movl 0x40(%rsp), %r9d
movl %r8d, 0x34(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movb %dl, 0x1f(%rsp)
movb %cl, 0x1e(%rsp)
movw %ax, 0x1c(%rsp)
movl 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rax
movl %eax, %edx
callq 0x8130
movb 0x1f(%rsp), %cl
movq 0x28(%rsp), %rax
movb %cl, 0x4(%rax)
movb 0x1e(%rsp), %cl
movq 0x28(%rsp), %rax
movb %cl, 0x5(%rax)
movl 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
addq $0x6, %rsi
movzwl 0x1c(%rsp), %edx
callq 0x80e0
movl 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
movl 0x40(%rsp), %edx
callq 0x8130
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_initoutput
void elf32_initoutput(struct GlobalVars *gv,
                      uint32_t init_file_offset,int8_t output_endianess)
/* initialize section header, program header, relocation, symbol, */
/* string and section header string lists */
{
  elf32_endianess = output_endianess;
  elf32offset = init_file_offset;
  file_hdr_gap = 0;

  if (gv->phdrlist == NULL) {
    /* we need to provide at least one dummy PHDR, even for reloc-objects */
    struct Phdr *p = alloczero(sizeof(struct Phdr));

    p->type = PT_LOAD;
    p->flags = PF_X|PF_W|PF_R|PHDR_USED;
    p->mem_end = p->file_end = 0xffffffff;
    p->offset = fff[gv->dest_format]->headersize(gv);
    gv->phdrlist = p;
  }

  initlist(&shdrlist);
  initlist(&phdrlist);
  initlist(&relalist);
  elf32shdridx = 0;

  symtabidx = elf32_addshdrstr(".symtab");
  strtabidx = elf32_addshdrstr(".strtab");
  shstrtabidx = elf32_addshdrstr(".shstrtab");
  elf32_newshdr();          /* first Shdr is always zero */
}

// Assembly:
subq $0x18, %rsp
movb %dl, %al
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
movb %al, 0x19df3(%rip)      # 0x402d0
movl 0xc(%rsp), %eax
movq %rax, 0x1e810(%rip)     # 0x44cf8
movq $0x0, 0x1e7dd(%rip) # 0x44cd0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x1f8(%rax)
jne 0x2657b
movl $0x58, %edi
callq 0x7290
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x1, 0x20(%rax)
movq (%rsp), %rax
movw $0x17, 0x24(%rax)
movq (%rsp), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0x38(%rax)
movq (%rsp), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0x40(%rax)
movq 0x10(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x194df(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x48(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x1f8(%rax)
leaq 0x1e756(%rip), %rdi     # 0x44cd8
callq 0x7330
leaq 0x1e7aa(%rip), %rdi     # 0x44d38
callq 0x7330
leaq 0x1e7b6(%rip), %rdi     # 0x44d50
callq 0x7330
movl $0x0, 0x1e747(%rip)     # 0x44cf0
leaq 0x100f6(%rip), %rdi     # 0x366a6
callq 0x25b90
movl %eax, 0x1e775(%rip)     # 0x44d30
leaq 0x100ec(%rip), %rdi     # 0x366ae
callq 0x25b90
movl %eax, 0x1e737(%rip)     # 0x44d04
leaq 0x100e2(%rip), %rdi     # 0x366b6
callq 0x25b90
movl %eax, 0x1e721(%rip)     # 0x44d00
callq 0x265f0
addq $0x18, %rsp
retq
nopl (%rax)