LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: sc_provide
static void sc_provide(struct GlobalVars *gv)
/* PROVIDE(symbol = expression); */
{
  if (startofblock('(')) {
    char *symname;

    if (symname = getword()) {
      if (getchr()=='=' && *symname!='\0') {
        symbol_assignment(gv,symname,SYMF_PROVIDED);
      }
      else {
        error(66,scriptname,getlineno(),'=');  /* '=' expected */
        back(1);
      }
    }
    else
      error(78,scriptname,getlineno());
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x28, %edi
callq 0xfa78
testl %eax, %eax
je 0xd6ad
movl $0x1, %edi
callq 0x100e6
testq %rax, %rax
je 0xd6e8
movq %rax, %r14
callq 0x1006f
cmpb $0x3d, %al
jne 0xd6b5
cmpb $0x0, (%r14)
je 0xd6b5
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe363
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x25f64(%rip), %rbx     # 0x33620
callq 0x10563
movl $0x42, %edi
movq %rbx, %rsi
movl %eax, %edx
movl $0x3d, %ecx
xorl %eax, %eax
callq 0x6f84
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x100d3
movq 0x25f31(%rip), %rbx     # 0x33620
callq 0x10563
movl $0x4e, %edi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6f84
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: sc_searchdir
static void sc_searchdir(struct GlobalVars *gv)
/* SEARCH_DIR(path) */
{
  if (startofblock('(')) {
    char *path;

    if (path = getfilename()) {
      struct LibPath *libp = alloc(sizeof(struct LibPath));

      libp->path = allocstring(path);
      addtail(&gv->libpaths,&libp->n);
    }
    else
      error(78,scriptname,getlineno());

    endofblock('(',')');
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x28, %edi
callq 0xfa78
testl %eax, %eax
je 0xd755
callq 0xfcb7
testq %rax, %rax
je 0xd75b
movq %rax, %r14
movl $0x18, %edi
callq 0x6668
movq %rax, %r15
movq %r14, %rdi
callq 0x66cd
movq %rax, 0x10(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6759
jmp 0xd778
popq %rbx
popq %r14
popq %r15
retq
movq 0x25ebe(%rip), %rbx     # 0x33620
callq 0x10563
movl $0x4e, %edi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6f84
movl $0x28, %edi
movl $0x29, %esi
popq %rbx
popq %r14
popq %r15
jmp 0xfb48
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: update_address
void update_address(struct MemoryDescr *rmd,struct MemoryDescr *dmd,
                    unsigned long addbytes)
{
  const char *secname = current_ls ? current_ls->name : defmemname;

  rmd->current += (lword)addbytes;
  if (rmd->current > rmd->org + rmd->len) {
    /* Fatal: Size of memory region exceeded! */
    error(63,rmd->name,secname,rmd->current);
  }
  if (dmd != rmd) {
    dmd->current += addbytes;
    if (dmd->current > dmd->org + dmd->len) {
      /* Fatal: Size of memory region exceeded! */
      error(63,dmd->name,secname,dmd->current);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x25e24(%rip), %rax     # 0x33608
testq %rax, %rax
je 0xd7ef
movq 0x18(%rax), %r15
jmp 0xd7f6
leaq 0x153dc(%rip), %r15     # 0x22bd2
movq 0x20(%r12), %rcx
addq %rbx, %rcx
movq %rcx, 0x20(%r12)
movq 0x18(%r12), %rax
addq 0x10(%r12), %rax
cmpq %rax, %rcx
jle 0xd826
movq 0x8(%r12), %rsi
movl $0x3f, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6f84
cmpq %r12, %r14
je 0xd861
addq 0x20(%r14), %rbx
movq %rbx, 0x20(%r14)
movq 0x18(%r14), %rax
addq 0x10(%r14), %rax
cmpq %rax, %rbx
jle 0xd861
movq 0x8(%r14), %rsi
movl $0x3f, %edi
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6f84
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: free_patterns
void free_patterns(char *fpat,char **spatlist)
/* free file-pattern and section-pattern list, allocated in next_pattern() */
{
  char **p;

  if (fpat)
    free(fpat);

  if (p = spatlist) {
    while (*p) {
      free(*p);
      p++;
    }
    free(spatlist);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0xd8a9
callq 0x5040
testq %rbx, %rbx
je 0xd8da
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xd8cb
leaq 0x8(%rbx), %r14
callq 0x5040
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0xd8ba
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5040
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: test_pattern
int test_pattern(struct GlobalVars *gv,char **fpat,char ***spatlist)
/* Returns next file/section-patterns, but doesn't execute any commands
   or assignments. It will remember the initial parsing state to
   do it a second time for real with next_pattern(). */
{
  char c,*keyword;

  if (!secdefbase) {
    secdefbase = gettxtptr();
    secdefline = getlineno();
  }
  *fpat = NULL;
  *spatlist = NULL;
  level = 2;

  do {
    while (keyword = getpattern()) {
      if (check_command(gv,keyword,SCMDF_IGNORE)) {
        continue;
      }
      else {
        c = getchr();
        if (c == '=') {
          skip_expr(0);
        }
        else if (c == '(') {
          if (parse_pattern(gv,keyword,fpat,spatlist))
            return 1;
        }
        else {
          /* unknown keyword ignored */
          error(65,scriptname,getlineno(),keyword);
          back(1);
        }
      }
    }
  }
  while (getchr() == ';');
  back(1);

  level = 1;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x25d14(%rip)     # 0x33610
jne 0xd915
callq 0x100de
movq %rax, 0x25d06(%rip)     # 0x33610
callq 0x10563
movl %eax, 0x25d03(%rip)     # 0x33618
xorl %eax, %eax
movq %rax, (%r14)
movq %rax, (%rbx)
movl $0x2, 0x25cf5(%rip)     # 0x3361c
movl $0x5, %edi
callq 0x100e6
testq %rax, %rax
je 0xd9cc
movq %rax, %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0x8000, %edx           # imm = 0x8000
callq 0xda00
testl %eax, %eax
je 0xd965
movl $0x5, %edi
callq 0x100e6
movq %rax, %r12
testq %rax, %rax
jne 0xd93d
jmp 0xd9cc
callq 0x1006f
cmpb $0x28, %al
je 0xd989
movzbl %al, %eax
cmpl $0x3d, %eax
jne 0xd9a0
callq 0x1006f
testb %al, %al
je 0xd951
movzbl %al, %eax
cmpl $0x3b, %eax
jne 0xd976
jmp 0xd951
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xdb59
testl %eax, %eax
je 0xd951
jmp 0xd9f1
movq 0x25c79(%rip), %r13     # 0x33620
callq 0x10563
movl $0x41, %edi
movq %r13, %rsi
movl %eax, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x6f84
movl $0x1, %edi
callq 0x100d3
jmp 0xd951
callq 0x1006f
cmpb $0x3b, %al
je 0xd927
movl $0x1, %edi
callq 0x100d3
movl $0x1, 0x25c2f(%rip)     # 0x3361c
xorl %eax, %eax
jmp 0xd9f6
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: check_command
static int check_command(struct GlobalVars *gv,char *name,uint32_t flags)
{
  struct ScriptCmd *scptr;

  for (scptr=ldCommands; scptr->name; scptr++) {
    if (!strcmp(scptr->name,name))
      break;
  }

  if (scptr->name) {
    if (scptr->flags & flags) {
      if (scptr->cmdptr) {
        scptr->cmdptr(gv);  /* execute linker-script command */
      }
      else {
        error(69,scriptname,getlineno(),name);  /* command ignored */
        if (scptr->flags & SCMDF_PAREN)
          skipblock(0,'(',')');
      }
    }
    else {
      if (!(flags & SCMDF_IGNORE)) {
        /* command not allowed outside SECTIONS block */
        error(107,scriptname,getlineno(),name);
      }
      if (scptr->flags & SCMDF_PAREN)
        skipblock(0,'(',')');
      if (scptr->flags & SCMDF_SEMIC)
        skip_expr(0);
    }
    return 1;
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x21a6b(%rip), %rdi     # 0x2f480
xorl %ebx, %ebx
testq %rdi, %rdi
sete %r13b
je 0xdb1d
movl %edx, %ebp
movq %rsi, %r14
callq 0x5160
leaq 0x21a4b(%rip), %r12     # 0x2f480
testl %eax, %eax
je 0xda59
movq 0x18(%r12), %rdi
testq %rdi, %rdi
sete %r13b
je 0xdb1d
addq $0x18, %r12
movq %r14, %rsi
callq 0x5160
jmp 0xda35
testb %r13b, %r13b
jne 0xdb1d
testl %ebp, 0x8(%r12)
je 0xda82
movq 0x10(%r12), %rax
testq %rax, %rax
je 0xdadf
movq %r15, %rdi
callq *%rax
movl $0x1, %ebx
jmp 0xdb1d
testw %bp, %bp
js 0xdaa7
movq 0x25b92(%rip), %rbx     # 0x33620
callq 0x10563
movl $0x6b, %edi
movq %rbx, %rsi
movl %eax, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x6f84
testb $0x20, 0x9(%r12)
je 0xdac0
xorl %edi, %edi
movl $0x28, %esi
movl $0x29, %edx
callq 0x1008e
movl $0x1, %ebx
testb $0x40, 0x9(%r12)
je 0xdb1d
callq 0x1006f
cmpb $0x3b, %al
je 0xdb1d
movzbl %al, %eax
testl %eax, %eax
jne 0xdacd
jmp 0xdb1d
movq 0x25b3a(%rip), %rbx     # 0x33620
callq 0x10563
movl $0x45, %edi
movq %rbx, %rsi
movl %eax, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x6f84
movl $0x1, %ebx
testb $0x20, 0x9(%r12)
je 0xdb1d
xorl %edi, %edi
movl $0x28, %esi
movl $0x29, %edx
callq 0x1008e
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_O1/deplinenoise[P]vlink/ldscript.c
// Function: find_phdr
static struct Phdr *find_phdr(struct GlobalVars *gv,const char *name,
                              struct MemoryDescr *vmreg,
                              struct MemoryDescr *lmreg)
{
  struct Phdr *p;

  if (p = gv->phdrlist) {
    do {
      if (!strcmp(p->name,name) && p->vmregion==vmreg && p->lmregion==lmreg)
        break;
    }
    while (p = p->next);
  }
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x1f8(%rdi), %rbx
testq %rbx, %rbx
je 0xe8b2
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x5160
testl %eax, %eax
jne 0xe8aa
cmpq %r15, 0x10(%rbx)
jne 0xe8aa
cmpq %r14, 0x18(%rbx)
je 0xe8b4
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0xe88e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: guess_special_segment
static uint16_t guess_special_segment(const char *secname,const char **segname)
{
  uint16_t type;

  if (!strncmp(secname,".interp",7)) {
    *segname = defint;
    type = PT_INTERP;
  }
  else if (!strncmp(secname,".dynamic",8)) {
    *segname = defdyn;
    type = PT_DYNAMIC;
  }
  else if (!strncmp(secname,".note",5)) {
    *segname = defnot;
    type = PT_NOTE;
  }
  else {
    *segname = NULL;
    type = 0;
  }

  return type;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x14410(%rip), %rsi     # 0x22ce4
movl $0x7, %edx
callq 0x5070
testl %eax, %eax
je 0xe929
leaq 0x14403(%rip), %rsi     # 0x22cec
movl $0x8, %edx
movq %r14, %rdi
callq 0x5070
testl %eax, %eax
je 0xe936
leaq 0x143f4(%rip), %rsi     # 0x22cf5
movl $0x5, %edx
movq %r14, %rdi
callq 0x5070
movl %eax, %ecx
xorl %edx, %edx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
leaq 0x143e3(%rip), %rcx     # 0x22d03
cmoveq %rcx, %rdx
shll $0x2, %eax
jmp 0xe941
movw $0x3, %ax
leaq 0x143c7(%rip), %rdx     # 0x22cfb
jmp 0xe941
movw $0x2, %ax
leaq 0x14c3f(%rip), %rdx     # 0x23580
movq %rdx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: change_address
static void change_address(struct MemoryDescr *md,lword newval)
{
  const char *secname = current_ls ? current_ls->name : defmemname;

  md->current = newval;
  if ((md->current < md->org) || (md->current > md->org + md->len)) {
    /* Fatal: Size of memory region exceeded! */
    error(63,md->name,secname,md->current);
  }
}

// Assembly:
movq %rsi, %rcx
movq 0x24967(%rip), %rax     # 0x33608
testq %rax, %rax
je 0xecac
movq 0x18(%rax), %rdx
jmp 0xecb3
leaq 0x13f1f(%rip), %rdx     # 0x22bd2
movq %rcx, 0x20(%rdi)
movq 0x10(%rdi), %rax
cmpq %rcx, %rax
jg 0xecc9
addq 0x18(%rdi), %rax
cmpq %rcx, %rax
jge 0xecd9
movq 0x8(%rdi), %rsi
movl $0x3f, %edi
xorl %eax, %eax
jmp 0x6f84
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: add_memblock
static struct MemoryDescr *add_memblock(const char *name,lword org,lword len)
{
  struct MemoryDescr *last,*new = alloc(sizeof(struct MemoryDescr));

  if (last = memory_blocks) {
    while (last->next)
      last = last->next;
    last->next = new;
  }
  else
    memory_blocks = new;

  new->next = NULL;
  new->name = allocstring(name);
  new->org = new->current = org;
  if (org+len < org)
    len -= org+len+1;
  new->len = len;
  return new;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movl $0x28, %edi
callq 0x6668
movq %rax, %r15
movq 0x24981(%rip), %rax     # 0x33680
testq %rax, %rax
je 0xed11
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
jne 0xed04
jmp 0xed18
leaq 0x24968(%rip), %rcx     # 0x33680
movq %r15, (%rcx)
movq $0x0, (%r15)
movq %r12, %rdi
callq 0x66cd
movq %rax, 0x8(%r15)
movq %r14, 0x20(%r15)
movq %r14, 0x10(%r15)
addq %rbx, %r14
notq %r14
movq %rbx, %rax
sarq $0x3f, %rax
andq %r14, %rax
addq %rbx, %rax
movq %rax, 0x18(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: add_phdr
static struct Phdr *add_phdr(struct GlobalVars *gv,const char *name,
                             uint32_t type,uint16_t flags,lword addr,
                             struct MemoryDescr *vmreg,struct MemoryDescr *lmreg)
{
  struct Phdr *p,*new;

  if (type == PT_PHDR) {
    flags |= PHDR_USED;
  }
  else if ((flags&(PHDR_FILEHDR|PHDR_PHDRS))==PHDR_FILEHDR ||
           (flags&(PHDR_FILEHDR|PHDR_PHDRS))==PHDR_PHDRS) {
    /* must include both: FILEHDR and PHDR */
    error(77,scriptname,getlineno(),name);
    return NULL;
  }

  new = alloczero(sizeof(struct Phdr));
  new->name = allocstring(name);
  new->type = type;
  new->flags = flags;
  new->start = addr;
  new->start_vma = ADDR_NONE;
  new->vmregion = vmreg;
  new->lmregion = lmreg;

  if (type == PT_LOAD) {
    if (!gv->no_page_align)
      new->alignment = shiftcnt(fff[gv->dest_format]->page_size);
  }
  else if (type == PT_PHDR)
    new->alignment = 2;

  if (p = gv->phdrlist) {
    while (p->next) {
      if (type==PT_PHDR && p->type==PT_PHDR) {
        free(new);
        return NULL;  /* reject double PHDR segment */
      }
      p = p->next;
    }
    p->next = new;
  }
  else
    gv->phdrlist = new;

  return new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %rbp
movl %ecx, %r15d
movl %edx, %ebx
movq %rsi, %r13
cmpl $0x6, %edx
jne 0xf960
orl $0x10, %r15d
jmp 0xf99e
movl %r15d, %eax
andl $0xc00, %eax            # imm = 0xC00
cmpl $0x800, %eax            # imm = 0x800
je 0xf976
cmpl $0x400, %eax            # imm = 0x400
jne 0xf99e
movq 0x23ca3(%rip), %rbx     # 0x33620
callq 0x10563
xorl %r14d, %r14d
movl $0x4d, %edi
movq %rbx, %rsi
movl %eax, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x6f84
jmp 0xfa66
movq %rdi, (%rsp)
movl $0x58, %edi
callq 0x66b6
movq %rax, %r14
movq %r13, %rdi
callq 0x66cd
movq %rax, 0x8(%r14)
movl %ebx, 0x20(%r14)
movw %r15w, 0x24(%r14)
movq %rbp, 0x30(%r14)
movq $-0x1, 0x28(%r14)
movq %r12, 0x10(%r14)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%r14)
cmpl $0x1, %ebx
jne 0xfa0c
movq (%rsp), %rcx
cmpl $0x0, 0x7c(%rcx)
jne 0xfa1b
movzbl 0x50(%rcx), %eax
leaq 0x1f789(%rip), %rcx     # 0x2f180
movq (%rcx,%rax,8), %rax
movl 0x98(%rax), %edi
callq 0x6e74
movq (%rsp), %rcx
jmp 0xfa17
movb $0x2, %al
cmpl $0x6, %ebx
movq (%rsp), %rcx
jne 0xfa1b
movb %al, 0x26(%r14)
movq 0x1f8(%rcx), %rax
testq %rax, %rax
je 0xfa4a
movq (%rax), %rdx
testq %rdx, %rdx
je 0xfa53
movq %rdx, %rcx
cmpl $0x6, %ebx
jne 0xfa3d
cmpl $0x6, 0x20(%rax)
je 0xfa5b
movq (%rcx), %rdx
movq %rcx, %rax
testq %rdx, %rdx
jne 0xfa2f
jmp 0xfa56
movq %r14, 0x1f8(%rcx)
jmp 0xfa66
movq %rax, %rcx
movq %r14, (%rcx)
jmp 0xfa66
movq %r14, %rdi
callq 0x5040
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: startofblock
static bool startofblock(char c)
{
  if (getchr() != c) {
    error(66,scriptname,getlineno(),c);
    back(1);
    return FALSE;
  }
  return TRUE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
callq 0x1006f
movl $0x1, %ebx
cmpb %bpl, %al
je 0xfabc
movzbl %bpl, %ebp
movq 0x23b88(%rip), %r14     # 0x33620
callq 0x10563
xorl %ebx, %ebx
movl $0x42, %edi
movq %r14, %rsi
movl %eax, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x6f84
movl $0x1, %edi
callq 0x100d3
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: getsection
static struct LinkedSection *getsection(struct GlobalVars *gv)
{
  struct LinkedSection *ls = NULL;
  char *sname;

  if (sname = getword()) {
    if (!(ls = find_lnksec(gv,sname,0,0,0,0)))
      error(79,scriptname,getlineno(),sname);  /* Undefined section */
  }
  else
    error(78,scriptname,getlineno());

  return ls;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x1, %edi
callq 0x100e6
testq %rax, %rax
je 0xfb1f
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xbeb0
movq %rax, %r14
testq %rax, %rax
jne 0xfb3f
movq 0x23b1f(%rip), %r15     # 0x33620
callq 0x10563
xorl %r14d, %r14d
movl $0x4f, %edi
movq %r15, %rsi
movl %eax, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x6f84
jmp 0xfb3f
movq 0x23afa(%rip), %rbx     # 0x33620
callq 0x10563
xorl %r14d, %r14d
movl $0x4e, %edi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6f84
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: endofblock
static bool endofblock(char c1,char c2)
{
  if (getchr() != c2) {
    error(66,scriptname,getlineno(),c2);
    skipblock(1,c1,c2);
    return FALSE;
  }
  return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %ebx
callq 0x1006f
movl $0x1, %ebp
cmpb %r14b, %al
je 0xfb99
movq 0x23ab6(%rip), %r15     # 0x33620
callq 0x10563
movsbl %r14b, %r14d
xorl %ebp, %ebp
movl $0x42, %edi
movq %r15, %rsi
movl %eax, %edx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x6f84
movsbl %bl, %esi
movl $0x1, %edi
movl %r14d, %edx
callq 0x1008e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: term_absexp
static lword term_absexp(void)
{
  lword val = 0;

  if (getchr() == '(') {
    if (!parse_expr(-1,&val))
      error(67,scriptname,getlineno());  /* Absolute number expected */
    if (getchr() != ')') {
      error(66,scriptname,getlineno(),')');  /* ')' expected */
      skipblock(1,'(',')');
    }
  }
  else
    error(66,scriptname,getlineno(),'(');  /* '(' expected */

  return val;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
callq 0x1006f
cmpb $0x28, %al
jne 0xfc30
leaq 0x8(%rsp), %rsi
movq $-0x1, %rdi
callq 0x101d8
testl %eax, %eax
jne 0xfbef
movq 0x23a47(%rip), %rbx     # 0x33620
callq 0x10563
movl $0x43, %edi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6f84
callq 0x1006f
cmpb $0x29, %al
je 0xfc52
movq 0x23a21(%rip), %rbx     # 0x33620
callq 0x10563
movl $0x42, %edi
movq %rbx, %rsi
movl %eax, %edx
movl $0x29, %ecx
xorl %eax, %eax
callq 0x6f84
movl $0x1, %edi
movl $0x28, %esi
movl $0x29, %edx
callq 0x1008e
jmp 0xfc52
movq 0x239e9(%rip), %rbx     # 0x33620
callq 0x10563
movl $0x42, %edi
movq %rbx, %rsi
movl %eax, %edx
movl $0x28, %ecx
xorl %eax, %eax
callq 0x6f84
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: set_ctors_type
static void set_ctors_type(struct GlobalVars *gv,uint8_t type)
{
  if (gv->collect_ctors_type!=CCDT_NONE &&
      gv->collect_ctors_type!=type)
    error(71,scriptname,getlineno());  /* multiple constructor types */

  gv->collect_ctors_type = type;

  if (new_ls_name)
    gv->collect_ctors_secname = new_ls_name;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movb 0x203(%rdi), %al
testb %al, %al
sete %cl
cmpb %bpl, %al
sete %al
orb %cl, %al
jne 0xfc98
movq 0x2399e(%rip), %r14     # 0x33620
callq 0x10563
movl $0x47, %edi
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6f84
movb %bpl, 0x203(%rbx)
movq 0x239d2(%rip), %rax     # 0x33678
testq %rax, %rax
je 0xfcb2
movq %rax, 0x208(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: getfilename
static char *getfilename(void)
{
  if (getchr() == '\"') {
    back(1);
    return getquoted();
  }

  back(1);
  return getarg(27);
}

// Assembly:
pushq %rbx
callq 0x1006f
movl %eax, %ebx
movl $0x1, %edi
callq 0x100d3
cmpb $0x22, %bl
jne 0xfcd4
popq %rbx
jmp 0x10154
movl $0x1b, %edi
popq %rbx
jmp 0x100e6
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: scriptsymbol
static void scriptsymbol(struct GlobalVars *gv,char *name,
                         lword val,uint8_t type,uint8_t flags)
{
  struct Symbol *sym;
  struct Symbol **chain = &script_obj->objsyms[elf_hash(name)%OBJSYMHTABSIZE];

  while (sym = *chain) {
    if (!strcmp(name,sym->name)) {
      error(109,scriptname,getlineno(),name);  /* already defined */
      return;
    }
    chain = &sym->obj_chain;
  }
  sym = alloczero(sizeof(struct Symbol));
  if (check_protection(gv,name))
    flags |= SYMF_PROTECTED;

  sym->name = allocstring(name);
  sym->value = val;
  sym->type = type;
  sym->flags = flags;
  sym->bind = SYMB_GLOBAL;

  /* These symbols will be moved from scriptsymbols list into
     LinkedSection.symbols during linker_copy() - at least
     the remaining, absolute ones. */
  if (addglobsym(gv,sym)) {
    *chain = sym;
    addtail(&gv->scriptsymbols,&sym->n);
  }
  else
    free(sym);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x23974(%rip), %rax     # 0x33670
movq 0x48(%rax), %r12
movq %rsi, %rdi
callq 0x6e09
andl $0x1f, %eax
movq (%r12,%rax,8), %rcx
testq %rcx, %rcx
je 0xfd3a
movq %rcx, %r13
movq 0x20(%rcx), %rsi
movq %r14, %rdi
callq 0x5160
testl %eax, %eax
je 0xfdbd
movq 0x18(%r13), %rcx
testq %rcx, %rcx
jne 0xfd14
addq $0x18, %r13
jmp 0xfd3e
leaq (%r12,%rax,8), %r13
movl $0x50, %edi
callq 0x66b6
movq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa8fa
movzbl %bpl, %ecx
orb $0x4, %bpl
testl %eax, %eax
movzbl %bpl, %ebp
cmovel %ecx, %ebp
movq %r14, %rdi
callq 0x66cd
movq %rax, 0x20(%r12)
movq %r15, 0x30(%r12)
movb $0x1, 0x40(%r12)
movb %bpl, 0x41(%r12)
movb $0x2, 0x43(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa934
testl %eax, %eax
je 0xfdeb
movq %r12, (%r13)
addq $0x190, %rbx            # imm = 0x190
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6759
movq 0x2385c(%rip), %rbx     # 0x33620
callq 0x10563
movl $0x6d, %edi
movq %rbx, %rsi
movl %eax, %edx
movq %r14, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6f84
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5040
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: get_dummy_sec
static struct Section *get_dummy_sec(const char *name)
/* return dummy section of our artificial script-object with name */
{
  struct Section *sec;

  for (sec=(struct Section *)script_obj->sections.first;
       sec->n.next!=NULL; sec=(struct Section *)sec->n.next) {
    if (!strcmp(sec->name,name))
      break;
  }
  if (sec->n.next == NULL)
    ierror("get_dummy_sec(): Dummy section \"%s\" not found",name);
  return sec;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x23860(%rip), %rax     # 0x33670
movq 0x20(%rax), %r15
movq %r15, %rbx
movq (%r15), %r15
testq %r15, %r15
je 0xfe34
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x5160
testl %eax, %eax
jne 0xfe14
testq %r15, %r15
jne 0xfe45
leaq 0x12e53(%rip), %rdi     # 0x22c8e
movq %r14, %rsi
xorl %eax, %eax
callq 0x52b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: readmemparam
static lword readmemparam(char *key)
{
  char *str;
  lword val = 0;

  if (str = getword()) {
    if (toupper((unsigned char)*str) == *key) {
      if (getchr() == '=') {
        if (!parse_expr(-1,&val))
          error(67,scriptname,getlineno());  /* Absolute number expected */
      }
      else
        error(66,scriptname,getlineno(),'=');
    }
    else
      error(68,scriptname,getlineno(),key);  /* keyword expected */
  }
  else
    error(68,scriptname,getlineno(),key);
  return val;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, (%rsp)
movl $0x1, %edi
callq 0x100e6
testq %rax, %rax
je 0xfebe
movq %rax, %r14
callq 0x5030
movq (%rax), %rax
movzbl (%r14), %ecx
movsbl (%rbx), %edx
cmpl %edx, (%rax,%rcx,4)
jne 0xfebe
callq 0x1006f
cmpb $0x3d, %al
jne 0xfeea
movq %rsp, %rsi
movq $-0x1, %rdi
callq 0x101d8
testl %eax, %eax
jne 0xfede
movq 0x2377a(%rip), %rbx     # 0x33620
callq 0x10563
movl $0x43, %edi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6f84
jmp 0xfede
movq 0x2375b(%rip), %r14     # 0x33620
callq 0x10563
movl $0x44, %edi
movq %r14, %rsi
movl %eax, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x6f84
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2372f(%rip), %rbx     # 0x33620
callq 0x10563
movl $0x42, %edi
movq %rbx, %rsi
movl %eax, %edx
movl $0x3d, %ecx
xorl %eax, %eax
callq 0x6f84
jmp 0xfede
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/ldscript.c
// Function: use_segment
static void use_segment(struct GlobalVars *gv,const char *name,uint32_t type,
                        struct MemoryDescr *vmreg,struct MemoryDescr *lmreg)
{
  struct Phdr *p;

  if (p = find_phdr(gv,name,vmreg,lmreg)) {
    if (p->type == PT_NULL)
      return;
  }
  else {
    if (!(p = add_phdr(gv,name,type,0,ADDR_NONE,vmreg,lmreg)))
      return;
  }
  p->flags |= PHDR_USED;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r15
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
movq %rcx, %rdx
movq %r8, %rcx
callq 0xe871
testq %rax, %rax
je 0xff4f
cmpl $0x0, 0x20(%rax)
je 0xff42
orb $0x10, 0x24(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r15, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
movq $-0x1, %r8
movq %rbx, %r9
callq 0xf93c
testq %rax, %rax
jne 0xff3e
jmp 0xff42
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/pmatch.c
// Function: patternlist_match
bool patternlist_match(char **patlist,const char *str)
/* match string against a list of patterns */
{
  if (patlist) {
    while (*patlist) {
      if (pattern_match(*patlist,str))
        return (TRUE);
      patlist++;
    }
  }
  return (FALSE);
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0xffce
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xffc7
movq %rsi, %rbx
addq $0x8, %r14
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5110
testl %eax, %eax
je 0xffc2
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0xffa4
xorl %eax, %eax
jmp 0xffc7
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: skip
void skip(void)
/* skips blanks, tabs, newlines and comments */
{
  s = skipblanks(s);
  while (*s == '/' && *(s+1) == '*') {
    /* skip comment */
    s += 2;
    while (*s && (*s!='*' || *(s+1)!='/')) {
      if (*s=='\n')
        line++;
      s++;
    }
    s += 2;
    s = skipblanks(s);
  }
}

// Assembly:
pushq %rax
movq 0x236b8(%rip), %rdi     # 0x33690
callq 0x10033
movq %rax, 0x236ac(%rip)     # 0x33690
cmpb $0x2f, (%rax)
jne 0x10031
cmpb $0x2a, 0x1(%rax)
jne 0x10031
movl 0x236a3(%rip), %ecx     # 0x33698
addq $0x4, %rax
movzbl -0x2(%rax), %edx
cmpl $0xa, %edx
je 0x10018
cmpl $0x2a, %edx
je 0x1000d
testl %edx, %edx
jne 0x10020
jmp 0x10025
cmpb $0x2f, -0x1(%rax)
je 0x10025
cmpb $0xa, %dl
jne 0x10020
incl %ecx
movl %ecx, 0x23678(%rip)     # 0x33698
incq %rax
jmp 0xfff9
movq %rax, 0x23664(%rip)     # 0x33690
movq %rax, %rdi
jmp 0xffd8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: skipblanks
static char *skipblanks(char *sp)
{
  unsigned char c = (unsigned char)*sp;

  while (isspace(c)) {
    if (c == '\n')
      line++;
    c = (unsigned char)*(++sp);
  }
  return sp;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5290
movq (%rax), %rax
movzbl (%rbx), %edx
testb $0x20, 0x1(%rax,%rdx,2)
je 0x1006a
movl 0x23649(%rip), %ecx     # 0x33698
cmpb $0xa, %dl
jne 0x1005c
incl %ecx
movl %ecx, 0x2363c(%rip)     # 0x33698
movzbl 0x1(%rbx), %edx
incq %rbx
testb $0x20, 0x1(%rax,%rdx,2)
jne 0x1004f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: getchr
char getchr(void)
{
  char c;

  skip();
  if (c = *s)
    s++;
  return c;
}

// Assembly:
pushq %rax
callq 0xffd0
movq 0x23614(%rip), %rcx     # 0x33690
movb (%rcx), %al
testb %al, %al
je 0x1008c
incq %rcx
movq %rcx, 0x23604(%rip)     # 0x33690
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: skipblock
void skipblock(int level,char start,char end)
/* skips a block between the two specified start- and end-characters */
{
  char c;

  while (c = getchr()) {
    if (c == start) {
      ++level;
    }
    else if (c == end) {
      if (--level <= 0)
        break;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
callq 0xffd0
movq 0x235eb(%rip), %rcx     # 0x33690
movb (%rcx), %al
testb %al, %al
je 0x100ce
incq %rcx
movq %rcx, 0x235db(%rip)     # 0x33690
cmpb %bpl, %al
jne 0x100bf
incl %r14d
jmp 0x10099
cmpb %bl, %al
jne 0x10099
cmpl $0x2, %r14d
jl 0x100ce
decl %r14d
jmp 0x10099
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: getquoted
char *getquoted(void)
/* return characters between "quotes" */
{
  skip();
  if (*s == '\"') {
    static char buffer[MAXLEN];
    char c,*bp=buffer;

    s++;

    while (c = *s) {
      s++;

      if (c == '\n') {
        line++;
        break;  /* @@@ newline breaks string? */
      }
      else if (c == '\"')
        break;

      *bp++ = c;
      if (bp >= &buffer[MAXLEN-1])
        break;  /* buffer overflow */
    }
    *bp = '\0';
    return buffer;
  }

  return NULL;
}

// Assembly:
pushq %rax
callq 0xffd0
movq 0x2352f(%rip), %rcx     # 0x33690
cmpb $0x22, (%rcx)
jne 0x101bc
leaq 0x1(%rcx), %rax
movq %rax, 0x2351f(%rip)     # 0x33690
addq $0x2, %rcx
xorl %edx, %edx
leaq 0x23622(%rip), %rax     # 0x337a0
movl $0xff, %edi
leaq (%rax,%rdi), %rsi
movzbl -0x1(%rcx), %r9d
testl %r9d, %r9d
je 0x101c0
leaq (%rax,%rdx), %r8
movq %rcx, 0x234f4(%rip)     # 0x33690
cmpl $0x22, %r9d
je 0x101d2
cmpl $0xa, %r9d
je 0x101cc
movb %r9b, (%rdx,%rax)
incq %rdx
incq %rcx
cmpq %rdi, %rdx
jne 0x10187
movq %rsi, %r8
jmp 0x101d2
xorl %eax, %eax
jmp 0x101d6
leaq 0x235d9(%rip), %r8      # 0x337a0
addq %rdx, %r8
jmp 0x101d2
incl 0x234c6(%rip)           # 0x33698
movb $0x0, (%r8)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: parse_expr
int parse_expr(lword current_addr,lword *result)
/* Tries to parse the input stream. Returns !0 for an absolute result.
   If current_addr = -1 then '.' is not defined and only references
   to absolute symbols are allowed.
   If current_addr = -2 then no expression evaluation takes place
   at all. The expression is just skipped. */
{
  lword saved_caddr = caddr;
  struct Expr *tree;
  int abs;

  caddr = current_addr;
  skip();
  tree = expression();
  abs = caddr==-2 ? 1 : eval_expr(tree,result);
  free_expr(tree);
  caddr = saved_caddr;
  return abs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x236b7(%rip), %r15     # 0x338a0
movq %rdi, 0x236b0(%rip)     # 0x338a0
callq 0xffd0
callq 0x10235
movq %rax, %r14
movl $0x1, %ebp
cmpq $-0x2, 0x23696(%rip)    # 0x338a0
je 0x10219
movq %r14, %rdi
movq %rbx, %rsi
callq 0x102b3
movl %eax, %ebp
movq %r14, %rdi
callq 0x1053e
movq %r15, 0x23678(%rip)     # 0x338a0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: expression
static struct Expr *expression(void)
{
  struct Expr *left,*new;

  left = logical_and_expr();
  skip();
  while (s[0]=='|' && s[1]=='|') {
    s += 2;
    skip();
    new = new_expr();
    new->type = LOR;
    skip();
    new->left = left;
    new->right = logical_and_expr();
    left = new;
  }
  return left;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x10586
movq %rax, %rbx
callq 0xffd0
movq 0x23443(%rip), %rax     # 0x33690
cmpb $0x7c, (%rax)
jne 0x102a5
cmpb $0x7c, 0x1(%rax)
jne 0x102a5
addq $0x2, %rax
movq %rax, 0x2342d(%rip)     # 0x33690
callq 0xffd0
movl $0x20, %edi
callq 0x6668
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0x8, (%rax)
callq 0xffd0
movq %rbx, 0x8(%r14)
callq 0x10586
movq %rax, 0x10(%r14)
movq 0x233f5(%rip), %rax     # 0x33690
cmpb $0x7c, (%rax)
movq %r14, %rbx
je 0x10252
jmp 0x102a8
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: free_expr
static void free_expr(struct Expr *tree)
{
  if (tree) {
    free_expr(tree->left);
    free_expr(tree->right);
    free(tree);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x10562
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1053e
movq 0x10(%rbx), %rdi
callq 0x1053e
movq %rbx, %rdi
popq %rbx
jmp 0x5040
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: logical_and_expr
static struct Expr *logical_and_expr(void)
{
  struct Expr *left,*new;

  left = inclusive_or_expr();
  skip();
  while (s[0]=='&' && s[1]=='&') {
    s += 2;
    skip();
    new = new_expr();
    new->type = LAND;
    skip();
    new->left = left;
    new->right = inclusive_or_expr();
    left = new;
  }
  return left;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x10604
movq %rax, %rbx
callq 0xffd0
movq 0x230f2(%rip), %rax     # 0x33690
cmpb $0x26, (%rax)
jne 0x105f6
cmpb $0x26, 0x1(%rax)
jne 0x105f6
addq $0x2, %rax
movq %rax, 0x230dc(%rip)     # 0x33690
callq 0xffd0
movl $0x20, %edi
callq 0x6668
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0x7, (%rax)
callq 0xffd0
movq %rbx, 0x8(%r14)
callq 0x10604
movq %rax, 0x10(%r14)
movq 0x230a4(%rip), %rax     # 0x33690
cmpb $0x26, (%rax)
movq %r14, %rbx
je 0x105a3
jmp 0x105f9
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: inclusive_or_expr
static struct Expr *inclusive_or_expr(void)
{
  struct Expr *left,*new;

  left = exclusive_or_expr();
  skip();
  while (s[0]=='|' && s[1]!='|') {
    s++;
    skip();
    new = new_expr();
    new->type = BOR;
    skip();
    new->left = left;
    new->right = exclusive_or_expr();
    left = new;
  }
  return left;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x10681
movq %rax, %rbx
callq 0xffd0
movq 0x23074(%rip), %rax     # 0x33690
cmpb $0x7c, (%rax)
jne 0x10673
cmpb $0x7c, 0x1(%rax)
je 0x10673
incq %rax
movq %rax, 0x2305f(%rip)     # 0x33690
callq 0xffd0
movl $0x20, %edi
callq 0x6668
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0xa, (%rax)
callq 0xffd0
movq %rbx, 0x8(%r14)
callq 0x10681
movq %rax, 0x10(%r14)
movq 0x23027(%rip), %rax     # 0x33690
cmpb $0x7c, (%rax)
movq %r14, %rbx
je 0x10621
jmp 0x10676
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: exclusive_or_expr
static struct Expr *exclusive_or_expr(void)
{
  struct Expr *left,*new;

  left = and_expr();
  skip();
  while (*s=='^') {
    s++;
    skip();
    new = new_expr();
    new->type = XOR;
    skip();
    new->left = left;
    new->right = and_expr();
    left = new;
  }
  return left;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x106f8
movq %rax, %rbx
callq 0xffd0
movq 0x22ff7(%rip), %rax     # 0x33690
cmpb $0x5e, (%rax)
jne 0x106ea
incq %rax
movq %rax, 0x22fe8(%rip)     # 0x33690
callq 0xffd0
movl $0x20, %edi
callq 0x6668
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0xb, (%rax)
callq 0xffd0
movq %rbx, 0x8(%r14)
callq 0x106f8
movq %rax, 0x10(%r14)
movq 0x22fb0(%rip), %rax     # 0x33690
cmpb $0x5e, (%rax)
movq %r14, %rbx
je 0x1069e
jmp 0x106ed
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: and_expr
static struct Expr *and_expr(void)
{
  struct Expr *left,*new;

  left = equality_expr();
  skip();
  while (s[0]=='&' && s[1]!='&') {
    s++;
    skip();
    new = new_expr();
    new->type = BAND;
    skip();
    new->left = left;
    new->right = equality_expr();
    left = new;
  }
  return left;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x10775
movq %rax, %rbx
callq 0xffd0
movq 0x22f80(%rip), %rax     # 0x33690
cmpb $0x26, (%rax)
jne 0x10767
cmpb $0x26, 0x1(%rax)
je 0x10767
incq %rax
movq %rax, 0x22f6b(%rip)     # 0x33690
callq 0xffd0
movl $0x20, %edi
callq 0x6668
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0x9, (%rax)
callq 0xffd0
movq %rbx, 0x8(%r14)
callq 0x10775
movq %rax, 0x10(%r14)
movq 0x22f33(%rip), %rax     # 0x33690
cmpb $0x26, (%rax)
movq %r14, %rbx
je 0x10715
jmp 0x1076a
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: equality_expr
static struct Expr *equality_expr(void)
{
  struct Expr *left,*new;
  char m;

  left = relational_expr();
  skip();
  while ((s[0]=='!' || s[0]=='=') && s[1]=='=') {
    m = *s;
    s += 2;
    skip();
    new = new_expr();
    new->type = (m=='!') ? NEQ : EQ;
    skip();
    new->left = left;
    new->right = relational_expr();
    left = new;
  }
  return left;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x107f2
movq %rax, %rbx
callq 0xffd0
movq 0x22f03(%rip), %rax     # 0x33690
movzbl (%rax), %ebp
cmpl $0x3d, %ebp
je 0x1079a
cmpl $0x21, %ebp
jne 0x107ea
cmpb $0x3d, 0x1(%rax)
jne 0x107ea
addq $0x2, %rax
movq %rax, 0x22ee5(%rip)     # 0x33690
callq 0xffd0
movl $0x20, %edi
callq 0x6668
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
xorl %eax, %eax
cmpb $0x21, %bpl
setne %al
addl $0x13, %eax
movl %eax, (%r14)
callq 0xffd0
movq %rbx, 0x8(%r14)
callq 0x107f2
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0x10786
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: relational_expr
static struct Expr *relational_expr(void)
{
  struct Expr *left,*new;
  char m1,m2=0;

  left = shift_expr();
  skip();
  while ((s[0]=='<' || s[0]=='>') && s[1]!=s[0]) {
    m1 = *s++;
    if (*s == '=')
      m2 = *s++;
    skip();
    new = new_expr();
    if (m1 == '<')
      new->type = m2 ? LEQ : LT;
    else
      new->type = m2 ? GEQ : GT;
    skip();
    new->left = left;
    new->right = shift_expr();
    left = new;
  }
  return left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x108a4
movq %rax, %rbx
callq 0xffd0
xorl %ebp, %ebp
movl $0x3d, %r15d
movq 0x22e7a(%rip), %rax     # 0x33690
movzbl (%rax), %r12d
movl %r12d, %ecx
orl $0x2, %ecx
cmpl $0x3e, %ecx
jne 0x10898
movb 0x1(%rax), %cl
cmpb %r12b, %cl
je 0x10898
leaq 0x1(%rax), %rdx
addq $0x2, %rax
cmpb $0x3d, %cl
cmovneq %rdx, %rax
movzbl %bpl, %ebp
cmovel %r15d, %ebp
movq %rax, 0x22e45(%rip)     # 0x33690
callq 0xffd0
movl $0x20, %edi
callq 0x6668
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
xorl %eax, %eax
testb %bpl, %bpl
setne %al
cmpb $0x3c, %r12b
leal 0x10(%rax,%rax), %ecx
leal 0xf(%rax,%rax), %eax
cmovnel %ecx, %eax
movl %eax, (%r14)
callq 0xffd0
movq %rbx, 0x8(%r14)
callq 0x108a4
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0x1080f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: shift_expr
static struct Expr *shift_expr(void)
{
  struct Expr *left,*new;
  char m;

  left = additive_expr();
  skip();
  while ((s[0]=='<' || s[0]=='>') && s[1]==s[0]) {
    m = *s;
    s += 2;
    skip();
    new = new_expr();
    new->type = (m=='<') ? LSH : RSH;
    new->left = left;
    new->right = additive_expr();
    left = new;
    skip();
  }
  return left;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x1091c
movq %rax, %rbx
callq 0xffd0
movq 0x22dd4(%rip), %rax     # 0x33690
movzbl (%rax), %ebp
movl %ebp, %ecx
orl $0x2, %ecx
cmpl $0x3e, %ecx
jne 0x10914
cmpb %bpl, 0x1(%rax)
jne 0x10914
addq $0x2, %rax
movq %rax, 0x22db6(%rip)     # 0x33690
callq 0xffd0
movl $0x20, %edi
callq 0x6668
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
xorl %eax, %eax
cmpb $0x3c, %bpl
setne %al
addl $0xd, %eax
movl %eax, (%r14)
movq %rbx, 0x8(%r14)
callq 0x1091c
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0x108b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: additive_expr
static struct Expr *additive_expr(void)
{
  struct Expr *left,*new;
  char m;

  left = multiplicative_expr();
  skip();
  while (*s=='+' || *s=='-') {
    m = *s++;
    skip();
    new = new_expr();
    new->type = (m=='+') ? ADD : SUB;
    new->left = left;
    new->right = multiplicative_expr();
    left = new;
    skip();
  }
  return left;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x1098a
movq %rax, %rbx
callq 0xffd0
movq 0x22d5c(%rip), %rax     # 0x33690
movzbl (%rax), %ebp
cmpl $0x2d, %ebp
je 0x10941
cmpl $0x2b, %ebp
jne 0x10982
incq %rax
movq %rax, 0x22d45(%rip)     # 0x33690
callq 0xffd0
movl $0x20, %edi
callq 0x6668
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
xorl %eax, %eax
cmpb $0x2b, %bpl
setne %al
movl %eax, (%r14)
movq %rbx, 0x8(%r14)
callq 0x1098a
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0x10928
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: multiplicative_expr
static struct Expr *multiplicative_expr(void)
{
  struct Expr *left,*new;
  char m;

  left = unary_expr();
  skip();
  while (*s=='*' || *s=='/' || *s=='%') {
    m = *s++;
    skip();
    new = new_expr();
    new->type = (m=='*') ? MUL : ( (m=='/') ? DIV : MOD );
    new->left = left;
    new->right = unary_expr();
    left = new;
    skip();
  }
  return left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x10a1c
movq %rax, %rbx
movabsq $0x842000000000, %r15   # imm = 0x842000000000
movl $0x2, %ebp
callq 0xffd0
movq 0x22cdb(%rip), %rax     # 0x33690
movzbl (%rax), %r12d
cmpq $0x2f, %r12
ja 0x10a10
btq %r12, %r15
jae 0x10a10
incq %rax
movq %rax, 0x22cc1(%rip)     # 0x33690
callq 0xffd0
movl $0x20, %edi
callq 0x6668
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
xorl %eax, %eax
cmpb $0x2f, %r12b
setne %al
addl $0x3, %eax
cmpb $0x2a, %r12b
cmovel %ebp, %eax
movl %eax, (%r14)
movq %rbx, 0x8(%r14)
callq 0x10a1c
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0x109a9
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/expr.c
// Function: unary_expr
static struct Expr *unary_expr(void)
{
  struct Expr *new;
  char m;

  if (*s=='+' || *s=='-' || *s=='!' || *s=='~') {
    m = *s++;
    skip();
  }
  else
    return primary_expr();
  if (m == '+')
    return primary_expr();

  new = new_expr();
  new->type = (m=='-') ? NEG : ( (m=='!') ? NOT : CPL );
  new->left = primary_expr();
  return new;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x22c69(%rip), %rax     # 0x33690
movzbl (%rax), %r14d
cmpq $0x2d, %r14
ja 0x10a41
movabsq $0x280200000000, %rcx   # imm = 0x280200000000
btq %r14, %rcx
jb 0x10a47
cmpl $0x7e, %r14d
jne 0x10a5c
incq %rax
movq %rax, 0x22c3f(%rip)     # 0x33690
callq 0xffd0
cmpb $0x2b, %r14b
jne 0x10a65
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10aac
movl $0x20, %edi
callq 0x6668
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
cmpb $0x21, %r14b
movl $0xc, %eax
movl $0x6, %ecx
cmovel %eax, %ecx
cmpb $0x2d, %r14b
movl $0x5, %eax
cmovnel %ecx, %eax
movl %eax, (%rbx)
callq 0x10aac
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/t_amigahunk.c
// Function: targetlink
static int 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. */
{
  static char *merged = "__MERGED";

  /* AmigaDOS doesn't merge unnamed sections, unless the Small- */
  /* Data/Code option was set */
  if (!(gv->small_code && s->type==ST_CODE) &&
      !(gv->small_data && (s->type==ST_DATA || s->type==ST_UDATA)))
    if (*(ls->name)==0 && *(s->name)==0)
      return (-1);

  /* sections with name "_NOMERGE" are never combined */
  if (!strcmp(s->name,"_NOMERGE"))
    return (-1);

  /* Executable only: */
  if (!gv->dest_object) {
    if (!strcmp(ls->name,merged) && !strcmp(s->name,merged)) {
      /* data and bss section with name __MERGED are always combined */
      if (s->type == ST_CODE)
        error(57,getobjname(s->obj)); /* Merging code section "__MERGED" */
      return (1);
    }
  }

  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x70(%rdi)
je 0x11c74
cmpb $0x1, 0x2c(%rbx)
je 0x11c96
cmpl $0x0, 0x74(%r15)
je 0x11c84
movb 0x2c(%rbx), %al
andb $-0x2, %al
cmpb $0x2, %al
je 0x11c96
movq 0x18(%r14), %rax
cmpb $0x0, (%rax)
jne 0x11c96
movq 0x20(%rbx), %rax
cmpb $0x0, (%rax)
je 0x11d02
movq 0x20(%rbx), %r12
leaq 0x114e0(%rip), %rsi     # 0x23181
movq %r12, %rdi
callq 0x5160
testl %eax, %eax
je 0x11d02
xorl %ebp, %ebp
cmpl $0x0, 0x54(%r15)
jne 0x11d07
movq 0x18(%r14), %rdi
leaq 0x114b7(%rip), %rsi     # 0x23178
callq 0x5160
testl %eax, %eax
jne 0x11d07
leaq 0x114a7(%rip), %rsi     # 0x23178
movq %r12, %rdi
callq 0x5160
testl %eax, %eax
jne 0x11d07
movl $0x1, %ebp
cmpb $0x1, 0x2c(%rbx)
jne 0x11d07
movq 0x10(%rbx), %rdi
callq 0x7174
movl $0x39, %edi
movq %rax, %rsi
xorl %eax, %eax
callq 0x6f84
jmp 0x11d07
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq