LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: dyn_reloc_entry
static void dyn_reloc_entry(struct GlobalVars *gv,struct Reloc *reloc,
                            int entrytype)
/* make a dyn_entry for a local GOT/PLT reference, fix reloc for entry */
{
  if (reloc->relocsect.ptr->obj->lnkfile->type!=ID_SHAREDOBJ
      && entrytype==PLT_LOCAL) {
    /* resolve PLT relocation to a local function directly */
    switch (reloc->rtype) {
      case R_PLT:
        reloc->rtype = R_ABS;
        break;
      case R_PLTPC:
        reloc->rtype = R_PC;
        break;
    }
  }
  else {
    DynArg a;
    struct Symbol *xdef;

    a.rel = reloc;
    if (xdef = dyn_entry(gv,a,entrytype)) {
      reloc->relocsect.ptr = xdef->relsect;
      reloc->addend = xdef->value;
    }
    else
      ierror("dyn_reloc_entry(): new xdef is NULL");
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzbl 0x39(%rax), %eax
cmpl $0x4, %eax
je 0xad98
cmpl $0x5, 0x24(%rsp)
jne 0xad98
movq 0x28(%rsp), %rax
movzbl 0x38(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x7, %eax
je 0xad82
jmp 0xad77
movl 0xc(%rsp), %eax
subl $0x8, %eax
je 0xad8d
jmp 0xad96
movq 0x28(%rsp), %rax
movb $0x1, 0x38(%rax)
jmp 0xad96
movq 0x28(%rsp), %rax
movb $0x2, 0x38(%rax)
jmp 0xadf6
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %edx
movq 0x18(%rsp), %rsi
callq 0xf150
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xade6
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x28(%rax)
jmp 0xadf4
leaq 0x2a72f(%rip), %rdi     # 0x3551c
movb $0x0, %al
callq 0x8ae0
jmp 0xadf6
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: linker_dynprep
void linker_dynprep(struct GlobalVars *gv)
/* Preparations for dynamic linking */
{
  /* hide unreferenced symbols from a shared library */
  hide_shlib_symbols(gv);

  /* export all global symbols when creating a shared library */
  if (gv->dest_sharedobj || gv->dyn_exp_all) {
    int i;

    for (i=0; i<SYMHTABSIZE; i++) {
      struct Symbol *sym;
      struct Symbol **chain = &gv->symbols[i];

      while (sym = *chain) {
        if (sym->bind>=SYMB_GLOBAL && !(sym->flags & SYMF_SHLIB) &&
            sym->relsect!=NULL && (sym->relsect->obj->flags & OUF_LINKED))
          dyn_export(gv,sym);
        chain = &sym->glob_chain;
      }
    }
  }

  /* let the target create and populate dynamic sections when needed */
  if (gv->dynamic && fff[gv->dest_format]->dyncreate)
    fff[gv->dest_format]->dyncreate(gv);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xfc50
movq 0x20(%rsp), %rax
cmpl $0x0, 0x58(%rax)
jne 0xae2d
movq 0x20(%rsp), %rax
cmpl $0x0, 0x5c(%rax)
je 0xaeed
movl $0x0, 0x1c(%rsp)
cmpl $0x10000, 0x1c(%rsp)    # imm = 0x10000
jge 0xaeeb
movq 0x20(%rsp), %rax
movq 0x180(%rax), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xaed9
movq 0x10(%rsp), %rax
movzbl 0x43(%rax), %eax
cmpl $0x2, %eax
jl 0xaec9
movq 0x10(%rsp), %rax
movzbl 0x41(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0xaec9
movq 0x10(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0xaec9
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movzwl 0x80(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xaec9
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa780
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
jmp 0xae60
jmp 0xaedb
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xae35
jmp 0xaeed
movq 0x20(%rsp), %rax
cmpl $0x0, 0x240(%rax)
je 0xaf39
movq 0x20(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x34b23(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x68(%rax)
je 0xaf39
movq 0x20(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x34b06(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movq 0x68(%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: cmpsecflags
static uint8_t cmpsecflags(struct GlobalVars *gv,struct LinkedSection *ls,
                           uint8_t new)
/* return 0xff if sections are incompatible, otherwise return new flags */
{
  uint8_t old = ls->flags;

  if (ls->ld_flags & LSF_NOLOAD)
    new &= ~SF_ALLOC;
  else if ((old&SF_ALLOC) != (new&SF_ALLOC))
    return 0xff;

  return (fff[gv->dest_format]->cmpsecflags != NULL) ?
         fff[gv->dest_format]->cmpsecflags(old,new) : (old | new);
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movb 0x21(%rax), %al
movb %al, 0xe(%rsp)
movq 0x10(%rsp), %rax
movzwl 0x24(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xc06f
movzbl 0xf(%rsp), %eax
andl $-0x2, %eax
movb %al, 0xf(%rsp)
jmp 0xc08c
movzbl 0xe(%rsp), %eax
andl $0x1, %eax
movzbl 0xf(%rsp), %ecx
andl $0x1, %ecx
cmpl %ecx, %eax
je 0xc08a
movb $-0x1, 0x27(%rsp)
jmp 0xc0f2
jmp 0xc08c
movq 0x18(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x33992(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x30(%rax)
je 0xc0da
movq 0x18(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x33975(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movq 0x30(%rax), %rax
movb 0xe(%rsp), %cl
movzbl %cl, %edi
movzbl 0xf(%rsp), %esi
callq *%rax
movzbl %al, %eax
movl %eax, 0x8(%rsp)
jmp 0xc0ea
movzbl 0xe(%rsp), %eax
movzbl 0xf(%rsp), %ecx
orl %ecx, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: allocate_common
static unsigned long allocate_common(struct GlobalVars *gv,
                                     struct Section *sec,unsigned long addr)
/* allocate all common symbols to section 'sec' at 'addr',
   returns number of total bytes allocated */
{
  unsigned long abytes,alloc=0;
  struct Symbol *sym;
  int i;

  for (i=0; i<SYMHTABSIZE; i++) {
    for (sym=gv->symbols[i]; sym; sym=sym->glob_chain) {
      /* common symbol from this section name? */
      if (sym->relsect==sec && sym->type==SYM_COMMON) {

        /* allocate and transform into SYM_RELOC */
        abytes = comalign(addr+alloc,sym->value);
        sym->value = (lword)((addr+alloc) - sec->va) + abytes;
        sym->type = SYM_RELOC;
        alloc += abytes + sym->size;

        if (gv->map_file)
          fprintf(gv->map_file,"Allocating common %s: %x at %llx hex\n",
                  sym->name,(int)sym->size,(lword)sec->va+sym->value);
      }
    }
  }

  sec->size += alloc;
  return alloc;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x10000, 0x4(%rsp)     # imm = 0x10000
jge 0xc444
movq 0x30(%rsp), %rax
movq 0x180(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xc432
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
cmpq 0x28(%rsp), %rax
jne 0xc41d
movq 0x8(%rsp), %rax
movzbl 0x40(%rax), %eax
cmpl $0x3, %eax
jne 0xc41d
movq 0x20(%rsp), %rdi
addq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rsi
callq 0x8830
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rcx
addq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
subq 0x30(%rax), %rcx
addq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rax
movb $0x2, 0x40(%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movl 0x44(%rcx), %ecx
addq %rcx, %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x90(%rax)
je 0xc41b
movq 0x30(%rsp), %rax
movq 0x90(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x8(%rsp), %rax
movl 0x44(%rax), %ecx
movq 0x28(%rsp), %rax
movq 0x30(%rax), %r8
movq 0x8(%rsp), %rax
addq 0x30(%rax), %r8
leaq 0x2912c(%rip), %rsi     # 0x35540
movb $0x0, %al
callq 0x5150
jmp 0xc41d
jmp 0xc41f
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xc33c
jmp 0xc434
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xc314
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
addq 0x48(%rax), %rcx
movq %rcx, 0x48(%rax)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: last_initialized
static struct Section *last_initialized(struct LinkedSection *ls)
/* search for bss-sections in reverse order, beginning at the end of
   the section-list, and return a pointer to the first initialized one,
   or NULL when all sections were uninitialized */
{
  struct Section *s;

  for (s=(struct Section *)ls->sections.last; s->n.pred!=NULL;
       s=(struct Section *)s->n.pred) {
    if (!(s->flags & SF_UNINITIALIZED))
      return (s);
  }
  return (NULL);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xc4ae
movq -0x18(%rsp), %rax
movzbl 0x2d(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0xc49c
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xc4b7
jmp 0xc49e
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0xc473
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: make_dynobj
static void make_dynobj(struct GlobalVars *gv)
{
  if (gv->dynobj == NULL) {
    gv->dynobj = art_objunit(gv,"DYNAMIC",NULL,0);
    gv->dynobj->flags |= OUF_LINKED;
    addhead(&gv->selobjects,&gv->dynobj->n);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x1e0(%rax)
jne 0xf13f
movq (%rsp), %rdi
leaq 0x26426(%rip), %rsi     # 0x35514
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x12350
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x1e0(%rax)
movq (%rsp), %rax
movq 0x1e0(%rax), %rax
movzwl 0x80(%rax), %ecx
orl $0x1, %ecx
movw %cx, 0x80(%rax)
movq (%rsp), %rdi
addq $0x138, %rdi            # imm = 0x138
movq (%rsp), %rax
movq 0x1e0(%rax), %rsi
callq 0x7410
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: dyn_entry
static struct Symbol *dyn_entry(struct GlobalVars *gv,DynArg arg,int entrytype)
{
  make_dynobj(gv);

  if (fff[gv->dest_format]->dynentry)
    return fff[gv->dest_format]->dynentry(gv,arg,entrytype);
  
  /* dynamic symbol reference not supported by target */
  error(126,fff[gv->dest_format]->tname);
  return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0xf0d0
movq 0x10(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x308b2(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x60(%rax)
je 0xf1ba
movq 0x10(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x30895(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movq 0x60(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movq 0x18(%rsp), %rsi
callq *%rax
movq %rax, 0x20(%rsp)
jmp 0xf1e8
movq 0x10(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x30864(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
movl $0x7e, %edi
movb $0x0, %al
callq 0x8c00
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: protstring
static char *protstring(uint8_t prot)
/* return pointer to protection string - example: "r---" or "rwxs" */
{
  static char ps[] = "----";
  char *p = ps;

  *p++ = (prot & SP_READ) ? 'r' : '-';
  *p++ = (prot & SP_WRITE) ? 'w' : '-';
  *p++ = (prot & SP_EXEC) ? 'x' : '-';
  *p++ = (prot & SP_SHARE) ? 's' : '-';
  return (ps);
}

// Assembly:
movb %dil, %al
movb %al, -0x1(%rsp)
leaq 0x307e2(%rip), %rax     # 0x3f9f0
movq %rax, -0x10(%rsp)
movzbl -0x1(%rsp), %edx
andl $0x1, %edx
movl $0x2d, %eax
movl $0x72, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rsp)
movb %cl, (%rax)
movzbl -0x1(%rsp), %edx
andl $0x2, %edx
movl $0x2d, %eax
movl $0x77, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rsp)
movb %cl, (%rax)
movzbl -0x1(%rsp), %edx
andl $0x4, %edx
movl $0x2d, %eax
movl $0x78, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rsp)
movb %cl, (%rax)
movzbl -0x1(%rsp), %edx
andl $0x8, %edx
movl $0x2d, %eax
movl $0x73, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rsp)
movb %cl, (%rax)
leaq 0x30722(%rip), %rax     # 0x3f9f0
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: checkrelrefs
static bool checkrelrefs(struct LinkedSection *ls,struct Section *newsec)
/* Check if there is a relative reference between those sections */
{
  struct Section *sec;

  for (sec=(struct Section *)ls->sections.first;
       sec->n.next!=NULL; sec=(struct Section *)sec->n.next) {
    /* check for references to 'newsec' */
    if (checkrr(sec->relrefs,newsec))
      return (TRUE);
    /* check for references from 'newsec' */
    if (checkrr(newsec->relrefs,sec))
      return (TRUE);
  }
  return (FALSE);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0xf352
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xf370
cmpl $0x0, %eax
je 0xf31c
movl $0x1, 0x24(%rsp)
jmp 0xf35a
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0xf370
cmpl $0x0, %eax
je 0xf341
movl $0x1, 0x24(%rsp)
jmp 0xf35a
jmp 0xf343
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xf2ec
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: checkrr
static bool checkrr(struct RelRef *rr,struct Section *sec)
/* Check if there is a relative reference to the specified section. */
{
  while (rr) {
    if (rr->refsec == sec)
      return (TRUE);
    rr = rr->next;
  }
  return (FALSE);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xf3ab
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rsp), %rax
jne 0xf39c
movl $0x1, -0x4(%rsp)
jmp 0xf3b3
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
jmp 0xf37a
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/dir.c
// Function: path_append
char *path_append(char *buf,const char *path,const char *add,size_t bufsize)
/* append a file- or path-name to an existing path */
{
  size_t len = strlen(path);

  if ((len+strlen(add)+1) < bufsize) {
    if (buf != path)
      strcpy(buf,path);
    if (len>0 && buf[len-1]!='/')
      buf[len++] = '/';
    strcpy(&buf[len],add);
    return (buf);
  }
  return (NULL);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x50c0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x50c0
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
addq $0x1, %rax
cmpq 0x10(%rsp), %rax
jae 0xf483
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0xf42a
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5060
cmpq $0x0, 0x8(%rsp)
jbe 0xf463
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0xf463
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb $0x2f, (%rax,%rcx)
movq 0x28(%rsp), %rdi
addq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5060
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xf48c
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: findsymbol
struct Symbol *findsymbol(struct GlobalVars *gv,struct Section *sec,
                          const char *name)
/* Return pointer to Symbol, otherwise return NULL.
   Make sure to prefer symbols from sec's ObjectUnit. */
{
  if (fff[gv->dest_format]->fndsymbol) {
    return fff[gv->dest_format]->fndsymbol(gv,sec,name);
  }
  else {
    struct Symbol *sym = gv->symbols[elf_hash(name)%SYMHTABSIZE];
    struct Symbol *found = NULL;

    while (sym) {
      if (!strcmp(name,sym->name)) {
        if (found && sec) {
          /* ignore, when not from the refering ObjectUnit */
          if (sym->relsect->obj == sec->obj)
            found = sym;
        }
        else
          found = sym;
      }
      sym = sym->glob_chain;
    }
    if (found!=NULL && found->type==SYM_INDIR)
      return findsymbol(gv,sec,found->indir_name);
    return found;
  }
  return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x3048b(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x40(%rax)
je 0xf5e5
movq 0x28(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x3046e(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movq 0x40(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq *%rax
movq %rax, 0x30(%rsp)
jmp 0xf6ce
movq 0x28(%rsp), %rax
movq 0x180(%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x8760
movq %rax, %rcx
movq (%rsp), %rax
andq $0xffff, %rcx           # imm = 0xFFFF
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xf68f
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x5130
cmpl $0x0, %eax
jne 0xf67f
cmpq $0x0, 0x8(%rsp)
je 0xf673
cmpq $0x0, 0x20(%rsp)
je 0xf673
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xf671
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0xf67d
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0xf67f
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xf61f
cmpq $0x0, 0x8(%rsp)
je 0xf6c4
movq 0x8(%rsp), %rax
movzbl 0x40(%rax), %eax
cmpl $0x4, %eax
jne 0xf6c4
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdx
callq 0xf580
movq %rax, 0x30(%rsp)
jmp 0xf6ce
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: check_protection
bool check_protection(struct GlobalVars *gv,const char *name)
/* checks if symbol name is protected against stripping */
{
  struct SymNames *sn = gv->prot_syms;

  while (sn) {
    if (!strcmp(sn->name,name))
      return TRUE;
    sn = sn->next;
  }
  return FALSE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0xb0(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xf738
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x5130
cmpl $0x0, %eax
jne 0xf729
movl $0x1, 0x24(%rsp)
jmp 0xf740
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xf6ff
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: hide_shlib_symbols
void hide_shlib_symbols(struct GlobalVars *gv)
/* scan for all unreferenced SYMF_SHLIB symbols in the global symbol list
   and remove them - they have to be invisible for the file we create */
{
  int i;

  for (i=0; i<SYMHTABSIZE; i++) {
    struct Symbol *sym;
    struct Symbol **chain = &gv->symbols[i];

    while (sym = *chain) {
      if ((sym->flags & SYMF_SHLIB) && !(sym->flags & SYMF_REFERENCED)) {
        /* remove from global symbol list */
        *chain = sym->glob_chain;
        sym->glob_chain = NULL;
      }
      else
        chain = &sym->glob_chain;
    }        
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x10000, -0xc(%rsp)    # imm = 0x10000
jge 0xfcff
movq -0x8(%rsp), %rax
movq 0x180(%rax), %rax
movslq -0xc(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, %rax
je 0xfced
movq -0x18(%rsp), %rax
movzbl 0x41(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xfcdd
movq -0x18(%rsp), %rax
movzbl 0x41(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0xfcdd
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
movq $0x0, 0x10(%rax)
jmp 0xfceb
movq -0x18(%rsp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rsp)
jmp 0xfc88
jmp 0xfcef
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xfc5d
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: findlocsymbol
struct Symbol *findlocsymbol(struct GlobalVars *gv,struct ObjectUnit *ou,
                             const char *name)
/* find a symbol which is local to the provided ObjectUnit */
{
  struct Symbol *sym;
  struct Symbol **chain = &ou->objsyms[elf_hash(name)%OBJSYMHTABSIZE];

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x8760
movq %rax, %rcx
movq (%rsp), %rax
andq $0x1f, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x10098
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x5130
cmpl $0x0, %eax
jne 0x10088
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x100a1
movq 0x10(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
jmp 0x10051
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: addlocsymbol
void addlocsymbol(struct GlobalVars *gv,struct Section *s,char *name,
                  char *iname,lword val,uint8_t type,uint8_t flags,
                  uint8_t info,uint32_t size)
/* Define a new local symbol. Local symbols are allowed to be */
/* multiply defined. */
{
  struct Symbol *sym;
  struct Symbol **chain = &s->obj->objsyms[elf_hash(name)%OBJSYMHTABSIZE];

  while (sym = *chain)
    chain = &sym->obj_chain;
  *chain = sym = alloczero(sizeof(struct Symbol));
  sym->name = name;
  sym->indir_name = iname;
  sym->value = val;
  sym->relsect = s;
  sym->type = type;
  sym->flags = flags;
  sym->info = info;
  sym->bind = SYMB_LOCAL;
  sym->size = size;
  if (check_protection(gv,name))
    sym->flags |= SYMF_PROTECTED;
}

// Assembly:
subq $0x48, %rsp
movb %r9b, %al
movl 0x60(%rsp), %r9d
movb 0x58(%rsp), %r9b
movb 0x50(%rsp), %r9b
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x48(%rax), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x8760
movq %rax, %rcx
movq (%rsp), %rax
andq $0x1f, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x10138
movq 0x10(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
jmp 0x10115
movl $0x50, %edi
callq 0x7290
movq %rax, %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x38(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
movb 0x1f(%rsp), %cl
movq 0x10(%rsp), %rax
movb %cl, 0x40(%rax)
movb 0x50(%rsp), %cl
movq 0x10(%rsp), %rax
movb %cl, 0x41(%rax)
movb 0x58(%rsp), %cl
movq 0x10(%rsp), %rax
movb %cl, 0x42(%rax)
movq 0x10(%rsp), %rax
movb $0x1, 0x43(%rax)
movl 0x60(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x44(%rax)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xf6e0
cmpl $0x0, %eax
je 0x101e6
movq 0x10(%rsp), %rax
movzbl 0x41(%rax), %ecx
orl $0x4, %ecx
movb %cl, 0x41(%rax)
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: addlnksymbol
struct Symbol *addlnksymbol(struct GlobalVars *gv,const char *name,lword val,
                            uint8_t type,uint8_t flags,uint8_t info,
                            uint8_t bind,uint32_t size)
/* Define a new, target-specific, linker symbol. */
{
  struct Symbol *sym;
  struct Symbol **chain;

  if (gv->lnksyms == NULL)
    gv->lnksyms = alloc_hashtable(LNKSYMHTABSIZE);
  chain = &gv->lnksyms[elf_hash(name)%LNKSYMHTABSIZE];

  while (sym = *chain)
    chain = &sym->obj_chain;
  *chain = sym = alloczero(sizeof(struct Symbol));
  sym->name = name;
  sym->value = val;
  sym->type = type;
  sym->flags = flags;
  sym->info = info;
  sym->bind = bind;
  sym->size = size;
  return sym;
}

// Assembly:
subq $0x58, %rsp
movl %r8d, 0x10(%rsp)
movl %ecx, %eax
movl 0x10(%rsp), %ecx
movl %eax, 0x14(%rsp)
movq %rdx, %rax
movl 0x14(%rsp), %edx
movq %rax, 0x18(%rsp)
movq %rsi, %rax
movq 0x18(%rsp), %rsi
movq %rax, 0x20(%rsp)
movq %rdi, %r8
movq 0x20(%rsp), %rdi
movb %r9b, %al
movl 0x68(%rsp), %r9d
movb 0x60(%rsp), %r9b
movq %r8, 0x50(%rsp)
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movb %dl, 0x3f(%rsp)
movb %cl, 0x3e(%rsp)
movb %al, 0x3d(%rsp)
movq 0x50(%rsp), %rax
cmpq $0x0, 0x188(%rax)
jne 0x10274
movl $0x10, %edi
callq 0x7310
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x188(%rax)
movq 0x50(%rsp), %rax
movq 0x188(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x8760
movq %rax, %rcx
movq 0x8(%rsp), %rax
andq $0xf, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x102ca
movq 0x30(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x28(%rsp)
jmp 0x102a7
movl $0x50, %edi
callq 0x7290
movq %rax, %rcx
movq %rcx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x48(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x30(%rax)
movb 0x3f(%rsp), %cl
movq 0x30(%rsp), %rax
movb %cl, 0x40(%rax)
movb 0x3e(%rsp), %cl
movq 0x30(%rsp), %rax
movb %cl, 0x41(%rax)
movb 0x3d(%rsp), %cl
movq 0x30(%rsp), %rax
movb %cl, 0x42(%rax)
movb 0x60(%rsp), %cl
movq 0x30(%rsp), %rax
movb %cl, 0x43(%rax)
movl 0x68(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x44(%rax)
movq 0x30(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: findlnksymbol
struct Symbol *findlnksymbol(struct GlobalVars *gv,const char *name)
/* return pointer to Symbol, if present */
{
  struct Symbol *sym;

  if (gv->lnksyms) {
    sym = gv->lnksyms[elf_hash(name)%LNKSYMHTABSIZE];
    while (sym) {
      if (!strcmp(name,sym->name))
        return sym;  /* symbol found! */
      sym = sym->obj_chain;
    }
  }
  return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x188(%rax)
je 0x103d9
movq 0x18(%rsp), %rax
movq 0x188(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x8760
movq %rax, %rcx
movq (%rsp), %rax
andq $0xf, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x103d7
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x5130
cmpl $0x0, %eax
jne 0x103c7
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x103e2
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x1039b
jmp 0x103d9
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: find_any_symbol
struct Symbol *find_any_symbol(struct GlobalVars *gv,struct Section *sec,
                               const char *name)
/* return pointer to a global symbol or linker symbol */
{
  struct Symbol *sym = findsymbol(gv,sec,name);

  if (sym == NULL)
    sym = findlnksymbol(gv,name);

  return sym;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xf580
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x10608
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x10350
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: newreloc
struct Reloc *newreloc(struct GlobalVars *gv,struct Section *sec,
                       const char *xrefname,struct Section *rs,uint32_t id,
                       unsigned long offset,uint8_t rtype,lword addend)
/* allocate and init new relocation structure */
{
  struct Reloc *r = alloczero(sizeof(struct Reloc));

  if (r->xrefname = xrefname) {
    if (sec->obj) {
      uint16_t flags = sec->obj->lnkfile->flags;

      if (flags & IFF_DELUNDERSCORE) {
        if (*xrefname == '_')
          r->xrefname = ++xrefname;
      }
      else if (flags & IFF_ADDUNDERSCORE) {
        char *new_name = alloc(strlen(xrefname) + 2);

        *new_name = '_';
        strcpy(new_name+1,xrefname);
        r->xrefname = new_name;
      }
    }
  }
  if (rs)
    r->relocsect.ptr = rs;
  else
    r->relocsect.id = id;
  r->offset = offset;
  r->addend = addend;
  r->rtype = rtype;
  return r;
}

// Assembly:
subq $0x48, %rsp
movq 0x58(%rsp), %rax
movb 0x50(%rsp), %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movq %r9, 0x18(%rsp)
movl $0x40, %edi
callq 0x7290
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0x1094e
movq 0x38(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1094c
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movw 0x3a(%rax), %ax
movw %ax, 0xe(%rsp)
movzwl 0xe(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x108fb
movq 0x30(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x108f9
movq 0x30(%rsp), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rsp)
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1094a
movzwl 0xe(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x10948
movq 0x30(%rsp), %rdi
callq 0x50c0
movq %rax, %rdi
addq $0x2, %rdi
callq 0x71f0
movq %rax, (%rsp)
movq (%rsp), %rax
movb $0x5f, (%rax)
movq (%rsp), %rdi
addq $0x1, %rdi
movq 0x30(%rsp), %rsi
callq 0x5060
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1094a
jmp 0x1094c
jmp 0x1094e
cmpq $0x0, 0x28(%rsp)
je 0x10966
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0x10972
movl 0x24(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x58(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movb 0x50(%rsp), %cl
movq 0x10(%rsp), %rax
movb %cl, 0x38(%rax)
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: addreloc
void addreloc(struct Section *sec,struct Reloc *r,
              uint16_t pos,uint16_t siz,lword mask)
/* Add a relocation description of the current type to this relocation,
   which will be inserted into the sections reloc list, if not
   already done. */
{
  struct RelocInsert *new = alloc(sizeof(struct RelocInsert));
  struct RelocInsert *ri = r->insert;

  new->next = NULL;
  new->bpos = pos;
  new->bsiz = siz;
  new->mask = mask;
  if (ri) {
    while (ri->next)
      ri = ri->next;
    ri->next = new;
  }
  else
    r->insert = new;

  if (r->n.next==NULL && sec!=NULL) {
    if (r->xrefname)
      addtail(&sec->xrefs,&r->n);  /* add to current section's XRef list */
    else
      addtail(&sec->relocs,&r->n);  /* add to current section's Reloc list */
  }
}

// Assembly:
subq $0x38, %rsp
movw %cx, %ax
movw %dx, %cx
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movw %cx, 0x26(%rsp)
movw %ax, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movl $0x18, %edi
callq 0x71f0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movw 0x26(%rsp), %cx
movq 0x10(%rsp), %rax
movw %cx, 0x8(%rax)
movw 0x24(%rsp), %cx
movq 0x10(%rsp), %rax
movw %cx, 0xa(%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x8(%rsp)
je 0x10a59
jmp 0x10a30
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x10a4a
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x10a30
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x10a67
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x10ab0
cmpq $0x0, 0x30(%rsp)
je 0x10ab0
movq 0x28(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x10a9b
movq 0x30(%rsp), %rdi
addq $0x68, %rdi
movq 0x28(%rsp), %rsi
callq 0x7470
jmp 0x10aae
movq 0x30(%rsp), %rdi
addq $0x50, %rdi
movq 0x28(%rsp), %rsi
callq 0x7470
jmp 0x10ab0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: isstdreloc
bool isstdreloc(struct Reloc *r,uint8_t type,uint16_t size)
/* return true when relocation type matches standard requirements */
{
  struct RelocInsert *ri;

  if (r->rtype==type && (ri = r->insert)!=NULL) {
    if (ri->bpos==0 && ri->bsiz==size && ri->mask==-1 && ri->next==NULL)
      return TRUE;
  }
  return FALSE;
}

// Assembly:
movw %dx, %ax
movb %sil, %cl
movq %rdi, -0x10(%rsp)
movb %cl, -0x11(%rsp)
movw %ax, -0x14(%rsp)
movq -0x10(%rsp), %rax
movzbl 0x38(%rax), %eax
movzbl -0x11(%rsp), %ecx
cmpl %ecx, %eax
jne 0x10b3d
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, %rax
je 0x10b3d
movq -0x20(%rsp), %rax
movzwl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0x10b3b
movq -0x20(%rsp), %rax
movzwl 0xa(%rax), %eax
movzwl -0x14(%rsp), %ecx
cmpl %ecx, %eax
jne 0x10b3b
movq -0x20(%rsp), %rax
cmpq $-0x1, 0x10(%rax)
jne 0x10b3b
movq -0x20(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x10b3b
movl $0x1, -0x4(%rsp)
jmp 0x10b45
jmp 0x10b3d
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: findreloc
struct Reloc *findreloc(struct Section *sec,unsigned long offset)
/* return possible relocation at offset */
{
  if (sec) {
    struct Reloc *reloc;

    for (reloc=(struct Reloc *)sec->relocs.first;
         reloc->n.next!=NULL; reloc=(struct Reloc *)reloc->n.next) {
      if (reloc->offset == offset)
        return reloc;
    }
  }
  return NULL;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0x10baa
movq -0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x10ba8
movq -0x20(%rsp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rsp), %rax
jne 0x10b97
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x10bb3
jmp 0x10b99
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x10b70
jmp 0x10baa
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: addstabs
void addstabs(struct ObjectUnit *ou,struct Section *sec,char *name,
              uint8_t type,int8_t other,int16_t desc,uint32_t value)
/* add an stab entry for debugging */
{
  struct StabDebug *stab = alloc(sizeof(struct StabDebug));

  stab->relsect = sec;
  stab->name.ptr = name;
  if (name) {
    if (*name == '\0')
      stab->name.ptr = NULL;
  }
  stab->n_type = type;
  stab->n_othr = other;
  stab->n_desc = desc;
  stab->n_value = value;
  addtail(&ou->stabs,&stab->n);
}

// Assembly:
subq $0x48, %rsp
movl %r8d, 0x8(%rsp)
movl %ecx, %eax
movl 0x8(%rsp), %ecx
movl %eax, 0xc(%rsp)
movq %rdx, %rax
movl 0xc(%rsp), %edx
movq %rax, 0x10(%rsp)
movq %rsi, %rax
movq 0x10(%rsp), %rsi
movq %rax, 0x18(%rsp)
movq %rdi, %r8
movq 0x18(%rsp), %rdi
movw %r9w, %ax
movl 0x50(%rsp), %r9d
movq %r8, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movb %dl, 0x2f(%rsp)
movb %cl, 0x2e(%rsp)
movw %ax, 0x2c(%rsp)
movl $0x28, %edi
callq 0x71f0
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
cmpq $0x0, 0x30(%rsp)
je 0x10c68
movq 0x30(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x10c66
movq 0x20(%rsp), %rax
movq $0x0, 0x18(%rax)
jmp 0x10c68
movb 0x2f(%rsp), %cl
movq 0x20(%rsp), %rax
movb %cl, 0x20(%rax)
movb 0x2e(%rsp), %cl
movq 0x20(%rsp), %rax
movb %cl, 0x21(%rax)
movw 0x2c(%rsp), %cx
movq 0x20(%rsp), %rax
movw %cx, 0x22(%rax)
movl 0x50(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x24(%rax)
movq 0x40(%rsp), %rdi
addq $0x50, %rdi
movq 0x20(%rsp), %rsi
callq 0x7470
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: fixstabs
void fixstabs(struct ObjectUnit *ou)
/* fix offsets of relocatable stab entries */
{
  struct StabDebug *stab;

  for (stab=(struct StabDebug *)ou->stabs.first;
       stab->n.next!=NULL; stab=(struct StabDebug *)stab->n.next) {
    if (stab->relsect) {
      stab->n_value += (uint32_t)stab->relsect->va;
    }
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x10d15
movq -0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x10d04
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rax), %rax
movl %eax, %ecx
movq -0x10(%rsp), %rax
addl 0x24(%rax), %ecx
movl %ecx, 0x24(%rax)
jmp 0x10d06
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
jmp 0x10cd3
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: addtargetext
struct TargetExt *addtargetext(struct Section *s,uint8_t id,uint8_t subid,
                               uint16_t flags,uint32_t size)
/* Add a new TargetExt structure of given type to a section. The contents */
/* of this structure is target-specific. */
{
  struct TargetExt *te,*newte = alloc(size);

  newte->next = NULL;
  newte->id = id;
  newte->sub_id = subid;
  newte->flags = flags;
  if (te = s->special) {
    while (te->next)
      te = te->next;
    te->next = newte;
  }
  else
    s->special = newte;
  return newte;
}

// Assembly:
subq $0x28, %rsp
movw %cx, %ax
movb %dl, %cl
movb %sil, %dl
movq %rdi, 0x20(%rsp)
movb %dl, 0x1f(%rsp)
movb %cl, 0x1e(%rsp)
movw %ax, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, %edi
callq 0x71f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb 0x1f(%rsp), %cl
movq 0x8(%rsp), %rax
movb %cl, 0x8(%rax)
movb 0x1e(%rsp), %cl
movq 0x8(%rsp), %rax
movb %cl, 0x9(%rax)
movw 0x1c(%rsp), %cx
movq 0x8(%rsp), %rax
movw %cx, 0xa(%rax)
movq 0x20(%rsp), %rax
movq 0x88(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x10dc7
jmp 0x10d9e
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x10db8
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x10d9e
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
jmp 0x10dd8
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x88(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: checktargetext
bool checktargetext(struct LinkedSection *ls,uint8_t id,uint8_t subid)
/* Checks if one of the sections in LinkedSection has a TargetExt */
/* block with the given id. If subid = 0 it will be ignored. */
{
  struct Section *sec = (struct Section *)ls->sections.first;
  struct Section *nextsec;
  struct TargetExt *te;

  while (nextsec = (struct Section *)sec->n.next) {
    if (te = sec->special) {
      do {
        if (te->id==id && (te->sub_id==subid || subid==0))
          return TRUE;
      }
      while (te = te->next);
    }
    sec = nextsec;
  }
  return FALSE;
}

// Assembly:
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x10(%rsp)
movb %cl, -0x11(%rsp)
movb %al, -0x12(%rsp)
movq -0x10(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
cmpq $0x0, %rax
je 0x10e9a
movq -0x20(%rsp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, %rax
je 0x10e8b
jmp 0x10e3c
movq -0x30(%rsp), %rax
movzbl 0x8(%rax), %eax
movzbl -0x11(%rsp), %ecx
cmpl %ecx, %eax
jne 0x10e74
movq -0x30(%rsp), %rax
movzbl 0x9(%rax), %eax
movzbl -0x12(%rsp), %ecx
cmpl %ecx, %eax
je 0x10e6a
movzbl -0x12(%rsp), %eax
cmpl $0x0, %eax
jne 0x10e74
movl $0x1, -0x4(%rsp)
jmp 0x10ea2
jmp 0x10e76
movq -0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, %rax
jne 0x10e3c
jmp 0x10e8b
movq -0x28(%rsp), %rax
movq %rax, -0x20(%rsp)
jmp 0x10e10
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: sort_relocs
void sort_relocs(struct list *rlist)
/* sorts a section's relocation list by their section offsets */
{
  struct Reloc *rel,**rel_ptr_array,**p;
  int cnt = 0;

  /* count relocs and make a pointer array */
  for (rel=(struct Reloc *)rlist->first; rel->n.next!=NULL;
       rel=(struct Reloc *)rel->n.next)
    cnt++;
  if (cnt > 1) {
    rel_ptr_array = alloc(cnt * sizeof(void *));
    for (rel=(struct Reloc *)rlist->first,p=rel_ptr_array;
         rel->n.next!=NULL; rel=(struct Reloc *)rel->n.next)
      *p++ = rel;

    /* sort pointer array */
    qsort(rel_ptr_array,cnt,sizeof(void *),reloc_offset_cmp);

    /* rebuild reloc list from sorted pointer array, then free it */
    initlist(rlist);
    for (p=rel_ptr_array; cnt; cnt--) {
      rel = *p++;
      addtail(rlist,&rel->n);
    }
    free(rel_ptr_array);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x117c3
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x1179e
cmpl $0x1, 0x4(%rsp)
jle 0x118a0
movslq 0x4(%rsp), %rdi
shlq $0x3, %rdi
callq 0x71f0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1182b
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x117f8
movq 0x10(%rsp), %rdi
movslq 0x4(%rsp), %rsi
movl $0x8, %edx
leaq 0x6f(%rip), %rcx        # 0x118b0
callq 0x5080
movq 0x20(%rsp), %rdi
callq 0x7330
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x11896
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7470
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1185a
movq 0x10(%rsp), %rdi
callq 0x5030
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: add_priptrs
void add_priptrs(struct GlobalVars *gv,struct ObjectUnit *ou)
/* Inserts all PriPointer nodes of an object into the global list. */
/* The node's position depends on 1. section name, 2. list name, */
/* 3. priority. */
{
  struct PriPointer *newpp,*nextpp,*pp;

  while (newpp = (struct PriPointer *)remhead(&ou->pripointers)) {
    pp = (struct PriPointer *)gv->pripointers.first;

    while (nextpp = (struct PriPointer *)pp->n.next) {
      int c;

      if ((c = strcmp(newpp->secname,pp->secname)) > 0)
        break;
      if (!c) {
        if ((c = strcmp(newpp->listname,pp->listname)) > 0)
          break;
        if (!c && newpp->priority < pp->priority)
          break;
      }
      pp = nextpp;
    }

    if (pp->n.pred)
      insertbefore(&newpp->n,&pp->n);
    else
      addhead(&gv->pripointers,&newpp->n);  /* first node in list */
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
addq $0x68, %rdi
callq 0x74d0
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x11a1e
movq 0x30(%rsp), %rax
movq 0x1a8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x119e6
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x5130
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
jle 0x11991
jmp 0x119e6
cmpl $0x0, 0xc(%rsp)
jne 0x119d7
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x5130
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
jle 0x119ba
jmp 0x119e6
cmpl $0x0, 0xc(%rsp)
jne 0x119d5
movq 0x20(%rsp), %rax
movl 0x20(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x119d5
jmp 0x119e6
jmp 0x119d7
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x1195c
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x11a03
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x7370
jmp 0x11a19
movq 0x30(%rsp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
movq 0x20(%rsp), %rsi
callq 0x7410
jmp 0x1192e
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: xtors_secname
static const char *xtors_secname(struct GlobalVars *gv,const char *defname)
{
  const char *name = defname;

  if (gv->collect_ctors_secname) {
    /* required to put constructors/destructors in non-default sections? */
    if (strcmp(gv->collect_ctors_secname,ctors_name) &&
        strcmp(gv->collect_ctors_secname,dtors_name))
      name = gv->collect_ctors_secname;
  }
  return name;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x208(%rax)
je 0x11c52
movq 0x10(%rsp), %rax
movq 0x208(%rax), %rdi
leaq 0x239b4(%rip), %rsi     # 0x355cd
callq 0x5130
cmpl $0x0, %eax
je 0x11c50
movq 0x10(%rsp), %rax
movq 0x208(%rax), %rdi
leaq 0x2399e(%rip), %rsi     # 0x355d4
callq 0x5130
cmpl $0x0, %eax
je 0x11c50
movq 0x10(%rsp), %rax
movq 0x208(%rax), %rax
movq %rax, (%rsp)
jmp 0x11c52
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/targets.c
// Function: add_xtor_sym
static void add_xtor_sym(struct GlobalVars *gv,int ctor,const char *name)
/* adds a constructor/destructor dummy symbol for linker_resolve() */
{
  if (ctor ? gv->ctor_symbol==NULL : gv->dtor_symbol==NULL) {
    struct Symbol *sym;

    if (sym = addlnksymbol(gv,name,0,SYM_ABS,0,SYMI_OBJECT,SYMB_GLOBAL,0)) {
      if (ctor)
        gv->ctor_symbol = sym;
      else
        gv->dtor_symbol = sym;
    }
    else
      error(59,name);  /* Can't define symbol as ctors/dtors label */
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x11c8d
movq 0x30(%rsp), %rax
cmpq $0x0, 0x210(%rax)
je 0x11c9c
jmp 0x11d15
movq 0x30(%rsp), %rax
cmpq $0x0, 0x218(%rax)
jne 0x11d15
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %r9d
xorl %r8d, %r8d
movl %r9d, %ecx
movl $0x2, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x101f0
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x11d02
cmpl $0x0, 0x2c(%rsp)
je 0x11cef
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x210(%rax)
jmp 0x11d00
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x218(%rax)
jmp 0x11d13
movq 0x20(%rsp), %rsi
movl $0x3b, %edi
movb $0x0, %al
callq 0x8c00
jmp 0x11d15
addq $0x38, %rsp
retq
nopw (%rax,%rax)