LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_elf32i386.c
// Function: i386_dynentry
static struct Symbol *i386_dynentry(struct GlobalVars *gv,DynArg a,int etype)
/* Create an entry into .got/.plt/.bss for the referenced symbol. */
{
  struct Symbol *entry_sym = NULL;
  struct Section *sec;
  char *bssname;

  switch (etype) {

    case GOT_ENTRY:
    case GOT_LOCAL:
      /* .got has 12 bytes reserved at the beginning,
         is writable, a new entry occupies 4 bytes. */
      sec = elf32_dyntable(gv,12,12,ST_DATA,SF_ALLOC,
                           SP_READ|SP_WRITE,GOT_ENTRY);
      entry_sym = elf32_pltgotentry(gv,sec,a,SYMI_OBJECT,4,4,etype);
      break;

    case PLT_ENTRY:
      /* .plt has 16 bytes reserved at the beginning, is executable,
         a new entry occupies another 16 bytes. */
      sec = elf32_dyntable(gv,16,16,ST_CODE,SF_ALLOC,
                           SP_READ|SP_EXEC,PLT_ENTRY);

      entry_sym = elf32_pltgotentry(gv,sec,a,SYMI_FUNC,16,16,PLT_ENTRY);
      break;

    case BSS_ENTRY:
      /* @@@ */
      ierror("i386_dynentry(): BSS_ENTRY not yet written");
      break;

    default:
      ierror("i386_dynentry(): illegal entrytype: %d",etype);
      break;
  }

  return entry_sym;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
leal -0x1(%r15), %eax
cmpl $0x3, %eax
ja 0x1917c
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8e44(%rip), %rcx      # 0x21f30
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, (%rsp)
pushq $0xc
popq %rdx
pushq $0x2
popq %rcx
pushq $0x1
popq %rbp
pushq $0x3
popq %r9
movq %r14, %rdi
movq %rdx, %rsi
movl %ebp, %r8d
callq 0x14a58
movl %r15d, (%rsp)
pushq $0x4
popq %r8
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
movq %r8, %r9
jmp 0x19165
pushq $0x2
popq %rbp
movl %ebp, (%rsp)
pushq $0x10
popq %r15
pushq $0x1
popq %rcx
pushq $0x5
popq %r9
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %rdx
movl %ecx, %r8d
callq 0x14a58
movl %ebp, (%rsp)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
movq %r15, %r8
movq %r15, %r9
callq 0x14d64
jmp 0x1918f
leaq 0x8ed8(%rip), %rdi      # 0x2204b
xorl %eax, %eax
callq 0x6b2c
jmp 0x1918d
leaq 0x8ef3(%rip), %rdi      # 0x22076
movl %r15d, %esi
xorl %eax, %eax
callq 0x6b2c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_elf32i386.c
// Function: aros_targetlink
static int aros_targetlink(struct GlobalVars *gv,struct LinkedSection *ls,
                           struct Section *s)
/* returns 1, if target requires the combination of the two sections, */
/* returns -1, if target doesn't want to combine them, */
/* returns 0, if target doesn't care - standard linking rules are used. */
{
  if (!gv->dest_object && !gv->use_ldscript) {
    if ((!strncmp(ls->name,sdata_name,6) && !strncmp(s->name,sbss_name,5)
         && *(ls->name+6) == *(s->name+5)) ||
        (!strncmp(ls->name,sbss_name,5) && !strncmp(s->name,sdata_name,6)
         && *(ls->name+5) == *(s->name+6)))
      /* .sdata/.sbss, .sdata2/.sbss2, etc. are always combined */
      return (1);
  }
  return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x54(%rdi)
jne 0x19270
cmpl $0x0, 0x244(%rdi)
jne 0x19270
movq %rdx, %r15
movq 0x18(%rsi), %r14
leaq 0x73b2(%rip), %rsi      # 0x205b1
pushq $0x6
popq %rdx
movq %r14, %rdi
callq 0x5070
pushq $0x1
popq %rbx
testl %eax, %eax
jne 0x19236
movq 0x20(%r15), %r12
leaq 0x739c(%rip), %rsi      # 0x205b8
pushq $0x5
popq %rdx
movq %r12, %rdi
callq 0x5070
testl %eax, %eax
jne 0x19236
movb 0x6(%r14), %al
cmpb 0x5(%r12), %al
je 0x19272
leaq 0x737b(%rip), %rsi      # 0x205b8
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0x5070
testl %eax, %eax
jne 0x19270
movq 0x20(%r15), %r15
leaq 0x735a(%rip), %rsi      # 0x205b1
pushq $0x6
popq %rdx
movq %r15, %rdi
callq 0x5070
testl %eax, %eax
jne 0x19270
movb 0x5(%r14), %al
cmpb 0x6(%r15), %al
je 0x19272
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_elf32i386.c
// Function: aros_lnksym
static struct Symbol *aros_lnksym(struct GlobalVars *gv,struct Section *sec,
                                  struct Reloc *xref)
{
  struct Symbol *sym;

  if (!gv->dest_object && !gv->use_ldscript) {
    if (!strcmp(linkerdb,xref->xrefname)) {  /* _LinkerDB */
      sym = addlnksymbol(gv,linkerdb,(lword)fff[gv->dest_format]->baseoff,
                         SYM_RELOC,SYMF_LNKSYM,SYMI_OBJECT,SYMB_GLOBAL,0);
      sym->extra = SYMX_SPECIAL|LINKERDB;
      if (findlnksymbol(gv,sdabase_name) == NULL) {
        /* Reference to _LinkerDB creates _SDA_BASE_ */
        struct Symbol *sdabase = addlnksymbol(gv,sdabase_name,
                                              (lword)fff[gv->dest_format]->baseoff,
                                              SYM_ABS,SYMF_LNKSYM,
                                              SYMI_OBJECT,SYMB_GLOBAL,0);
        sdabase->type = SYM_RELOC;
        sdabase->extra = SDABASE;
      }
      return (sym);  /* new linker symbol created */
    }
  }

  return (elf32_lnksym(gv,sec,xref));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x0, 0x54(%rdi)
jne 0x192b1
cmpl $0x0, 0x244(%rbx)
jne 0x192b1
movq 0x10(%r14), %rsi
leaq 0x16f00(%rip), %rdi     # 0x301a8
callq 0x5160
testl %eax, %eax
je 0x192c4
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x14617
movzbl 0x50(%rbx), %eax
leaq 0x15ec1(%rip), %r15     # 0x2f190
movq (%r15,%rax,8), %rax
movslq 0x9c(%rax), %rdx
leaq 0x16ec7(%rip), %rsi     # 0x301a8
pushq $0x2
popq %rcx
pushq $0x1
popq %r8
movq %rbx, %rdi
movl %r8d, %r9d
pushq $0x0
pushq $0x2
callq 0xa880
popq %rcx
popq %rdx
movq %rax, %r14
movl $0x80000000, 0x48(%rax) # imm = 0x80000000
leaq 0x72db(%rip), %rsi      # 0x205e5
movq %rbx, %rdi
callq 0xa922
testq %rax, %rax
jne 0x1934e
movzbl 0x50(%rbx), %eax
movq (%r15,%rax,8), %rax
movslq 0x9c(%rax), %rdx
leaq 0x72b8(%rip), %rsi      # 0x205e5
pushq $0x1
popq %rcx
movq %rbx, %rdi
movl %ecx, %r8d
movl %ecx, %r9d
pushq $0x0
pushq $0x2
callq 0xa880
addq $0x10, %rsp
movb $0x2, 0x40(%rax)
andl $0x0, 0x48(%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_elf32i386.c
// Function: aros_setlnksym
static void aros_setlnksym(struct GlobalVars *gv,struct Symbol *xdef)
{
  if ((xdef->flags & SYMF_LNKSYM) && (xdef->extra & SYMX_SPECIAL)) {
    struct LinkedSection *ls;

    switch (xdef->extra & ~SYMX_SPECIAL) {
      case LINKERDB:
        ls = smalldata_section(gv);
        xdef->relsect = (struct Section *)ls->sections.first;
        break;
    }
    xdef->flags &= ~SYMF_LNKSYM;  /* do not init again */
  }
  else
    elf32_setlnksym(gv,xdef);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movb 0x41(%rsi), %al
testb $0x1, %al
je 0x19369
movl 0x48(%rbx), %ecx
testl %ecx, %ecx
js 0x19372
movq %rbx, %rsi
popq %rbx
jmp 0x14720
testl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
jne 0x1938a
callq 0xc25a
movq 0x60(%rax), %rax
movq %rax, 0x38(%rbx)
movb 0x41(%rbx), %al
andb $-0x2, %al
movb %al, 0x41(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_elf32i386.c
// Function: aros_writeexec
static void aros_writeexec(struct GlobalVars *gv,FILE *f)
/* creates a target-elfaros executable file, which in reality */
/* is a relocatable object too, but all symbol references have */
/* been resolved */
{
  struct LinkedSection *ls;

  for (ls=(struct LinkedSection *)gv->lnksec.first; ls->n.next!=NULL;
       ls=(struct LinkedSection *)ls->n.next) {
    /* set filesize to memsize for all sections */
    if (!(ls->flags & SF_UNINITIALIZED))
      ls->filesize = ls->size;
  }

  elf32_writeobject(gv,f,EM_386,_LITTLE_ENDIAN_,i386_reloc_vlink2elf);
}

// Assembly:
movq 0x1c0(%rdi), %rax
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
je 0x193d2
testb $0x2, 0x21(%rcx)
jne 0x193b7
movq 0x48(%rcx), %rdx
movq %rdx, 0x50(%rcx)
jmp 0x193b7
leaq 0x38(%rip), %r8         # 0x19411
pushq $0x3
popq %rdx
xorl %ecx, %ecx
jmp 0x172df
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_elf32arm.c
// Function: armle_readconv
static void armle_readconv(struct GlobalVars *gv,struct LinkFile *lf)
/* Read ELF-ARM little-endian executable / object / shared obj. */
{
  if (lf->type == ID_LIBARCH) {
    struct ar_info ai;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x8, 0x39(%rsi)
jne 0x19525
movq 0x18(%rbx), %rcx
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq %rsp, %rdi
callq 0xc6e0
testl %eax, %eax
je 0x19554
movq %rsp, %r12
leaq 0x15cd4(%rip), %r15     # 0x2f190
pushq $0x1
popq %rbp
leaq 0xee(%rip), %r13        # 0x195b4
movq %r12, %rdi
callq 0xc745
testl %eax, %eax
je 0x19566
leaq 0x20(%rsp), %rdi
callq 0x63a1
movq %rax, 0x20(%rbx)
movzbl 0x38(%rbx), %eax
movq (%r15,%rax,8), %rdi
movq 0x10(%rbx), %rsi
movq 0x128(%rsp), %rdx
movl %ebp, %ecx
movl %ebp, %r8d
movl %ebp, %r9d
xorl %eax, %eax
pushq $0x28
pushq $0x1
callq 0x12dec
popq %rax
popq %rcx
movq 0x128(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rcx
callq 0x137fb
jmp 0x194c6
movq 0x18(%rbx), %rax
movq 0x28(%rbx), %rdx
movq %rax, 0x20(%rbx)
leaq 0x7c(%rip), %rcx        # 0x195b4
movq %r14, %rdi
movq %rbx, %rsi
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x137fb
movq 0x10(%rbx), %rsi
leaq 0x8bdd(%rip), %rdi      # 0x2213c
xorl %eax, %eax
callq 0x6b2c
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_aout.c
// Function: aout_identify
int aout_identify(struct FFFuncs *ff,char *name,struct aout_hdr *p,
                  unsigned long plen)
/* check a possible a.out file against the requirements, then */
/* return its type (object, library, shared object) */
{
  uint32_t mid = ff->id;
  bool arflag = FALSE;

  if (plen < ff->headersize(0))  /* @@@ gv-ptr is not needed for a.out ! */
    return (ID_UNKNOWN);

  if (ar_init(&ai,(char *)p,plen,name)) {
    /* library archive detected, extract 1st archive member */
    arflag = TRUE;
    if (!(ar_extract(&ai))) {
      error(38,name);  /* Empty archive ignored */
      return (ID_IGNORE);
    }
    p = (struct aout_hdr *)ai.data;
  }

  if (GETMID(p) == mid) {
    uint32_t mag = GETMAGIC(p);
    int fl = GETFLAGS(p) & EX_DPMASK;

    if (mag==OMAGIC || mag==NMAGIC || mag==ZMAGIC || mag==QMAGIC) {
      /* valid a.out format for this machine detected! */
      switch (mag) {
        case OMAGIC:
          return (arflag ? ID_LIBARCH : ID_OBJECT);
        case NMAGIC:
        case ZMAGIC:
          if (arflag) {
            if (fl == EX_DYNAMIC|EX_PIC)
              error(39,name,ff->tname); /* no shared objects in lib archives */
            else
              error(40,name,ff->tname); /* no executables in lib archives */
          }
          if (fl == EX_DYNAMIC|EX_PIC)
            return (ID_SHAREDOBJ);
          return (ID_EXECUTABLE);
        case QMAGIC:
          error(84,name); /* QMAGIC is deprecated */
          break;
      }
    }
  }
  return (ID_UNKNOWN);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl 0xa4(%rdi), %ebp
xorl %ebx, %ebx
xorl %edi, %edi
callq *0x18(%r15)
cmpq %r13, %rax
ja 0x19a1b
leaq 0x1a45b(%rip), %rdi     # 0x33db8
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0xc6e0
movl %eax, %r13d
testl %eax, %eax
je 0x19989
leaq 0x1a43f(%rip), %rdi     # 0x33db8
callq 0xc745
testl %eax, %eax
je 0x199e1
movq 0x1a557(%rip), %r12     # 0x33ee0
movq %r12, %rdi
callq 0x6607
shrl $0x10, %eax
andl $0x3ff, %eax            # imm = 0x3FF
cmpl %ebp, %eax
jne 0x19a1b
movl %r13d, %ebp
movq %r12, %rdi
callq 0x6607
movl %eax, %r13d
movq %r12, %rdi
callq 0x6607
cmpw $0xcc, %r13w
je 0x19a0c
movzwl %r13w, %eax
cmpl $0x10b, %eax            # imm = 0x10B
je 0x199f3
cmpl $0x108, %eax            # imm = 0x108
je 0x199f3
cmpl $0x107, %eax            # imm = 0x107
jne 0x19a1b
testl %ebp, %ebp
pushq $0x1
popq %rax
pushq $0x8
popq %rbx
cmovel %eax, %ebx
jmp 0x19a1b
pushq $0x26
popq %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x6c19
pushq $-0x1
popq %rbx
jmp 0x19a1b
pushq $0x4
popq %rbx
testl %ebp, %ebp
je 0x19a1b
movq (%r15), %rdx
pushq $0x27
popq %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x6c19
jmp 0x19a1b
xorl %ebx, %ebx
pushq $0x54
popq %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x6c19
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_aout.c
// Function: aout_lnksym
struct Symbol *aout_lnksym(struct GlobalVars *gv,struct Section *sec,
                           struct Reloc *xref)
/* Check for common a.out linker symbols. */
{
  struct Symbol *sym;
  int i;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x0, 0x54(%rdi)
je 0x19a61
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
movq 0x10(%rdx), %r12
leaq 0x15351(%rip), %rbp     # 0x2edc0
xorl %r14d, %r14d
xorl %r13d, %r13d
cmpq $0x3, %r13
je 0x19a4f
movq (%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x5160
testl %eax, %eax
je 0x19a97
incq %r13
addq $0x8, %rbp
jmp 0x19a75
andl $0x0, 0x8(%rsp)
movl $0x2, (%rsp)
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %ecx, %r8d
movl %ecx, %r9d
callq 0xa880
movq %rax, %r14
movl %r13d, 0x48(%rax)
cmpq $0x2, %r13
jae 0x19a4f
movq %r15, 0x230(%rbx)
movb $0x2, 0x40(%r14)
jmp 0x19a4f
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_aout.c
// Function: aoutstd_readconv
void aoutstd_readconv(struct GlobalVars *gv,struct LinkFile *lf)
/* Read a.out executable / object / shared obj. with standard relocs */
{
  if (lf->type == ID_LIBARCH) {
    if (ar_init(&ai,(char *)lf->data,lf->length,lf->filename)) {
      while (ar_extract(&ai)) {
        lf->objname = allocstring(ai.name);
        aoutstd_read(gv,lf,(struct aout_hdr *)ai.data);
      }
    }
    else
      ierror("aoutstd_readconv(): archive %s corrupted since last access",
             lf->pathname);
  }
  else {
    lf->objname = lf->filename;
    aoutstd_read(gv,lf,(struct aout_hdr *)lf->data);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x8, 0x39(%rsi)
jne 0x1ac8a
movq 0x18(%rbx), %rcx
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
leaq 0x19171(%rip), %rdi     # 0x33db8
callq 0xc6e0
testl %eax, %eax
je 0x1acb8
leaq 0x19161(%rip), %r15     # 0x33db8
leaq 0x1917a(%rip), %r12     # 0x33dd8
movq %r15, %rdi
callq 0xc745
testl %eax, %eax
je 0x1acac
movq %r12, %rdi
callq 0x63a1
movq %rax, 0x20(%rbx)
movq 0x19263(%rip), %rdx     # 0x33ee0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a1a4
jmp 0x1ac5e
movq 0x18(%rbx), %rax
movq 0x28(%rbx), %rdx
movq %rax, 0x20(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1a1a4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10(%rbx), %rsi
leaq 0x78fb(%rip), %rdi      # 0x225be
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6b2c
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_aout.c
// Function: aout_initwrite
void aout_initwrite(struct GlobalVars *gv,struct LinkedSection **sections)
{
  static const char *fn = "aout_initwrite(): ";
  struct LinkedSection *ls;

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

  get_text_data_bss(gv,sections);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x19206(%rip), %rdi     # 0x33ef0
callq 0x63c8
movl $0x80000, %edi          # imm = 0x80000
callq 0x638a
movq %rax, 0x19208(%rip)     # 0x33f08
movl $0x4, 0x19206(%rip)     # 0x33f10
leaq 0x19207(%rip), %rdi     # 0x33f18
callq 0x63c8
movl $0x80000, %edi          # imm = 0x80000
callq 0x638a
movq %rax, 0x19209(%rip)     # 0x33f30
andl $0x0, 0x1920a(%rip)     # 0x33f38
leaq 0x1920b(%rip), %rdi     # 0x33f40
callq 0x63c8
leaq 0x19217(%rip), %rdi     # 0x33f58
callq 0x63c8
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc2c0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_aout.c
// Function: aout_debugsyms
void aout_debugsyms(struct GlobalVars *gv,bool be)
/* add debug stab-entries to symbol table, sorted by ObjectUnits */
{
  struct ObjectUnit *obj;
  struct StabDebug *stab;

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

// Assembly:
cmpb $0x0, 0x6c(%rdi)
je 0x1afdf
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
addq $0x138, %r14            # imm = 0x138
movq (%r14), %r14
cmpq $0x0, (%r14)
je 0x1b036
leaq 0x50(%r14), %r15
movq (%r15), %r15
cmpq $0x0, (%r15)
je 0x1aff4
movq 0x18(%r15), %rdi
movl 0x24(%r15), %esi
movzbl 0x21(%r15), %edx
movl %edx, %eax
shrb $0x4, %al
movzbl 0x20(%r15), %r8d
movswl 0x22(%r15), %r9d
movl %ebx, (%rsp)
andl $0xf, %edx
movzbl %al, %ecx
callq 0x1b040
jmp 0x1b001
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_aout.c
// Function: aout_addsym
static uint32_t aout_addsym(const char *name,uint32_t value,uint8_t bind,
                           uint8_t info,uint8_t type,int16_t desc,int be)
/* add a new symbol, return its symbol table index */
{
  struct SymbolNode **chain;
  struct SymbolNode *sym;

  if (name == NULL)
    name = noname;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r13d
movq %rdi, %rbp
testq %rdi, %rdi
jne 0x1b070
leaq 0x55e0(%rip), %rbp      # 0x20650
movq 0x18eb9(%rip), %rbx     # 0x33f30
movq %rbp, %rdi
callq 0x69ee
movzwl %ax, %eax
leaq (%rbx,%rax,8), %rax
movq %rax, %r12
movq (%rax), %rcx
leaq 0x10(%rcx), %rax
testq %rcx, %rcx
jne 0x1b086
pushq $0x30
popq %rdi
callq 0x638a
movq %rax, %rbx
movq %rax, (%r12)
movq %rbp, 0x18(%rax)
movl 0x18e8a(%rip), %eax     # 0x33f38
leal 0x1(%rax), %ecx
movl %ecx, 0x18e81(%rip)     # 0x33f38
movl %eax, 0x2c(%rbx)
movq 0x18e47(%rip), %r12     # 0x33f08
movq %rbp, %rdi
callq 0x69ee
cmpb $0x0, (%rbp)
je 0x1b0fe
movl %r13d, 0xc(%rsp)
movzwl %ax, %eax
leaq (%r12,%rax,8), %r13
movq (%r13), %r12
testq %r12, %r12
je 0x1b102
movq 0x18(%r12), %rsi
movq %rbp, %rdi
callq 0x5160
testl %eax, %eax
je 0x1b14d
addq $0x10, %r12
movq %r12, %r13
jmp 0x1b0db
xorl %edx, %edx
jmp 0x1b15a
pushq $0x28
popq %rdi
callq 0x6340
movq %rax, (%r13)
andq $0x0, 0x10(%rax)
movq %rbp, 0x18(%rax)
leaq 0x18dd2(%rip), %rdi     # 0x33ef0
movl 0x18dec(%rip), %ecx     # 0x33f10
leaq 0x20(%rax), %r12
movl %ecx, 0x20(%rax)
movq %rax, %rsi
callq 0x6414
movq %rbp, %rdi
callq 0x50e0
movl 0x18dcf(%rip), %ecx     # 0x33f10
addl %ecx, %eax
incl %eax
movl %eax, 0x18dc5(%rip)     # 0x33f10
jmp 0x1b151
addq $0x20, %r12
movl (%r12), %edx
movl 0xc(%rsp), %r13d
leaq 0x20(%rbx), %rsi
movl 0x50(%rsp), %ebp
movl %ebp, %edi
callq 0x6681
movl 0x10(%rsp), %eax
movb %al, 0x24(%rbx)
shlb $0x4, %r15b
andb $0xf, %r14b
orb %r15b, %r14b
movb %r14b, 0x25(%rbx)
leaq 0x26(%rbx), %rsi
movzwl 0x14(%rsp), %edx
movl %ebp, %edi
callq 0x666c
movq %rbx, %rsi
addq $0x28, %rsi
movl %ebp, %edi
movl %r13d, %edx
callq 0x6681
leaq 0x18d71(%rip), %rdi     # 0x33f18
movq %rbx, %rsi
callq 0x6414
movl 0x2c(%rbx), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_aout.c
// Function: detect_movei_relocs
static void detect_movei_relocs(struct Reloc *first)
/* Search for possible MOVEI RISC relocations and flag them by the
   internal type R_AOUT_MOVEI. */
{
  struct Reloc *r;
  struct RelocInsert *ri;

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

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

// Assembly:
movl $0xffff0000, %eax       # imm = 0xFFFF0000
movq %rdi, %rcx
movq %rcx, %rdx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x1b4c4
cmpb $0x1, 0x38(%rdx)
jne 0x1b432
movq 0x30(%rdx), %rsi
testq %rsi, %rsi
je 0x1b432
cmpw $0x0, 0x8(%rsi)
jne 0x1b432
cmpq $0x0, (%rsi)
jne 0x1b432
cmpw $0x10, 0xa(%rsi)
jne 0x1b432
cmpq %rax, 0x10(%rsi)
jne 0x1b432
movq 0x20(%rdx), %rsi
addq $-0x2, %rsi
movq %rdi, %r9
movq %r9, %r8
movq (%r9), %r9
testq %r9, %r9
je 0x1b432
cmpq %rsi, 0x20(%r8)
jne 0x1b475
cmpb $0x1, 0x38(%r8)
jne 0x1b475
movq 0x30(%r8), %r10
testq %r10, %r10
je 0x1b475
cmpw $0x0, 0x8(%r10)
jne 0x1b475
cmpq $0x0, (%r10)
jne 0x1b475
cmpw $0x10, 0xa(%r10)
jne 0x1b475
cmpq $0xffff, 0x10(%r10)     # imm = 0xFFFF
jne 0x1b475
movb $0x11, 0x38(%r8)
movb $0x0, 0x38(%rdx)
jmp 0x1b432
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_aout.c
// Function: aout_addreloclist
static void aout_addreloclist(struct list *rlst,int32_t raddr,uint32_t rindex,
                              uint32_t rinfo,int be)
/* add new relocation_info to .text or .data reloc-list */
{
  struct RelocNode *rn = alloc(sizeof(struct RelocNode));

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r14d
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, (%rsp)
pushq $0x18
popq %rdi
callq 0x6340
movq %rax, %r13
leaq 0x10(%rax), %rsi
movl %r14d, %edi
movl %r12d, %edx
callq 0x6681
leaq 0x14(%r13), %r12
pushq $0x18
popq %rbx
movl %r14d, %edi
movq %r12, %rsi
xorl %edx, %edx
movl %ebx, %ecx
movl %r15d, %r8d
callq 0x6792
pushq $0x8
popq %rcx
movl %r14d, %edi
movq %r12, %rsi
movl %ebx, %edx
movl %ebp, %r8d
callq 0x6792
movq (%rsp), %rdi
movq %r13, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6414
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_aout.c
// Function: aout_header
void aout_header(FILE *f,uint32_t mag,uint32_t mid,uint32_t flag,
                 uint32_t tsize,uint32_t dsize,uint32_t bsize,uint32_t syms,
                 uint32_t entry,uint32_t trsize,uint32_t drsize,int be)
/* write an a.out header */
{
  struct aout_hdr h;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %r15d
movl %r8d, %ebp
movq %rdi, %rbx
movl 0x60(%rsp), %r13d
movl 0x88(%rsp), %r14d
shll $0x1a, %ecx
shll $0x10, %edx
andl $0x3ff0000, %edx        # imm = 0x3FF0000
leal (%rdx,%rcx), %eax
movzwl %si, %esi
orl %eax, %esi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x661b
leaq 0xc(%rsp), %rsi
movl %r14d, %edi
movl %ebp, %edx
callq 0x6681
leaq 0x10(%rsp), %rsi
movl %r14d, %edi
movl %r15d, %edx
callq 0x6681
leaq 0x14(%rsp), %rsi
movl %r14d, %edi
movl %r13d, %edx
callq 0x6681
leaq 0x18(%rsp), %rsi
movl %r14d, %edi
movl 0x68(%rsp), %edx
callq 0x6681
leaq 0x1c(%rsp), %rsi
movl %r14d, %edi
movl 0x70(%rsp), %edx
callq 0x6681
leaq 0x20(%rsp), %rsi
movl %r14d, %edi
movl 0x78(%rsp), %edx
callq 0x6681
leaq 0x24(%rsp), %rsi
movl %r14d, %edi
movl 0x80(%rsp), %edx
callq 0x6681
pushq $0x20
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6817
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_aout.c
// Function: aout_getpagedsize
uint32_t aout_getpagedsize(struct GlobalVars *gv,struct LinkedSection **ls,
                         int sec)
/* return size of section aligned to page boundaries */
{
  unsigned long pagealign = shiftcnt(fff[gv->dest_format]->page_size);

  if (sec == 0) {  /* .text */
    if (ls[1]) {  /* followed by .data */
      check_overlap(gv,ls[0],ls[1]);
      return ((ls[1]->base - ls[0]->base) + sizeof(struct aout_hdr));
    }
    else { /* align section size to page boundary */
      check_overlap(gv,ls[0],ls[2]);
      return (ls[0]->size + sizeof(struct aout_hdr) +
              align(ls[0]->base+ls[0]->size,pagealign));
    }
  }
  else if (sec == 1) {  /* .data */
    if (ls[1]) {
      check_overlap(gv,ls[1],ls[2]);
      return (ls[1]->size + align(ls[1]->base+ls[1]->size,pagealign));
    }
  }
  else if (ls[2]) {  /* .bss */
    /* parts of .bss might disappear in the last .text or .data page */
    unsigned long bytes_in_last_page = align(ls[2]->base,pagealign);

    if (bytes_in_last_page < ls[2]->size)
      return (ls[2]->size - bytes_in_last_page);
  }

  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movzbl 0x50(%rdi), %eax
leaq 0x13b5f(%rip), %rcx     # 0x2f190
movq (%rcx,%rax,8), %rax
movl 0x98(%rax), %edi
callq 0x6a50
movslq %eax, %r14
cmpl $0x1, %ebp
je 0x1b675
testl %ebp, %ebp
jne 0x1b6a5
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
je 0x1b6cf
movq %r15, %rdi
callq 0x1b703
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movl 0x40(%rcx), %ebx
subl 0x40(%rax), %ebx
addl $0x20, %ebx
jmp 0x1b6f6
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1b6cb
movq 0x10(%rbx), %rdx
movq %r15, %rdi
callq 0x1b703
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rbx
movq 0x40(%rax), %rdi
addq %rbx, %rdi
movq %r14, %rsi
callq 0x6a1e
addl %eax, %ebx
jmp 0x1b6f6
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x1b6cb
movq 0x40(%rax), %rdi
movq %r14, %rsi
callq 0x6a1e
movq 0x10(%rbx), %rcx
movq 0x48(%rcx), %rbx
cmpq %rax, %rbx
jbe 0x1b6cb
subl %eax, %ebx
jmp 0x1b6f6
xorl %ebx, %ebx
jmp 0x1b6f6
movq 0x10(%rbx), %rdx
movq %r15, %rdi
callq 0x1b703
movq (%rbx), %rax
movq 0x48(%rax), %rbx
movq %rbx, %rdi
addq 0x40(%rax), %rdi
movq %r14, %rsi
callq 0x6a1e
addl %eax, %ebx
addl $0x20, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_aout.c
// Function: aout_pagedsection
void aout_pagedsection(struct GlobalVars *gv,FILE *f,
                       struct LinkedSection **ls,int sec)
/* write .text and .data section aligned to page boundaries */
{
  if (ls[sec]) {
    fwritex(f,ls[sec]->data,ls[sec]->size);
    fwritegap(f,aout_getpagedsize(gv,ls,sec) -
              (sec ? ls[sec]->size : ls[sec]->size+sizeof(struct aout_hdr)));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movslq %ecx, %r14
movq (%rdx,%r14,8), %rax
testq %rax, %rax
je 0x1b7b2
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq 0x48(%rax), %rdx
movq 0x78(%rax), %rsi
movq %rbx, %rdi
callq 0x6817
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x1b617
movq (%r15,%r14,8), %rcx
movq 0x48(%rcx), %rcx
leaq 0x20(%rcx), %rdx
testl %r14d, %r14d
cmovneq %rcx, %rdx
movl %eax, %esi
subq %rdx, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x698d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_aout.c
// Function: aout_writestrings
void aout_writestrings(FILE *f,int be)
{
  if (aoutstrlist.nextoffset > 4) {
    struct StrTabNode *stn;
    uint32_t len;

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

// Assembly:
movl 0x186a9(%rip), %edx     # 0x33f10
cmpl $0x5, %edx
jb 0x1b8cf
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movl %esi, %edi
movq %r14, %rsi
callq 0x6681
pushq $0x4
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6817
leaq 0x18654(%rip), %r14     # 0x33ef0
movq %r14, %rdi
callq 0x642a
testq %rax, %rax
je 0x1b8c6
movq 0x18(%rax), %r15
movq %r15, %rdi
callq 0x50e0
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6817
jmp 0x1b89c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_aout.c
// Function: isPIC
static bool isPIC(struct LinkedSection **secs)
/* check if all sections contain position independant code (PIC) */
{
  int i;

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

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

// Assembly:
xorl %ecx, %ecx
pushq $0x1
popq %rax
cmpq $0x3, %rcx
je 0x1bc87
movq (%rdi,%rcx,8), %rdx
testq %rdx, %rdx
je 0x1bc80
movq 0x80(%rdx), %rsi
movq (%rsi), %r8
testq %r8, %r8
je 0x1bc66
cmpb $0x1, 0x38(%rsi)
movq %r8, %rsi
jne 0x1bc53
jmp 0x1bc85
movq 0x98(%rdx), %rdx
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x1bc80
cmpb $0x1, 0x38(%rdx)
movq %rsi, %rdx
jne 0x1bc6d
jmp 0x1bc85
incq %rcx
jmp 0x1bc3d
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_aout.c
// Function: aout_create_section
static void aout_create_section(struct ObjectUnit *ou,struct FFFuncs *ff,
                                const char *sec_name,uint8_t *data,
                                unsigned long size,uint8_t type)
{
  struct LinkFile *lf = ou->lnkfile;
  uint8_t flags=0,protection;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movb $0x3, %al
movb $0x3, %cl
cmpl $0x3, %r8d
je 0x1bee6
movq 0x10(%r12), %rax
leaq (%r14,%rbx), %rcx
movq 0x28(%rax), %rdx
addq 0x30(%rax), %rdx
cmpq %rdx, %rcx
jbe 0x1bed8
movq 0x10(%rax), %rsi
movq 0x20(%rax), %rcx
pushq $0x31
popq %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6c19
cmpb $0x1, %bpl
sete %cl
addb %cl, %cl
addb $0x3, %cl
movb $0x1, %al
subq $0x8, %rsp
movzbl %cl, %r10d
movzbl %bpl, %r8d
movzbl %al, %r9d
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
pushq $0x0
pushq $0x2
pushq %r10
callq 0xbab3
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_aout.c
// Function: get_symname
static char *get_symname(struct LinkFile *lf,struct aout_hdr *hdr,int be,
                         int32_t offset)
{
  char *symname = ((char *)hdr) + aout_stroffset(hdr,be) + offset;

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

  return (symname);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rsi, %r12
movq %rdi, %r15
movq %rsi, %rdi
movl %edx, %esi
callq 0x1be42
movl %eax, %eax
movslq %ebx, %r14
addq %r12, %r14
addq %rax, %r14
movq 0x28(%r15), %rax
cmpq %rax, %r14
jb 0x1bfa4
addq 0x30(%r15), %rax
cmpq %rax, %r14
jbe 0x1bfb8
movq 0x10(%r15), %rsi
movq 0x20(%r15), %rcx
pushq $0x57
popq %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x6c19
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_ataritos.c
// Function: write_dri_sym
static void write_dri_sym(FILE *f,const char *name,
                          uint16_t type,uint32_t value)
{
  struct DRIsym stab;
  int longname = strlen(name) > DRI_NAMELEN;

  strncpy(stab.name,name,DRI_NAMELEN);
  write16be(stab.type,longname?(type|STYP_LONGNAME):type);
  write32be(stab.value,value);
  fwritex(f,&stab,sizeof(struct DRIsym));

  if (longname) {
    char rest_of_name[sizeof(struct DRIsym)];

    memset(rest_of_name,0,sizeof(struct DRIsym));
    strncpy(rest_of_name,name+DRI_NAMELEN,sizeof(struct DRIsym));
    fwritex(f,rest_of_name,sizeof(struct DRIsym));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x50e0
movq %rax, %r15
leaq 0xc(%rsp), %r13
pushq $0x8
popq %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x5060
movl %r12d, %esi
orl $0x48, %esi
cmpq $0x9, %r15
leaq 0x14(%rsp), %rdi
cmovbl %r12d, %esi
callq 0x6613
leaq 0x16(%rsp), %rdi
movl %ebp, %esi
callq 0x661b
pushq $0xe
popq %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6817
cmpq $0x9, %r15
jb 0x1c90b
addq $0x8, %r14
leaq 0x1a(%rsp), %r15
pushq $0xe
popq %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5060
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6817
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_rawbin.c
// Function: shex1_write
static void shex1_write(struct GlobalVars *gv,FILE *f)
{
  bool firstsec = TRUE;
  struct LinkedSection *ls;
  unsigned long len,addr;
  uint8_t *p;

  while (ls = get_next_section(gv)) {
    if (ls->size == 0 || !(ls->flags & SF_ALLOC) || (ls->ld_flags & LSF_NOLOAD))
      continue;  /* ignore empty sections */

    if (firstsec) {
      if (gv->trace_file)
        fprintf(gv->trace_file,"Base address = 0x%08lx.\n",ls->copybase);
      firstsec = FALSE;
    }

    /* resolve all relocations and write section contents */
    calc_relocs(gv,ls);

    for (p=ls->data,addr=ls->copybase,len=ls->filesize; len>0; ) {
      int nbytes = (len>32) ? 32 : len;

      SHex1Out(f,addr,p,nbytes);
      p += nbytes;
      addr += nbytes;
      len -= nbytes;
    }
  }
  fprintf(f,"000000 0\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x6b9c(%rip), %r14      # 0x23704
xorl %r15d, %r15d
movq %r12, %rdi
callq 0x1ce4b
testq %rax, %rax
je 0x1cc9d
movq %rax, %rbp
cmpq $0x0, 0x48(%rax)
je 0x1cb6b
testb $0x1, 0x21(%rbp)
je 0x1cb6b
testb $0x1, 0x24(%rbp)
jne 0x1cb6b
testb $0x1, %r15b
jne 0x1cbb7
movq 0xa0(%r12), %rdi
testq %rdi, %rdi
je 0x1cbb7
movq 0x38(%rbp), %rdx
leaq 0x6b30(%rip), %rsi      # 0x236e0
xorl %eax, %eax
callq 0x5180
movq %r12, (%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0xb170
movq 0x78(%rbp), %r12
movq 0x38(%rbp), %rdx
movq 0x50(%rbp), %rax
testq %rax, %rax
je 0x1cc91
cmpq $0x20, %rax
pushq $0x20
popq %rbp
movq %rax, 0x8(%rsp)
cmovbq %rax, %rbp
leal 0x3(%rbp), %r13d
movl %r13d, %ecx
shrl $0x2, %ecx
movq %rbx, %rdi
leaq 0x6b48(%rip), %rsi      # 0x23747
movq %rdx, 0x10(%rsp)
xorl %eax, %eax
callq 0x5180
xorl %r15d, %r15d
cmpq %r15, %rbp
je 0x1cc3b
testb $0x3, %r15b
jne 0x1cc24
pushq $0x20
popq %rdi
movq %rbx, %rsi
callq 0x5150
movzbl (%r12,%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x5180
incq %r15
jmp 0x1cc0e
andl $0x7c, %r13d
subl %ebp, %r13d
testl %r13d, %r13d
movl $0x0, %eax
cmovlel %eax, %r13d
leaq 0x6ae5(%rip), %r15      # 0x2373a
subl $0x1, %r13d
jb 0x1cc6e
movq %r15, %rdi
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x5280
jmp 0x1cc55
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x5150
addq %rbp, %r12
movq 0x10(%rsp), %rdx
addq %rbp, %rdx
movq 0x8(%rsp), %rax
subq %rbp, %rax
jmp 0x1cbd2
movb $0x1, %r15b
movq (%rsp), %r12
jmp 0x1cb6b
leaq 0x6a99(%rip), %rdi      # 0x2373d
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5280
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_rawbin.c
// Function: get_next_section
static struct LinkedSection *get_next_section(struct GlobalVars *gv)
/* returns pointer to next section with lowest base address */
{
  struct LinkedSection *ls = (struct LinkedSection *)gv->lnksec.first;
  struct LinkedSection *nextls,*minls = NULL;

  while (nextls = (struct LinkedSection *)ls->n.next) {
    if (minls) {
      if (ls->copybase < minls->copybase)
        minls = ls;
    }
    else
      minls = ls;
    ls = nextls;
  }
  if (minls) {
    remnode(&minls->n);
  }
  return (minls);
}

// Assembly:
pushq %rbx
movq 0x1c0(%rdi), %rax
xorl %ecx, %ecx
movq %rcx, %rbx
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
je 0x1ce76
testq %rbx, %rbx
je 0x1ce55
movq 0x38(%rcx), %rdx
cmpq 0x38(%rbx), %rdx
cmovaeq %rbx, %rcx
jmp 0x1ce55
testq %rbx, %rbx
je 0x1ce83
movq %rbx, %rdi
callq 0x6444
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_rawbin.c
// Function: SRecOut
static void SRecOut(FILE *f,int stype,uint8_t *buf,int len)
{
  uint8_t chksum = 0xff-len-1;

  fprintf(f,"S%1d%02X",stype,(unsigned)(len+1));
  for (; len>0; len--) {
    fprintf(f,"%02X",(unsigned)*buf);
    chksum -= *buf++;
  }
  fprintf(f,"%02X\n",(unsigned)chksum);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %edx
movq %rdi, %rbx
movb $-0x2, %bpl
subb %r14b, %bpl
leal 0x1(%r14), %ecx
leaq 0x6697(%rip), %rsi      # 0x23700
xorl %eax, %eax
callq 0x5180
leaq 0x668d(%rip), %r12      # 0x23704
testl %r14d, %r14d
jle 0x1d098
movzbl (%r15), %edx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x5180
subb (%r15), %bpl
incq %r15
decl %r14d
jmp 0x1d077
movzbl %bpl, %edx
leaq 0x6684(%rip), %rsi      # 0x23727
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5180
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_vobj.c
// Function: vobj_readconv
static void vobj_readconv(struct GlobalVars *gv,struct LinkFile *lf)
{
  if (lf->type == ID_LIBARCH) {
    if (ar_init(&ai,(char *)lf->data,lf->length,lf->filename)) {
      while (ar_extract(&ai)) {
        lf->objname = allocstring(ai.name);
        vobj_read(gv,lf,(uint8_t *)ai.data);
      }
    }
    else
      ierror("vobj_readconv(): archive %s corrupted since last access",
             lf->pathname);
  }
  else {
    lf->objname = lf->filename;
    vobj_read(gv,lf,lf->data);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x8, 0x39(%rsi)
jne 0x1d12d
movq 0x18(%rbx), %rcx
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
leaq 0x16e8e(%rip), %rdi     # 0x33f78
callq 0xc6e0
testl %eax, %eax
je 0x1d15b
leaq 0x16e7e(%rip), %r15     # 0x33f78
leaq 0x16e97(%rip), %r12     # 0x33f98
movq %r15, %rdi
callq 0xc745
testl %eax, %eax
je 0x1d14f
movq %r12, %rdi
callq 0x63a1
movq %rax, 0x20(%rbx)
movq 0x16f80(%rip), %rdx     # 0x340a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d241
jmp 0x1d101
movq 0x18(%rbx), %rax
movq 0x28(%rbx), %rdx
movq %rax, 0x20(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1d241
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10(%rbx), %rsi
leaq 0x669e(%rip), %rdi      # 0x23804
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6b2c
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_vobj.c
// Function: vobj_identify
static int vobj_identify(char *name,uint8_t *p,unsigned long plen,uint8_t e)
{
  int id = ID_OBJECT;

  if (ar_init(&ai,(char *)p,plen,name)) {
    /* library archive detected, extract 1st archive member */
    id = ID_LIBARCH;
    if (!(ar_extract(&ai))) {
      error(38,name);  /* empty archive ignored */
      return ID_IGNORE;
    }
    p = (uint8_t *)ai.data;
    plen = ai.size;
  }

  if (plen>4 && p[0]==0x56 && p[1]==0x4f && p[2]==0x42 &&
      p[3]==0x4a && p[4]==e) {
    return id;
  }

  return ID_UNKNOWN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x16db0(%rip), %rdi     # 0x33f78
movq %r15, %rcx
callq 0xc6e0
testl %eax, %eax
je 0x1d1f7
leaq 0x16d9d(%rip), %rdi     # 0x33f78
callq 0xc745
testl %eax, %eax
je 0x1d225
movq 0x16eb5(%rip), %r14     # 0x340a0
pushq $0x8
popq %rax
movq 0x16eb3(%rip), %r12     # 0x340a8
jmp 0x1d1fa
pushq $0x1
popq %rax
cmpq $0x5, %r12
jb 0x1d221
cmpb $0x56, (%r14)
jne 0x1d221
cmpb $0x4f, 0x1(%r14)
jne 0x1d221
cmpb $0x42, 0x2(%r14)
jne 0x1d221
cmpb $0x4a, 0x3(%r14)
jne 0x1d221
cmpb %bl, 0x4(%r14)
je 0x1d235
xorl %eax, %eax
jmp 0x1d235
pushq $0x26
popq %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x6c19
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/t_vobj.c
// Function: read_number
static taddr read_number(void)
{
  taddr val;
  uint8_t n,*q;
  int size;

  if ((n = *p++) <= 0x7f)
    return (taddr)n;

  val = 0;
  if (n -= 0x80) {
    size = n << 3;
    p += n;
    q = p;
    while (n--)
      val = (val<<8) | *(--q);
    val = sign_extend(val,size);
  }
  return val;
}

// Assembly:
movq 0x1664c(%rip), %rcx     # 0x340b0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x16641(%rip)     # 0x340b0
movsbq (%rcx), %rax
testq %rax, %rax
js 0x1da79
retq
andb $0x7f, %al
je 0x1daab
movzbl %al, %esi
addq %rsi, %rdx
movq %rdx, 0x16626(%rip)     # 0x340b0
xorl %edi, %edi
movq %rsi, %rax
testb %al, %al
je 0x1daa3
shlq $0x8, %rdi
movzbl (%rcx,%rax), %edx
orq %rdx, %rdi
decq %rax
jmp 0x1da8f
shll $0x3, %esi
jmp 0x6ad8
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/kilobyte[P]colormatch/xterm256.c
// Function: main
int main()
{
    for (int c = 0; c < 16777216; ++c)
    {
        nt[c] = closest(c);
        if (!(c&0xff))
            printf("%06X\n", c);
    }

    int fd = creat("xterm.rgb", 0666);
    write(fd, nt, sizeof(nt));
    close(fd);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0xff, %r15d
xorl %r14d, %r14d
cmpq $0x1000000, %r14        # imm = 0x1000000
je 0x123e
movl %r14d, %eax
shrl $0x10, %eax
movl %eax, 0xc(%rsp)
movl %r14d, %ebx
shrl $0x8, %ebx
andl %r15d, %ebx
movq %r14, 0x10(%rsp)
movl %r14d, %r12d
andl %r15d, %r12d
xorl %ebp, %ebp
movl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
cmpl $0x100, %ebp            # imm = 0x100
je 0x1210
movl %ebp, %edi
callq 0x127c
movl %eax, %ecx
shrl $0x10, %ecx
andl %r15d, %ecx
subl 0xc(%rsp), %ecx
imull %ecx, %ecx
movl %eax, %edx
shrl $0x8, %edx
andl %r15d, %edx
subl %ebx, %edx
imull %edx, %edx
andl %r15d, %eax
subl %r12d, %eax
imull %eax, %eax
addl %edx, %eax
addl %ecx, %eax
cmpl %r14d, %eax
cmovll %eax, %r14d
cmovll %ebp, %r13d
incl %ebp
jmp 0x11c9
leaq 0x2e49(%rip), %rax      # 0x4060
movq 0x10(%rsp), %r14
movb %r13b, (%r14,%rax)
testl %r12d, %r12d
jne 0x1236
leaq 0xdd8(%rip), %rdi       # 0x2004
movl %r14d, %esi
xorl %eax, %eax
callq 0x1050
incq %r14
jmp 0x1193
leaq 0xdc5(%rip), %rdi       # 0x200a
movl $0x1b6, %esi            # imm = 0x1B6
callq 0x1070
movl %eax, %ebx
leaq 0x2e08(%rip), %rsi      # 0x4060
movl $0x1000000, %edx        # imm = 0x1000000
movl %eax, %edi
callq 0x1040
movl %ebx, %edi
callq 0x1060
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/codeplea[P]tinyexpr/example3.c
// Function: main
int main(int argc, char *argv[])
{
    te_variable vars[] = {
        {"mysum", my_sum, TE_FUNCTION2}
    };

    const char *expression = "mysum(5, 6)";
    printf("Evaluating:\n\t%s\n", expression);

    int err;
    te_expr *n = te_compile(expression, vars, 1, &err);

    if (n) {
        const double r = te_eval(n);
        printf("Result:\n\t%f\n", r);
        te_free(n);
    } else {
        /* Show the user where the error is at. */
        printf("\t%*s^\nError near here", err-1, "");
    }


    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movaps 0x38b7(%rip), %xmm0     # 0x4aa0
leaq 0x10(%rsp), %rbx
movaps %xmm0, 0x10(%rbx)
movaps 0x3897(%rip), %xmm0     # 0x4a90
movaps %xmm0, (%rbx)
leaq 0x1e36(%rip), %rdi      # 0x3039
leaq 0x1e23(%rip), %r14      # 0x302d
movq %r14, %rsi
xorl %eax, %eax
callq 0x1070
pushq $0x1
popq %rdx
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1bde
testq %rax, %rax
je 0x124f
movq %rax, %rbx
movq %rax, %rdi
callq 0x15e5
leaq 0x1e0c(%rip), %rdi      # 0x304a
movb $0x1, %al
callq 0x1070
movq %rbx, %rdi
callq 0x12dc
jmp 0x126a
movl 0xc(%rsp), %esi
decl %esi
leaq 0x1dfb(%rip), %rdi      # 0x3057
leaq 0x1dc3(%rip), %rdx      # 0x3026
xorl %eax, %eax
callq 0x1070
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq