LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/main.c
// Function: ReadListFile
static void  ReadListFile(struct GlobalVars *gv,char *name,uint16_t flags)
/* read a file, which contains a list of object file names */
{
  FILE *f;
  struct InputFile *ifn;
  int c;
  char buf[256],*n=NULL;

  if (f = fopen(name,"r")) {
    do {
      int len = 0;

      c = fgetc(f);
      if (c == '\"') {  /* read file name in quotes */
        n = buf;
        len = 0;
        while ((c = fgetc(f))!=EOF && c!='\"') {
          if (len < 255) {
            len++;
            *n++ = c;
          }
        }
      }
      else if (c > ' ') {
        if (n == NULL) {
          n = buf;
          len = 0;
        }
        if (len < 255) {
          len++;
          *n++ = c;
        }
      }
      if (c<=' ' && n) {  /* file name ends here */
        *n = 0;
        ifn = alloc(sizeof(struct InputFile));
        ifn->name = allocstring(buf);
        ifn->lib = FALSE;
        ifn->flags = flags;
        addtail(&gv->inputlist,&ifn->n);
        n = NULL;
      }
    }
    while (c != EOF);
    fclose(f);
  }
  else
    error(8,name);  /* cannot open */
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movw %dx, %ax
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movw %ax, 0x136(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x138(%rsp), %rdi
leaq 0x2d7b6(%rip), %rsi     # 0x34790
callq 0x5200
movq %rax, 0x128(%rsp)
cmpq $0x0, %rax
je 0x71a4
jmp 0x6ff3
movl $0x0, 0x4(%rsp)
movq 0x128(%rsp), %rdi
callq 0x5110
movl %eax, 0x11c(%rsp)
cmpl $0x22, 0x11c(%rsp)
jne 0x709e
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x128(%rsp), %rdi
callq 0x5110
movl %eax, %ecx
movl %ecx, 0x11c(%rsp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, 0x3(%rsp)
je 0x705f
cmpl $0x22, 0x11c(%rsp)
setne %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x7069
jmp 0x709c
cmpl $0xff, 0x4(%rsp)
jge 0x709a
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
movl 0x11c(%rsp), %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %cl, (%rax)
jmp 0x702f
jmp 0x70f7
cmpl $0x20, 0x11c(%rsp)
jle 0x70f5
cmpq $0x0, 0x8(%rsp)
jne 0x70c2
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0xff, 0x4(%rsp)
jge 0x70f3
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
movl 0x11c(%rsp), %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %cl, (%rax)
jmp 0x70f5
jmp 0x70f7
cmpl $0x20, 0x11c(%rsp)
jg 0x7185
cmpq $0x0, 0x8(%rsp)
je 0x7185
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movl $0x28, %edi
callq 0x71f0
movq %rax, 0x120(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x72d0
movq %rax, %rcx
movq 0x120(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x120(%rsp), %rax
movl $0x0, 0x18(%rax)
movw 0x136(%rsp), %cx
movq 0x120(%rsp), %rax
movw %cx, 0x24(%rax)
movq 0x140(%rsp), %rdi
addq $0x18, %rdi
movq 0x120(%rsp), %rsi
callq 0x7470
movq $0x0, 0x8(%rsp)
jmp 0x7187
cmpl $-0x1, 0x11c(%rsp)
jne 0x6ff3
movq 0x128(%rsp), %rdi
callq 0x50a0
jmp 0x71b8
movq 0x138(%rsp), %rsi
movl $0x8, %edi
movb $0x0, %al
callq 0x8c00
addq $0x148, %rsp            # imm = 0x148
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: alloc
void *alloc(size_t size)
/* allocate memory and print error message if not enough available */
{
  void *p;

  if (!size)
    size = 1;
  if (!(p = malloc(size)))
    error(1);  /* out of memory */
  return p;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x720a
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x51a0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x722b
movl $0x1, %edi
movb $0x0, %al
callq 0x8c00
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: re_alloc
void *re_alloc(void *old,size_t size)
/* reallocate memory block, preserve old contents */
{
  void *p;

  if (!size)
    size = 1;
  if (!(p = realloc(old,size)))
    error(1);  /* out of memory */
  return p;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x725f
movq $0x1, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x51e0
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x7284
movl $0x1, %edi
movb $0x0, %al
callq 0x8c00
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: insertbefore
void insertbefore(struct node *n,struct node *sn)
/* insert node n directly before node sn */
/* sn must be a real node - no dummy nodes allowed! */
{
  struct node *pn = sn->pred;

  n->next = sn;
  n->pred = pn;
  pn->next = sn->pred = n;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: insertbehind
void insertbehind(struct node *pn,struct node *n)
/* insert node n directly behind node pn */
/* pn must be a real node - no dummy nodes allowed! */
{
  struct node *sn = pn->next;

  n->next = sn;
  n->pred = pn;
  pn->next = sn->pred = n;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x8(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: addhead
void addhead(struct list *l,struct node *n)
/* add node as first element of list */
{
  struct node *fn = l->first;

  n->pred = fn->pred;
  fn->pred = n;
  n->next = fn;
  l->first = n;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: addtail
void addtail(struct list *l,struct node *n)
/* add node as last element of list */
{
  struct node *ln = l->last;

  n->next = ln->next;
  ln->next = n;
  n->pred = ln;
  l->last = n;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: remhead
struct node *remhead(struct list *l)
/* remove first node in list and return a pointer to it */
{
  struct node *n = l->first;

  if (n->next) {
    l->first = n->next;
    n->next->pred = n->pred;
    return n;
  }
  return NULL;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x751e
movq -0x18(%rsp), %rax
movq (%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x7527
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: mapfile
char *mapfile(const char *name)
/* Map a complete file into memory and return its address. */
/* The file's length is returned in *(p-sizeof(size_t)). */
/* The last byte is followed by a 0-byte, indicating EOF for */
/* functions which need it. */
{
  FILE *fp;
  char *p=NULL;
  size_t fsiz;

  if (fp = fopen(name,"rb")) {
    fsiz = filesize(fp,name);
    p = alloc(fsiz+sizeof(size_t)+1);
    *(size_t *)p = fsiz;  /* store file size before the text starts */
    p += sizeof(size_t);
    *(p+fsiz) = 0;        /* terminated by 0-byte */
    if (fread(p,1,fsiz,fp) != fsiz) {
      fclose(fp);
      error(7,name);  /* read error */
    }
    fclose(fp);
  }
  return p;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x2bcfa(%rip), %rsi     # 0x33288
callq 0x5200
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x763b
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7650
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
addq $0x1, %rdi
callq 0x71f0
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl $0x1, %esi
callq 0x5090
cmpq 0x8(%rsp), %rax
je 0x7631
movq 0x18(%rsp), %rdi
callq 0x50a0
movq 0x20(%rsp), %rsi
movl $0x7, %edi
movb $0x0, %al
callq 0x8c00
movq 0x18(%rsp), %rdi
callq 0x50a0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: filesize
static size_t filesize(FILE *fp,const char *name)
{
  /* somebody knows a better way to determine file size in ANSI C? */
  long oldpos,size;

  if ((oldpos = ftell(fp)) >= 0)
    if (fseek(fp,0,SEEK_END) >= 0)
      if ((size = ftell(fp)) >= 0)
        if (fseek(fp,oldpos,SEEK_SET) >= 0)
          return (size_t)size;
  fclose(fp);
  error(5,name);  /* read error - doesn't return */
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x5160
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jl 0x76c6
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x51d0
cmpl $0x0, %eax
jl 0x76c4
movq 0x18(%rsp), %rdi
callq 0x5160
movq %rax, (%rsp)
cmpq $0x0, %rax
jl 0x76c2
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x51d0
cmpl $0x0, %eax
jl 0x76c0
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x76ea
jmp 0x76c2
jmp 0x76c4
jmp 0x76c6
movq 0x18(%rsp), %rdi
callq 0x50a0
movq 0x10(%rsp), %rsi
movl $0x5, %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/support.c
// Function: base_name
const char *base_name(const char *s)
/* returns last part of a path - the file name itself */
{
  char c;
  int l = strlen(s);

  while (l--) {
    c = s[l];
    if (c== '/' || c==':')
      return &s[l+1];
  }
  return s;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x50c0
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, (%rsp)
cmpl $0x0, %eax
je 0x7764
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x7(%rsp)
movsbl 0x7(%rsp), %eax
cmpl $0x2f, %eax
je 0x774a
movsbl 0x7(%rsp), %eax
cmpl $0x3a, %eax
jne 0x7762
movq 0x8(%rsp), %rax
movl (%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x776e
jmp 0x7716
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: checkrange
bool checkrange(lword val,bool sign,int size)
/* Checks if 'val' (signed or unsigned) fits into 'size' bits.
   Returns FALSE when 'val' is out of range! */
{
  if (size) {
    lword min = -(1LL<<(size-1));
    lword max = sign ? ((1LL<<(size-1))-1LL) : ((1LL<<size)-1LL);

    if (val<min || val>max)
      return FALSE;

    return TRUE;
  }

  ierror("checkrange(): size==0 (val=%lld)\n",val);
  return FALSE;  /* size==0 is illegal */
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
cmpl $0x0, 0x20(%rsp)
je 0x785e
movl 0x20(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x7811
movl 0x20(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x7828
movl 0x20(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x18(%rsp), %rax
jl 0x784a
movq 0x28(%rsp), %rax
cmpq 0x10(%rsp), %rax
jle 0x7854
movl $0x0, 0x34(%rsp)
jmp 0x7879
movl $0x1, 0x34(%rsp)
jmp 0x7879
movq 0x28(%rsp), %rsi
leaq 0x2ba21(%rip), %rdi     # 0x3328b
movb $0x0, %al
callq 0x8ae0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: write32be
void write32be(void *vp,uint32_t x)
/* write 32 bit word in big endian format */
{
  uint8_t *p = (uint8_t *)vp;

  *p++ = (uint8_t)((x>>24)&0xff);
  *p++ = (uint8_t)((x>>16)&0xff);
  *p++ = (uint8_t)((x>>8)&0xff);
  *p = (uint8_t)(x&0xff);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl -0xc(%rsp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movl -0xc(%rsp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movl -0xc(%rsp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movl -0xc(%rsp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rsp), %rax
movb %cl, (%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: write64be
void write64be(void *vp,uint64_t x)
/* write 64 bit word in big endian format */
{
  uint8_t *p = (uint8_t *)vp;

  *p++ = (uint8_t)((x>>56)&0xff);
  *p++ = (uint8_t)((x>>48)&0xff);
  *p++ = (uint8_t)((x>>40)&0xff);
  *p++ = (uint8_t)((x>>32)&0xff);
  *p++ = (uint8_t)((x>>24)&0xff);
  *p++ = (uint8_t)((x>>16)&0xff);
  *p++ = (uint8_t)((x>>8)&0xff);
  *p = (uint8_t)(x&0xff);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
shrq $0x38, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
shrq $0x30, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
shrq $0x28, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
shrq $0x20, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
shrq $0x18, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
shrq $0x10, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rsp), %rax
movb %cl, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: writetaddr
int writetaddr(struct GlobalVars *gv,void *p,lword d)
{
  bool be = fff[gv->dest_format]->endianess == _BIG_ENDIAN_;

  switch (fff[gv->dest_format]->addr_bits) {
    case 16:
      write16(be,p,(uint16_t)d);
      return 2;
    case 32:
      write32(be,p,(uint32_t)d);
      return 4;
    case 64:
      write64(be,p,(uint64_t)d);
      return 8;
    default:
      ierror("writetaddr(): target address has %d bits",
             (int)fff[gv->dest_format]->addr_bits);
      break;
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x3785b(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rcx
movb 0xaa(%rcx), %cl
subb $0x1, %cl
sete %cl
movzbl %cl, %ecx
movl %ecx, 0x4(%rsp)
movq 0x18(%rsp), %rcx
movzbl 0x50(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movsbl 0xab(%rax), %eax
movl %eax, (%rsp)
subl $0x10, %eax
je 0x821e
jmp 0x820a
movl (%rsp), %eax
subl $0x20, %eax
je 0x823e
jmp 0x8214
movl (%rsp), %eax
subl $0x40, %eax
je 0x825d
jmp 0x827a
movl 0x4(%rsp), %edi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
movzwl %ax, %edx
callq 0x80e0
movl $0x2, 0x24(%rsp)
jmp 0x82ad
movl 0x4(%rsp), %edi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
movl %eax, %edx
callq 0x8130
movl $0x4, 0x24(%rsp)
jmp 0x82ad
movl 0x4(%rsp), %edi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x8170
movl $0x8, 0x24(%rsp)
jmp 0x82ad
movq 0x18(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x377a4(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movsbl 0xab(%rax), %esi
leaq 0x2b00f(%rip), %rdi     # 0x332ad
movb $0x0, %al
callq 0x8ae0
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/support.c
// Function: readbf32
uint32_t readbf32(bool be,void *p,int offset,int size)
/* read value from 32-bit bitfield */
{
  if (size>0 && offset+size<=32) {
    uint32_t mask=(1<<size)-1;

    return (be)?((read32be(p) >> (32-(offset+size))) & mask)
                :((read32le(p) >> offset) & mask);
  }
  ierror("readbf32(): Illegal arguments: offset=%d size=%d",offset,size);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jle 0x8349
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
cmpl $0x20, %eax
jg 0x8349
movl 0x10(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x20(%rsp)
je 0x8327
movq 0x18(%rsp), %rdi
callq 0x7a00
movl 0x14(%rsp), %edx
addl 0x10(%rsp), %edx
movl $0x20, %ecx
subl %edx, %ecx
shrl %cl, %eax
andl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0x833f
movq 0x18(%rsp), %rdi
callq 0x7d20
movl 0x14(%rsp), %ecx
shrl %cl, %eax
andl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x8367
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
leaq 0x2af7e(%rip), %rdi     # 0x332d6
movb $0x0, %al
callq 0x8ae0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: writebf32
void writebf32(bool be,void *p,int offset,int size,uint32_t d)
/* write value to 32-bit bitfield */
{
  if (size>0 && offset+size<=32) {
    uint32_t mask=(1<<size)-1;

    if (be) {
      int s = 32-(offset+size);
      write32be(p,(read32be(p) & ~(mask<<s)) | ((d & mask) << s));
    }
    else
      write32le(p,(read32le(p) & ~(mask<<offset)) | ((d & mask) << offset));
  }
  else
    ierror("writebf32(): Illegal arguments: offset=%d size=%d",offset,size);
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
cmpl $0x0, 0x20(%rsp)
jle 0x8452
movl 0x24(%rsp), %eax
addl 0x20(%rsp), %eax
cmpl $0x20, %eax
jg 0x8452
movl 0x20(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x8413
movl 0x24(%rsp), %ecx
addl 0x20(%rsp), %ecx
movl $0x20, %eax
subl %ecx, %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7a00
movq 0x8(%rsp), %rdi
movl %eax, %esi
movl 0x18(%rsp), %eax
movl 0x14(%rsp), %ecx
shll %cl, %eax
xorl $-0x1, %eax
andl %eax, %esi
movl 0x1c(%rsp), %eax
andl 0x18(%rsp), %eax
movl 0x14(%rsp), %ecx
shll %cl, %eax
orl %eax, %esi
callq 0x7b30
jmp 0x8450
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x7d20
movq (%rsp), %rdi
movl %eax, %esi
movl 0x18(%rsp), %eax
movl 0x24(%rsp), %ecx
shll %cl, %eax
xorl $-0x1, %eax
andl %eax, %esi
movl 0x1c(%rsp), %eax
andl 0x18(%rsp), %eax
movl 0x24(%rsp), %ecx
shll %cl, %eax
orl %eax, %esi
callq 0x7e50
jmp 0x8468
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
leaq 0x2aea6(%rip), %rdi     # 0x33307
movb $0x0, %al
callq 0x8ae0
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: fwritex
void fwritex(FILE *fp,const void *buf,size_t len)
/* write a buffer of len bytes, with check for len=0 and write error */
{
  if (len) {
    if (!fwrite(buf,1,len,fp)) {
      fclose(fp);
      error(31,gvars.dest_name);  /* write error */
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, (%rsp)
je 0x84ca
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %esi
callq 0x5250
cmpq $0x0, %rax
jne 0x84c8
movq 0x10(%rsp), %rdi
callq 0x50a0
leaq 0x39ab0(%rip), %rax     # 0x41f68
movq 0x48(%rax), %rsi
movl $0x1f, %edi
movb $0x0, %al
callq 0x8c00
jmp 0x84ca
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: fwrite32be
void fwrite32be(FILE *fp,uint32_t w)
/* write a big endian 32 bit word */
{
  uint8_t be[4];

  be[0] = (w>>24) & 0xff;
  be[1] = (w>>16) & 0xff;
  be[2] = (w>>8) & 0xff;
  be[3] = w & 0xff;
  if (!fwrite(be,4,sizeof(uint8_t),fp)) {
    fclose(fp);
    error(31,gvars.dest_name);  /* write error */
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, 0x8(%rsp)
movl 0xc(%rsp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, 0x9(%rsp)
movl 0xc(%rsp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, 0xa(%rsp)
movl 0xc(%rsp), %eax
andl $0xff, %eax
movb %al, 0xb(%rsp)
leaq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x5250
cmpq $0x0, %rax
jne 0x855a
movq 0x10(%rsp), %rdi
callq 0x50a0
leaq 0x39a1e(%rip), %rax     # 0x41f68
movq 0x48(%rax), %rsi
movl $0x1f, %edi
movb $0x0, %al
callq 0x8c00
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: fwrite16be
void fwrite16be(FILE *fp,uint16_t w)
/* write a big endian 16 bit word */
{
  uint8_t be[2];

  be[0] = (w>>8) & 0xff;
  be[1] = w & 0xff;
  if (!fwrite(be,2,sizeof(uint8_t),fp)) {
    fclose(fp);
    error(31,gvars.dest_name);  /* write error */
  }
}

// Assembly:
subq $0x18, %rsp
movw %si, %ax
movq %rdi, 0x10(%rsp)
movw %ax, 0xe(%rsp)
movzwl 0xe(%rsp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, 0xc(%rsp)
movzwl 0xe(%rsp), %eax
andl $0xff, %eax
movb %al, 0xd(%rsp)
leaq 0xc(%rsp), %rdi
movq 0x10(%rsp), %rcx
movl $0x2, %esi
movl $0x1, %edx
callq 0x5250
cmpq $0x0, %rax
jne 0x85d0
movq 0x10(%rsp), %rdi
callq 0x50a0
leaq 0x399a8(%rip), %rax     # 0x41f68
movq 0x48(%rax), %rsi
movl $0x1f, %edi
movb $0x0, %al
callq 0x8c00
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: fwrite_align
void fwrite_align(FILE *fp,uint32_t a,uint32_t n)
/* writes as many zero bytes as required for alignment a (a bits */
/* must be zero) with current file offset n */
{
  static uint8_t alignment_bytes[MAX_FWALIGN];

  a = 1<<a;
  if ((n = (a-(n&(a-1))&(a-1))) > MAX_FWALIGN)
    ierror("fwrite_align(): Alignment > %d required",MAX_FWALIGN);
  fwritex(fp,alignment_bytes,n);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl 0xc(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl 0x8(%rsp), %ecx
movl 0xc(%rsp), %edx
subl $0x1, %edx
andl %edx, %ecx
subl %ecx, %eax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, 0x8(%rsp)
cmpl $0x2000, %eax           # imm = 0x2000
jbe 0x869a
leaq 0x2acab(%rip), %rdi     # 0x33339
movl $0x2000, %esi           # imm = 0x2000
movb $0x0, %al
callq 0x8ae0
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %eax
movl %eax, %edx
leaq 0x39b14(%rip), %rsi     # 0x421c0
callq 0x8470
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: fwritegap
void fwritegap(FILE *f,long bytes)
{
  uint8_t buf[GAPBUFSIZE];

  memset(buf,0,GAPBUFSIZE);
  do
    fwritex(f,buf,bytes>GAPBUFSIZE?GAPBUFSIZE:bytes);
  while ((bytes-=GAPBUFSIZE) > 0);
}

// Assembly:
subq $0x438, %rsp            # imm = 0x438
movq %rdi, 0x430(%rsp)
movq %rsi, 0x428(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x5100
movq 0x430(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x400, 0x428(%rsp) # imm = 0x400
jle 0x8719
movl $0x400, %eax            # imm = 0x400
movq %rax, 0x8(%rsp)
jmp 0x8726
movq 0x428(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0x8470
movq 0x428(%rsp), %rax
subq $0x400, %rax            # imm = 0x400
movq %rax, 0x428(%rsp)
cmpq $0x0, %rax
jg 0x86e8
addq $0x438, %rsp            # imm = 0x438
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: elf_hash
unsigned long elf_hash(const unsigned char *name)
/* calculate a hash code as used in ELF objects */
{
  unsigned long h=0,g;

  while (*name) {
    h = (h << 4) + *name++;
    if (g = h & 0xf0000000)
      h ^= g >> 24;
    h &= ~g;
  }
  return h;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
movq -0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x87df
movq -0x10(%rsp), %rax
shlq $0x4, %rax
movq -0x8(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rsp)
movzbl (%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x10(%rsp)
movabsq $0xf0000000, %rax       # imm = 0xF0000000
andq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, %rax
je 0x87ca
movq -0x18(%rsp), %rax
shrq $0x18, %rax
xorq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
xorq $-0x1, %rax
andq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
jmp 0x876e
movq -0x10(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: shiftcnt
int shiftcnt(uint32_t x)
/* returns number of 0-bits before the first 1-bit - something like */
/* an integer-log2() function - returns 0 on x=0 */
{
  int i;

  if (x == 0)
    return 0;
  for (i=0; i<32; i++) {
    if (x & 1)
      break;
    x >>= 1;
  }
  return i;
}

// Assembly:
movl %edi, -0x8(%rsp)
cmpl $0x0, -0x8(%rsp)
jne 0x8875
movl $0x0, -0x4(%rsp)
jmp 0x88b1
movl $0x0, -0xc(%rsp)
cmpl $0x20, -0xc(%rsp)
jge 0x88a9
movl -0x8(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8892
jmp 0x88a9
movl -0x8(%rsp), %eax
shrl %eax
movl %eax, -0x8(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x887d
movl -0xc(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: lshiftcnt
int lshiftcnt(lword x)
/* shiftcnt() of an lword */
{
  int i,n=sizeof(lword)<<3;

  if (x == 0)
    return 0;
  for (i=0; i<n; i++) {
    if (x & 1)
      break;
    x >>= 1;
  }
  return i;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl $0x40, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0x88df
movl $0x0, -0x4(%rsp)
jmp 0x8924
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
cmpl -0x18(%rsp), %eax
jge 0x891c
movq -0x10(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x8902
jmp 0x891c
movq -0x10(%rsp), %rax
sarq %rax
movq %rax, -0x10(%rsp)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x88e7
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: memset16
void memset16(struct GlobalVars *gv,void *start,uint16_t fill,long n)
{
  if (n > 0) {
    uint8_t f[2];
    uint8_t *p;
    int i;

    write16(fff[gv->dest_format]->endianess==_BIG_ENDIAN_,f,fill);
    for (p=start,i=((unsigned long)start)&1; n; n--,i^=1)
      *p++ = f[i];
  }
}

// Assembly:
subq $0x38, %rsp
movw %dx, %ax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movw %ax, 0x26(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jle 0x89e6
movq 0x30(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x370c7(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movsbl 0xaa(%rax), %eax
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x16(%rsp), %rsi
movzwl 0x26(%rsp), %edx
callq 0x80e0
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
andq $0x1, %rax
movl %eax, 0x4(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x89e4
movslq 0x4(%rsp), %rax
movb 0x16(%rsp,%rax), %cl
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %cl, (%rax)
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
movl 0x4(%rsp), %eax
xorl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x89a5
jmp 0x89e6
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/support.c
// Function: add_symnames
void add_symnames(struct SymNames **snlist,const char *name)
/* add a new name to a SymNames list */
{
  struct SymNames *new = alloc(sizeof(struct SymNames));
  struct SymNames *sn;

  new->next = NULL;
  new->name = name;
  if (sn = *snlist) {
    while (sn->next)
      sn = sn->next;
    sn->next = new;
  }
  else
    *snlist = new;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x10, %edi
callq 0x71f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x8ac5
jmp 0x8a9c
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x8ab6
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x8a9c
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x8ad2
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/errors.c
// Function: ierror
void ierror(char *errtxt,...)
/* display internal error and quit */
{
  struct GlobalVars *gv = &gvars;
  va_list vl;

  fprintf(stderr,"\nINTERNAL ERROR: ");
  va_start(vl,errtxt);
  vfprintf(stderr,errtxt,vl);
  va_end(vl);
  fprintf(stderr,".\nAborting.\n");
  gv->returncode = EXIT_FAILURE;
  cleanup(gv);
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x8b1f
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm3, 0x70(%rsp)
movaps %xmm4, 0x80(%rsp)
movaps %xmm5, 0x90(%rsp)
movaps %xmm6, 0xa0(%rsp)
movaps %xmm7, 0xb0(%rsp)
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0xe0(%rsp)
leaq 0x39421(%rip), %rax     # 0x41f68
movq %rax, 0xd8(%rsp)
movq 0x364a2(%rip), %rax     # 0x3eff8
movq %rax, (%rsp)
movq (%rax), %rdi
leaq 0x2a7fd(%rip), %rsi     # 0x33361
xorl %eax, %eax
movb %al, 0xf(%rsp)
callq 0x5150
movq (%rsp), %rax
leaq 0x10(%rsp), %rcx
movq %rcx, 0xd0(%rsp)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0xc8(%rsp)
movl $0x30, 0xc4(%rsp)
movl $0x8, 0xc0(%rsp)
movq (%rax), %rdi
movq 0xe0(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x5210
movq (%rsp), %rcx
movb 0xf(%rsp), %al
movq (%rcx), %rdi
leaq 0x2a7a3(%rip), %rsi     # 0x33373
callq 0x5150
movq 0xd8(%rsp), %rax
movl $0x1, 0x11c(%rax)
movq 0xd8(%rsp), %rdi
callq 0x5370
addq $0xe8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: getobjname
const char *getobjname(struct ObjectUnit *obj)
/* if library: return "file name(object name)" */
/* else: return "file name" */
{
  const char *fn = obj->lnkfile->filename;

  if (obj->lnkfile->type == ID_LIBARCH) {
    const char *on = obj->objname;
    if (strlen(fn)+strlen(on)+2 < FNAMEBUFSIZE) {
      sprintf(namebuf,"%s(%s)",fn,on);
      return (namebuf);
    }
  }
  return (fn);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movzbl 0x39(%rax), %eax
cmpl $0x8, %eax
jne 0x8f98
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x50c0
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x50c0
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
addq $0x2, %rax
cmpq $0x400, %rax            # imm = 0x400
jae 0x8f96
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0x3b246(%rip), %rdi     # 0x441c0
leaq 0x2c147(%rip), %rsi     # 0x350c8
movb $0x0, %al
callq 0x5230
leaq 0x3b231(%rip), %rax     # 0x441c0
movq %rax, 0x20(%rsp)
jmp 0x8fa2
jmp 0x8f98
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: print_symbol
void print_symbol(FILE *f,struct Symbol *sym)
/* print symbol name, type, value, etc. */
{
  if (sym->type == SYM_COMMON)
    fprintf(f,"  %s: %s%s%s, alignment %d, size %d\n",sym->name,
            sym_bind[sym->bind],sym_type[sym->type],sym_info[sym->info],
            (int)sym->value,(int)sym->size);
  else if (sym->type == SYM_INDIR)
    fprintf(f,"  %s: %s%s%s, referencing %s\n",sym->name,
            sym_bind[sym->bind],sym_type[sym->type],sym_info[sym->info],
            sym->indir_name);
  else
#if 0
    fprintf(f,"  %s: %s%s%s, value 0x%llx, size %d\n",sym->name,
            sym_bind[sym->bind],sym_type[sym->type],sym_info[sym->info],
            (uint64_t)sym->value,(int)sym->size);
#else
    fprintf(f,"  %s: %s%s%s, value 0x%x, size %d\n",sym->name,
            sym_bind[sym->bind],sym_type[sym->type],sym_info[sym->info],
            (uint32_t)sym->value,(int)sym->size);
#endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl 0x40(%rax), %eax
cmpl $0x3, %eax
jne 0x922b
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x18(%rsp), %rax
movzbl 0x43(%rax), %eax
movl %eax, %ecx
leaq 0x369b4(%rip), %rax     # 0x3fb80
movq (%rax,%rcx,8), %rcx
movq 0x18(%rsp), %rax
movzbl 0x40(%rax), %eax
movl %eax, %esi
leaq 0x3693e(%rip), %rax     # 0x3fb20
movq (%rax,%rsi,8), %r8
movq 0x18(%rsp), %rax
movzbl 0x42(%rax), %eax
movl %eax, %esi
leaq 0x36958(%rip), %rax     # 0x3fb50
movq (%rax,%rsi,8), %r9
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movl %eax, %r10d
movq 0x18(%rsp), %rax
movl 0x44(%rax), %eax
leaq 0x2beda(%rip), %rsi     # 0x350f1
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x5150
jmp 0x9322
movq 0x18(%rsp), %rax
movzbl 0x40(%rax), %eax
cmpl $0x4, %eax
jne 0x92a6
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x18(%rsp), %rax
movzbl 0x43(%rax), %eax
movl %eax, %ecx
leaq 0x36927(%rip), %rax     # 0x3fb80
movq (%rax,%rcx,8), %rcx
movq 0x18(%rsp), %rax
movzbl 0x40(%rax), %eax
movl %eax, %esi
leaq 0x368b1(%rip), %rax     # 0x3fb20
movq (%rax,%rsi,8), %r8
movq 0x18(%rsp), %rax
movzbl 0x42(%rax), %eax
movl %eax, %esi
leaq 0x368cb(%rip), %rax     # 0x3fb50
movq (%rax,%rsi,8), %r9
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
leaq 0x2be7d(%rip), %rsi     # 0x35116
movq %rax, (%rsp)
movb $0x0, %al
callq 0x5150
jmp 0x9320
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x18(%rsp), %rax
movzbl 0x43(%rax), %eax
movl %eax, %ecx
leaq 0x368ba(%rip), %rax     # 0x3fb80
movq (%rax,%rcx,8), %rcx
movq 0x18(%rsp), %rax
movzbl 0x40(%rax), %eax
movl %eax, %esi
leaq 0x36844(%rip), %rax     # 0x3fb20
movq (%rax,%rsi,8), %r8
movq 0x18(%rsp), %rax
movzbl 0x42(%rax), %eax
movl %eax, %esi
leaq 0x3685e(%rip), %rax     # 0x3fb50
movq (%rax,%rsi,8), %r9
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movl %eax, %r10d
movq 0x18(%rsp), %rax
movl 0x44(%rax), %eax
leaq 0x2be23(%rip), %rsi     # 0x35134
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x5150
jmp 0x9322
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: trace_sym_access
bool trace_sym_access(struct GlobalVars *gv,const char *name)
/* check if the symbol with this name should be traced */
{
  struct SymNames *sn;

  if (gv->trace_syms) {
    sn = gv->trace_syms[elf_hash(name)%TRSYMHTABSIZE];
    while (sn) {
      if (!strcmp(name,sn->name))
        return (TRUE);  /* symbol found! */
      sn = sn->next;
    }
  }
  return (FALSE);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x93b6
movq 0x18(%rsp), %rax
movq 0xa8(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x8760
movq %rax, %rcx
movq (%rsp), %rax
andq $0x3f, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x93b4
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x5130
cmpl $0x0, %eax
jne 0x93a5
movl $0x1, 0x24(%rsp)
jmp 0x93be
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x937b
jmp 0x93b6
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: linker_init
void linker_init(struct GlobalVars *gv)
{
  initlist(&gv->linkfiles);
  initlist(&gv->selobjects);
  initlist(&gv->libobjects);
  initlist(&gv->sharedobjects);
  gv->symbols = alloc_hashtable(SYMHTABSIZE);
  initlist(&gv->pripointers);
  initlist(&gv->scriptsymbols);
  gv->got_base_name = gotbase_name;
  gv->plt_base_name = pltbase_name;

  if (gv->reloctab_format != RTAB_UNDEF) {
    if (!(fff[gv->dest_format]->rtab_mask & gv->reloctab_format)) {
      error(122,fff[gv->dest_format]->tname);
      gv->reloctab_format = fff[gv->dest_format]->rtab_format;
    }
  }
  else
    gv->reloctab_format = fff[gv->dest_format]->rtab_format;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0x7330
movq (%rsp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x7330
movq (%rsp), %rdi
addq $0x150, %rdi            # imm = 0x150
callq 0x7330
movq (%rsp), %rdi
addq $0x168, %rdi            # imm = 0x168
callq 0x7330
movl $0x10000, %edi          # imm = 0x10000
callq 0x7310
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x180(%rax)
movq (%rsp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x7330
movq (%rsp), %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0x7330
movq (%rsp), %rax
leaq 0x2c1a8(%rip), %rcx     # 0x35600
movq %rcx, 0x230(%rax)
movq (%rsp), %rax
leaq 0x2c1b6(%rip), %rcx     # 0x35620
movq %rcx, 0x238(%rax)
movq (%rsp), %rax
movzbl 0x6e(%rax), %eax
cmpl $0x0, %eax
je 0x94f1
movq (%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x365a1(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movzbl 0xa9(%rax), %eax
movq (%rsp), %rcx
movzbl 0x6e(%rcx), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x94ef
movq (%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x36576(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
movl $0x7a, %edi
movb $0x0, %al
callq 0x8c00
movq (%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x36552(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movb 0xa8(%rax), %cl
movq (%rsp), %rax
movb %cl, 0x6e(%rax)
jmp 0x9513
movq (%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x3652e(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movb 0xa8(%rax), %cl
movq (%rsp), %rax
movb %cl, 0x6e(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: maplibrary
static char *maplibrary(struct GlobalVars *gv,struct InputFile *ifn)
/* Map a complete file into memory and return its address. */
/* The file's length is returned in *(p-sizeof(size_t)). */
/* All defined library paths will be searched for the file, */
/* before aborting. On success, the complete path of the loaded */
/* file is stored in namebuf[]. */
{
  char *p;
  char libname[FNAMEBUFSIZE];

  if (strlen(ifn->name) < (FNAMEBUFSIZE-16)) {
    if (ifn->dynamic) {
      sprintf(libname,"lib%s.so",ifn->name);
      if (p = searchlib(gv,libname,ifn->so_ver))
        return (p);
    }
    sprintf(libname,"lib%s.a",ifn->name);
    if (p = searchlib(gv,libname,-1))
      return (p);
    sprintf(libname,"%s.lib",ifn->name);
    if (p = searchlib(gv,libname,-1))
      return (p);
  }
  return (NULL);
}

// Assembly:
subq $0x428, %rsp            # imm = 0x428
movq %rdi, 0x418(%rsp)
movq %rsi, 0x410(%rsp)
movq 0x410(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x50c0
cmpq $0x3f0, %rax            # imm = 0x3F0
jae 0x9b55
movq 0x410(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x9aaf
movq %rsp, %rdi
movq 0x410(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x2b9eb(%rip), %rsi     # 0x35453
movb $0x0, %al
callq 0x5230
movq 0x418(%rsp), %rdi
movq %rsp, %rsi
movq 0x410(%rsp), %rax
movl 0x20(%rax), %edx
callq 0xec00
movq %rax, 0x408(%rsp)
cmpq $0x0, %rax
je 0x9aad
movq 0x408(%rsp), %rax
movq %rax, 0x420(%rsp)
jmp 0x9b61
jmp 0x9aaf
movq %rsp, %rdi
movq 0x410(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x2b997(%rip), %rsi     # 0x3545c
movb $0x0, %al
callq 0x5230
movq 0x418(%rsp), %rdi
movq %rsp, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xec00
movq %rax, 0x408(%rsp)
cmpq $0x0, %rax
je 0x9b01
movq 0x408(%rsp), %rax
movq %rax, 0x420(%rsp)
jmp 0x9b61
movq %rsp, %rdi
movq 0x410(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x2b94d(%rip), %rsi     # 0x35464
movb $0x0, %al
callq 0x5230
movq 0x418(%rsp), %rdi
movq %rsp, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xec00
movq %rax, 0x408(%rsp)
cmpq $0x0, %rax
je 0x9b53
movq 0x408(%rsp), %rax
movq %rax, 0x420(%rsp)
jmp 0x9b61
jmp 0x9b55
movq $0x0, 0x420(%rsp)
movq 0x420(%rsp), %rax
addq $0x428, %rsp            # imm = 0x428
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: lnksymbol
static struct Symbol *lnksymbol(struct GlobalVars *gv,struct Section *sec,
                                struct Reloc *xref)
{
  struct Symbol *sym;

  if (sym = findlnksymbol(gv,xref->xrefname))
    return (sym);

  if (fff[gv->dest_format]->lnksymbol)
    return (fff[gv->dest_format]->lnksymbol(gv,sec,xref));

  return (NULL);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x10350
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xa61b
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xa673
movq 0x18(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x35403(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x48(%rax)
je 0xa66a
movq 0x18(%rsp), %rax
movzbl 0x50(%rax), %eax
movl %eax, %ecx
leaq 0x353e6(%rip), %rax     # 0x3fa30
movq (%rax,%rcx,8), %rax
movq 0x48(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq *%rax
movq %rax, 0x20(%rsp)
jmp 0xa673
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: dyn_ext_entry
static struct Symbol *dyn_ext_entry(struct GlobalVars *gv,
                                    struct Symbol *xdef,struct Reloc *xref,
                                    int entrytype)
/* make a dyn_entry for an external reference */
{
  if (xdef->relsect->obj->lnkfile->type!=ID_SHAREDOBJ
      && entrytype==PLT_ENTRY) {
    /* resolve PLT relocation to a local function directly */
    switch (xref->rtype) {
      case R_PLT:
        xref->rtype = R_ABS;
        break;
      case R_PLTPC:
        xref->rtype = R_PC;
        break;
    }
  }
  else {
    DynArg a;
    struct Symbol *sym;

    a.sym = xdef;
    sym = dyn_entry(gv,a,entrytype);
    if (sym)
      return sym;
  }
  return xdef;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzbl 0x39(%rax), %eax
cmpl $0x4, %eax
je 0xa72d
cmpl $0x2, 0x24(%rsp)
jne 0xa72d
movq 0x28(%rsp), %rax
movzbl 0x38(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x7, %eax
je 0xa717
jmp 0xa70c
movl 0xc(%rsp), %eax
subl $0x8, %eax
je 0xa722
jmp 0xa72b
movq 0x28(%rsp), %rax
movb $0x1, 0x38(%rax)
jmp 0xa72b
movq 0x28(%rsp), %rax
movb $0x2, 0x38(%rax)
jmp 0xa765
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl 0x24(%rsp), %edx
movq 0x18(%rsp), %rsi
callq 0xf150
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xa763
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xa76f
jmp 0xa765
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: dyn_export
static void dyn_export(struct GlobalVars *gv,struct Symbol *sym)
{
  DynArg a;

  if (!(sym->flags & SYMF_DYNLINK)) {
    sym->flags |= SYMF_DYNEXPORT;
    a.sym = sym;
    dyn_entry(gv,a,SYM_ENTRY);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl 0x41(%rax), %eax
andl $0xc0, %eax
cmpl $0x0, %eax
jne 0xa7cf
movq 0x8(%rsp), %rax
movzbl 0x41(%rax), %ecx
orl $0x80, %ecx
movb %cl, 0x41(%rax)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movl $0x7, %edx
callq 0xf150
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/linker.c
// Function: addrelref
static void addrelref(struct RelRef **rrptr,struct Section *sec)
/* if not already exists, add a new relative reference to another sect. */
{
  struct RelRef *rr;

  if (rr = *rrptr) {
    while (rr->next) {
      if (rr->refsec == sec)
        return;  /* reference already exists */
      rr = rr->next;
    }
  }
  else
    rr = (struct RelRef *)rrptr;

  rr->next = alloczero(sizeof(struct RelRef));
  rr->next->refsec = sec;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xacfc
jmp 0xacd2
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0xacfa
movq (%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x8(%rsp), %rax
jne 0xaced
jmp 0xad29
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0xacd2
jmp 0xad05
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x10, %edi
callq 0x7290
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nop