LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/ldscript.c
// Function: sc_entry
static void sc_entry(struct GlobalVars *gv)
/* ENTRY(symbol or address) */
{
  if (startofblock('(')) {
    char *entryname;

    if (entryname = getalnum()) {
      if (gv->entry_name == NULL)
        gv->entry_name = allocstring(entryname);
    }
    else
      error(78,scriptname,getlineno());
    endofblock('(',')');
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0xef1d
testl %eax, %eax
je 0xcb62
pushq $0x3
popq %rdi
callq 0xf4bf
testq %rax, %rax
je 0xcb64
cmpq $0x0, 0xd0(%rbx)
jne 0xcb7f
movq %rax, %rdi
callq 0x63a1
movq %rax, 0xd0(%rbx)
jmp 0xcb7f
popq %rbx
retq
movq 0x26ea5(%rip), %rbx     # 0x33a10
callq 0xf90a
pushq $0x4e
popq %rdi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6c19
pushq $0x28
popq %rdi
pushq $0x29
popq %rsi
popq %rbx
jmp 0xefde
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/ldscript.c
// Function: sc_extern
static void sc_extern(struct GlobalVars *gv)
/* EXTERN(symbol [symbol...]) */
{
  if (startofblock('(')) {
    char c;

    do {
      char *name = getword();

      if (*name)
        add_symnames(&gv->undef_syms,allocstring(name));
      else
        error(78,scriptname,getlineno());   /* missing argument */

      if (c = getchr())
        back(1);
    }
    while (c!='\0' && c!=')');

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0xef1d
testl %eax, %eax
je 0xcc17
addq $0xb8, %rbx
pushq $0x4e
popq %rbp
pushq $0x1
popq %r14
callq 0xe109
cmpb $0x0, (%rax)
je 0xcbce
movq %rax, %rdi
callq 0x63a1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6af4
jmp 0xcbe8
movq 0x26e3b(%rip), %r15     # 0x33a10
callq 0xf90a
movl %ebp, %edi
movq %r15, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6c19
callq 0xf457
testb %al, %al
je 0xcc02
movl %eax, %r15d
movl %r14d, %edi
callq 0xf4ac
cmpb $0x29, %r15b
jne 0xcbaf
pushq $0x28
popq %rdi
pushq $0x29
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xefde
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/ldscript.c
// Function: sc_fill
static void sc_fill(struct GlobalVars *gv)
/* FILL(data16) */
{
  if (startofblock('(')) {
    lword val;

    if (parse_expr(preparse ? -1 : 0,&val))
      gv->filldata = (uint16_t)(val & 0xffff);
    else
      error(67,scriptname,getlineno());  /* Absolute number expected */
    endofblock('(',')');
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0xef1d
testl %eax, %eax
je 0xcc85
movzbl 0x26e13(%rip), %edi     # 0x33a50
andl $0x1, %edi
negq %rdi
leaq 0x8(%rsp), %rsi
callq 0xf5a5
testl %eax, %eax
je 0xcc5f
movzwl 0x8(%rsp), %eax
movw %ax, 0x200(%rbx)
jmp 0xcc7a
movq 0x26daa(%rip), %rbx     # 0x33a10
callq 0xf90a
pushq $0x43
popq %rdi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6c19
pushq $0x28
popq %rdi
pushq $0x29
popq %rsi
callq 0xefde
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/ldscript.c
// Function: sc_input
static void sc_input(struct GlobalVars *gv)
/* INPUT(file1 [file2...]) */
{
  if (startofblock('(')) {
    char c,*fname;

    while (fname = getfilename()) {
      struct InputFile *ifn = alloc(sizeof(struct InputFile));

      if (strlen(fname)>2 && !strncmp(fname,"-l",2)) {
        fname += 2;
        while (isspace((unsigned)*fname))
          fname++;
        ifn->lib = TRUE;
        ifn->dynamic = gv->dynamic;
        ifn->so_ver = 0;  /* @@@ */
      }
      else
        ifn->lib = FALSE;
      ifn->name = allocstring(fname);
      ifn->flags = 0;  /* @@@ add support for clr/set flags? */
      addtail(&gv->inputlist,&ifn->n);

      if ((c = getchr()) == ',')
        continue;
      back(1);
      if (c=='\0' || c==')')
        break;
    }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0xef1d
testl %eax, %eax
je 0xcd95
movq %rbx, (%rsp)
leaq 0x18(%rbx), %r14
pushq $0x28
popq %r15
pushq $0x18
popq %rbx
pushq $0x1
popq %rbp
callq 0xf12b
testq %rax, %rax
je 0xcd7c
movq %rax, %r12
movq %r15, %rdi
callq 0x6340
movq %rax, %r13
movq %r12, %rdi
callq 0x50e0
cmpq $0x3, %rax
jb 0xcd2d
cmpb $0x2d, (%r12)
jne 0xcd2d
cmpb $0x6c, 0x1(%r12)
movq %rbx, %rax
jne 0xcd30
callq 0x52a0
movq (%rax), %rax
incq %r12
movsbq 0x1(%r12), %rcx
incq %r12
testb $0x20, 0x1(%rax,%rcx,2)
jne 0xcd02
movl $0x1, 0x18(%r13)
movq (%rsp), %rax
movl 0x240(%rax), %eax
movl %eax, 0x1c(%r13)
pushq $0x20
popq %rax
jmp 0xcd30
movq %rbx, %rax
andl $0x0, (%r13,%rax)
movq %r12, %rdi
callq 0x63a1
movq %rax, 0x10(%r13)
andw $0x0, 0x24(%r13)
movq %r14, %rdi
movq %r13, %rsi
callq 0x6414
callq 0xf457
cmpb $0x2c, %al
je 0xccbb
movl %eax, %r12d
movl %ebp, %edi
callq 0xf4ac
cmpb $0x29, %r12b
je 0xcd7c
movzbl %r12b, %eax
testl %eax, %eax
jne 0xccbb
pushq $0x28
popq %rdi
pushq $0x29
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xefde
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/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
pushq $0x28
popq %rdi
callq 0xef1d
testl %eax, %eax
je 0xcde8
callq 0xe109
testq %rax, %rax
je 0xce1d
movq %rax, %r14
callq 0xf457
cmpb $0x3d, %al
jne 0xcdf0
cmpb $0x0, (%r14)
je 0xcdf0
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd9e1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x26c19(%rip), %rbx     # 0x33a10
callq 0xf90a
pushq $0x42
popq %rdi
pushq $0x3d
popq %rcx
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6c19
pushq $0x1
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf4ac
movq 0x26bec(%rip), %rbx     # 0x33a10
callq 0xf90a
pushq $0x4e
popq %rdi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6c19
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x28
popq %rdi
callq 0xef1d
testl %eax, %eax
je 0xce84
callq 0xf12b
testq %rax, %rax
je 0xce8a
movq %rax, %r14
pushq $0x18
popq %rdi
callq 0x6340
movq %rax, %r15
movq %r14, %rdi
callq 0x63a1
movq %rax, 0x10(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6414
jmp 0xcea5
popq %rbx
popq %r14
popq %r15
retq
movq 0x26b7f(%rip), %rbx     # 0x33a10
callq 0xf90a
pushq $0x4e
popq %rdi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6c19
pushq $0x28
popq %rdi
pushq $0x29
popq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xefde
// File: /workspace/github_c_makefile_star2_O2/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 0x26af1(%rip), %rax     # 0x339f8
testq %rax, %rax
je 0xcf12
movq 0x18(%rax), %r15
jmp 0xcf19
leaq 0x13cad(%rip), %r15     # 0x20bc6
movq 0x20(%r12), %rcx
addq %rbx, %rcx
movq %rcx, 0x20(%r12)
movq 0x18(%r12), %rax
addq 0x10(%r12), %rax
cmpq %rax, %rcx
jle 0xcf47
movq 0x8(%r12), %rsi
pushq $0x3f
popq %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6c19
cmpq %r12, %r14
je 0xcf80
addq 0x20(%r14), %rbx
movq %rbx, 0x20(%r14)
movq 0x18(%r14), %rax
addq 0x10(%r14), %rax
cmpq %rax, %rbx
jle 0xcf80
movq 0x8(%r14), %rsi
pushq $0x3f
popq %rdi
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6c19
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x5040
testq %rbx, %rbx
je 0xcfed
movq %rbx, %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0xcfde
callq 0x5040
addq $0x8, %r14
jmp 0xcfcb
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_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x269ef(%rip)     # 0x33a00
jne 0xd02a
callq 0xf4b7
movq %rax, 0x269e1(%rip)     # 0x33a00
callq 0xf90a
movl %eax, 0x269de(%rip)     # 0x33a08
andq $0x0, (%r14)
andq $0x0, (%rbx)
movl $0x2, 0x269d0(%rip)     # 0x33a0c
pushq $0x1
popq %rbp
callq 0xd0eb
testq %rax, %rax
je 0xd07a
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movl $0x8000, %edx           # imm = 0x8000
callq 0xd0f3
testl %eax, %eax
jne 0xd03f
callq 0xf457
cmpb $0x28, %al
je 0xd085
movzbl %al, %eax
cmpl $0x3d, %eax
jne 0xd09c
xorl %edi, %edi
callq 0xd1da
jmp 0xd03f
callq 0xf457
cmpb $0x3b, %al
je 0xd03f
jmp 0xd0c6
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xd1ff
testl %eax, %eax
je 0xd03f
jmp 0xd0da
movq 0x2696d(%rip), %r12     # 0x33a10
callq 0xf90a
pushq $0x41
popq %rdi
movq %r12, %rsi
movl %eax, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x6c19
movl %ebp, %edi
callq 0xf4ac
jmp 0xd03f
pushq $0x1
popq %rdi
callq 0xf4ac
movl $0x1, 0x26934(%rip)     # 0x33a0c
xorl %ebp, %ebp
movl %ebp, %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/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 %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x22397(%rip), %r15     # 0x2f4a0
movq -0x10(%r15), %rdi
testq %rdi, %rdi
je 0xd124
movq %rbx, %rsi
callq 0x5160
testl %eax, %eax
je 0xd12b
addq $0x18, %r15
jmp 0xd109
xorl %ebx, %ebx
jmp 0xd1cd
movl -0x8(%r15), %eax
testl %ebp, %eax
je 0xd148
movq (%r15), %rax
testq %rax, %rax
je 0xd198
movq %r14, %rdi
callq *%rax
pushq $0x1
popq %rbx
jmp 0xd1cd
testw %bp, %bp
js 0xd16f
movq 0x268bc(%rip), %r14     # 0x33a10
callq 0xf90a
pushq $0x6b
popq %rdi
movq %r14, %rsi
movl %eax, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x6c19
movl -0x8(%r15), %eax
btl $0xd, %eax
jae 0xd186
pushq $0x28
popq %rsi
pushq $0x29
popq %rdx
xorl %edi, %edi
callq 0xf476
movl -0x8(%r15), %eax
pushq $0x1
popq %rbx
btl $0xe, %eax
jae 0xd1cd
xorl %edi, %edi
callq 0xd1da
jmp 0xd1cd
movq 0x26871(%rip), %r14     # 0x33a10
callq 0xf90a
pushq $0x45
popq %rdi
movq %r14, %rsi
movl %eax, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x6c19
pushq $0x1
popq %rbx
testb $0x20, -0x7(%r15)
je 0xd1cd
pushq $0x28
popq %rsi
pushq $0x29
popq %rdx
xorl %edi, %edi
callq 0xf476
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/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 0xdf29
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x5160
testl %eax, %eax
jne 0xdf21
cmpq %r15, 0x10(%rbx)
jne 0xdf21
cmpq %r14, 0x18(%rbx)
je 0xdf2b
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0xdf05
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12d8a(%rip), %rsi     # 0x20cd5
pushq $0x7
popq %rdx
callq 0x5070
testl %eax, %eax
je 0xdf9a
leaq 0x12d7f(%rip), %rsi     # 0x20cdd
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x5070
testl %eax, %eax
je 0xdfa7
leaq 0x12d72(%rip), %rsi     # 0x20ce6
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0x5070
movl %eax, %ecx
xorl %edx, %edx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
leaq 0x12d63(%rip), %rcx     # 0x20cf4
cmoveq %rcx, %rdx
shll $0x2, %eax
jmp 0xdfb2
movw $0x3, %ax
leaq 0x12d47(%rip), %rdx     # 0x20cec
jmp 0xdfb2
movw $0x2, %ax
leaq 0x135ce(%rip), %rdx     # 0x21580
movq %rdx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x25733(%rip), %rax     # 0x339f8
testq %rax, %rax
je 0xe2d0
movq 0x18(%rax), %rdx
jmp 0xe2d7
leaq 0x128ef(%rip), %rdx     # 0x20bc6
movq %rcx, 0x20(%rdi)
movq 0x10(%rdi), %rax
cmpq %rcx, %rax
jg 0xe2ed
addq 0x18(%rdi), %rax
cmpq %rcx, %rax
jge 0xe2fb
movq 0x8(%rdi), %rsi
pushq $0x3f
popq %rdi
xorl %eax, %eax
jmp 0x6c19
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x28
popq %rdi
callq 0x6340
movq %rax, %r15
movq 0x25751(%rip), %rax     # 0x33a70
testq %rax, %rax
je 0xe331
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
jne 0xe324
jmp 0xe338
leaq 0x25738(%rip), %rcx     # 0x33a70
movq %r15, (%rcx)
andq $0x0, (%r15)
movq %r12, %rdi
callq 0x63a1
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_O2/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, %r13
movq %r8, %rbp
movl %ecx, %r15d
movl %edx, %ebx
movq %rsi, %r12
cmpl $0x6, %edx
jne 0xee1d
orl $0x10, %r15d
jmp 0xee58
movl %r15d, %eax
andl $0xc00, %eax            # imm = 0xC00
cmpw $0x800, %ax             # imm = 0x800
je 0xee32
cmpl $0x400, %eax            # imm = 0x400
jne 0xee58
movq 0x24bd7(%rip), %rbx     # 0x33a10
callq 0xf90a
xorl %r14d, %r14d
pushq $0x4d
popq %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x6c19
jmp 0xef0b
movq %rdi, (%rsp)
pushq $0x58
popq %rdi
callq 0x638a
movq %rax, %r14
movq %r12, %rdi
callq 0x63a1
movq %rax, 0x8(%r14)
movl %ebx, 0x20(%r14)
movw %r15w, 0x24(%r14)
movq %rbp, 0x30(%r14)
orq $-0x1, 0x28(%r14)
movq %r13, 0x10(%r14)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%r14)
cmpl $0x1, %ebx
jne 0xeec1
movq (%rsp), %rcx
cmpl $0x0, 0x7c(%rcx)
jne 0xeed0
movzbl 0x50(%rcx), %eax
leaq 0x202e4(%rip), %rcx     # 0x2f190
movq (%rcx,%rax,8), %rax
movl 0x98(%rax), %edi
callq 0x6a50
movq (%rsp), %rcx
jmp 0xeecc
movb $0x2, %al
cmpl $0x6, %ebx
movq (%rsp), %rcx
jne 0xeed0
movb %al, 0x26(%r14)
movq 0x1f8(%rcx), %rax
testq %rax, %rax
je 0xef04
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
je 0xeeff
cmpl $0x6, %ebx
jne 0xeedc
cmpl $0x6, 0x20(%rcx)
jne 0xeedc
movq %r14, %rdi
callq 0x5040
xorl %r14d, %r14d
jmp 0xef0b
movq %r14, (%rcx)
jmp 0xef0b
movq %r14, 0x1f8(%rcx)
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_O2/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, %ebx
callq 0xf457
cmpb %bl, %al
jne 0xef31
pushq $0x1
popq %rbx
jmp 0xef5b
movzbl %bl, %ebp
movq 0x24ad5(%rip), %r14     # 0x33a10
callq 0xf90a
xorl %ebx, %ebx
pushq $0x42
popq %rdi
movq %r14, %rsi
movl %eax, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x6c19
pushq $0x1
popq %rdi
callq 0xf4ac
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0xe109
testq %rax, %rax
je 0xefb7
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xb7e9
movq %rax, %r14
testq %rax, %rax
jne 0xefd5
movq 0x24a75(%rip), %r15     # 0x33a10
callq 0xf90a
xorl %r14d, %r14d
pushq $0x4f
popq %rdi
movq %r15, %rsi
movl %eax, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x6c19
jmp 0xefd5
movq 0x24a52(%rip), %rbx     # 0x33a10
callq 0xf90a
xorl %r14d, %r14d
pushq $0x4e
popq %rdi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6c19
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %ebp
movl %edi, %ebx
callq 0xf457
cmpb %bpl, %al
jne 0xeff8
pushq $0x1
popq %rbp
jmp 0xf02a
movq 0x24a11(%rip), %r14     # 0x33a10
callq 0xf90a
movsbl %bpl, %r15d
xorl %ebp, %ebp
pushq $0x42
popq %rdi
movq %r14, %rsi
movl %eax, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x6c19
movsbl %bl, %esi
pushq $0x1
popq %rdi
movl %r15d, %edx
callq 0xf476
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
andq $0x0, (%rsp)
callq 0xf457
cmpb $0x28, %al
jne 0xf0aa
pushq $-0x1
popq %rdi
movq %rsp, %rsi
callq 0xf5a5
testl %eax, %eax
jne 0xf072
movq 0x249b2(%rip), %rbx     # 0x33a10
callq 0xf90a
pushq $0x43
popq %rdi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6c19
callq 0xf457
cmpb $0x29, %al
je 0xf0c8
movq 0x2498e(%rip), %rbx     # 0x33a10
callq 0xf90a
pushq $0x42
popq %rdi
pushq $0x29
popq %rbp
movq %rbx, %rsi
movl %eax, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x6c19
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
movl %ebp, %edx
callq 0xf476
jmp 0xf0c8
movq 0x2495f(%rip), %rbx     # 0x33a10
callq 0xf90a
pushq $0x42
popq %rdi
pushq $0x28
popq %rcx
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6c19
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf10c
movq 0x24918(%rip), %r14     # 0x33a10
callq 0xf90a
pushq $0x47
popq %rdi
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6c19
movb %bpl, 0x203(%rbx)
movq 0x2494e(%rip), %rax     # 0x33a68
testq %rax, %rax
je 0xf126
movq %rax, 0x208(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf457
movl %eax, %ebx
pushq $0x1
popq %rdi
callq 0xf4ac
cmpb $0x22, %bl
jne 0xf146
popq %rbx
jmp 0xf52d
pushq $0x1b
popq %rdi
popq %rbx
jmp 0xf4bf
// File: /workspace/github_c_makefile_star2_O2/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 0x248f4(%rip), %rax     # 0x33a60
movq 0x48(%rax), %r12
movq %rsi, %rdi
callq 0x69ee
andl $0x1f, %eax
leaq (%r12,%rax,8), %r13
movq (%r13), %r12
testq %r12, %r12
je 0xf1cc
movq 0x20(%r12), %rsi
movq %r14, %rdi
callq 0x5160
addq $0x18, %r12
movq %r12, %r13
testl %eax, %eax
jne 0xf17f
movq 0x24869(%rip), %rbx     # 0x33a10
callq 0xf90a
pushq $0x6d
popq %rdi
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 0x6c19
pushq $0x50
popq %rdi
callq 0x638a
movq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa2f1
movzbl %bpl, %ecx
orb $0x4, %bpl
testl %eax, %eax
movzbl %bpl, %ebp
cmovel %ecx, %ebp
movq %r14, %rdi
callq 0x63a1
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 0xa32a
testl %eax, %eax
je 0xf249
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 0x6414
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_O2/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
andq $0x0, (%rsp)
callq 0xe109
testq %rax, %rax
je 0xf2c1
movq %rax, %r14
callq 0x5030
movq (%rax), %rax
movzbl (%r14), %ecx
movsbl (%rbx), %edx
cmpl %edx, (%rax,%rcx,4)
jne 0xf2c1
callq 0xf457
cmpb $0x3d, %al
jne 0xf2eb
pushq $-0x1
popq %rdi
movq %rsp, %rsi
callq 0xf5a5
testl %eax, %eax
jne 0xf2df
movq 0x24765(%rip), %rbx     # 0x33a10
callq 0xf90a
pushq $0x43
popq %rdi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6c19
jmp 0xf2df
movq 0x24748(%rip), %r14     # 0x33a10
callq 0xf90a
pushq $0x44
popq %rdi
movq %r14, %rsi
movl %eax, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x6c19
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2471e(%rip), %rbx     # 0x33a10
callq 0xf90a
pushq $0x42
popq %rdi
pushq $0x3d
popq %rcx
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6c19
jmp 0xf2df
// File: /workspace/github_c_makefile_star2_O2/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 0xdee8
testq %rax, %rax
je 0xf34c
cmpl $0x0, 0x20(%rax)
je 0xf33f
orb $0x10, 0x24(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r15, (%rsp)
pushq $-0x1
popq %r8
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
movq %rbx, %r9
callq 0xedf9
testq %rax, %rax
jne 0xf33b
jmp 0xf33f
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0xf3b4
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rbp
movq (%r15), %rdi
testq %rdi, %rdi
je 0xf3b4
movq %r14, %rsi
callq 0xf370
addq $0x8, %r15
testl %eax, %eax
je 0xf39a
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x246b4(%rip), %rdi     # 0x33a80
callq 0xf424
movq %rax, 0x246a8(%rip)     # 0x33a80
cmpb $0x2f, (%rax)
jne 0xf422
cmpb $0x2a, 0x1(%rax)
jne 0xf422
movl 0x2469f(%rip), %ecx     # 0x33a88
addq $0x4, %rax
movzbl -0x2(%rax), %edx
cmpl $0xa, %edx
je 0xf409
cmpl $0x2a, %edx
je 0xf401
testl %edx, %edx
jne 0xf411
jmp 0xf416
cmpb $0x2f, -0x1(%rax)
jne 0xf411
jmp 0xf416
incl %ecx
movl %ecx, 0x24677(%rip)     # 0x33a88
incq %rax
jmp 0xf3ed
movq %rax, 0x24663(%rip)     # 0x33a80
movq %rax, %rdi
jmp 0xf3cc
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x52a0
movq (%rax), %rax
movl 0x24652(%rip), %ecx     # 0x33a88
movzbl (%rbx), %edx
testb $0x20, 0x1(%rax,%rdx,2)
je 0xf452
cmpb $0xa, %dl
jne 0xf44d
incl %ecx
movl %ecx, 0x2463b(%rip)     # 0x33a88
incq %rbx
jmp 0xf436
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/expr.c
// Function: getchr
char getchr(void)
{
  char c;

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

// Assembly:
pushq %rax
callq 0xf3c4
movq 0x2461c(%rip), %rcx     # 0x33a80
movb (%rcx), %al
testb %al, %al
je 0xf474
incq %rcx
movq %rcx, 0x2460c(%rip)     # 0x33a80
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf457
testb %al, %al
je 0xf4a7
cmpb %bpl, %al
je 0xf4a2
cmpb %bl, %al
jne 0xf481
leal -0x1(%r14), %eax
cmpl $0x1, %r14d
movl %eax, %r14d
jg 0xf481
jmp 0xf4a7
incl %r14d
jmp 0xf481
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf3c4
movq 0x24546(%rip), %rcx     # 0x33a80
cmpb $0x22, (%rcx)
jne 0xf595
leaq 0x1(%rcx), %rax
movq %rax, 0x24536(%rip)     # 0x33a80
addq $0x2, %rcx
xorl %edx, %edx
leaq 0x24639(%rip), %rax     # 0x33b90
movl $0xff, %edi
leaq (%rax,%rdi), %rsi
leaq (%rax,%rdx), %r8
movzbl -0x1(%rcx), %r9d
testl %r9d, %r9d
je 0xf59f
movq %rcx, 0x2450b(%rip)     # 0x33a80
cmpl $0x22, %r9d
je 0xf59f
cmpl $0xa, %r9d
je 0xf599
movb %r9b, (%rdx,%rax)
incq %rdx
incq %rcx
cmpq %rdi, %rdx
jne 0xf560
movq %rsi, %r8
jmp 0xf59f
xorl %eax, %eax
jmp 0xf5a3
incl 0x244e9(%rip)           # 0x33a88
movb $0x0, (%r8)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq 0x246da(%rip), %r15     # 0x33c90
movq %rdi, 0x246d3(%rip)     # 0x33c90
callq 0xf3c4
callq 0xf602
movq %rax, %rbx
cmpq $-0x2, 0x246be(%rip)    # 0x33c90
jne 0xf5d9
pushq $0x1
popq %rbp
jmp 0xf5e6
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf665
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf8e5
movq %r15, 0x2469b(%rip)     # 0x33c90
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf92d
movq %rax, %rbx
callq 0xf3c4
movq 0x24466(%rip), %rax     # 0x33a80
cmpb $0x7c, (%rax)
jne 0xf65a
cmpb $0x7c, 0x1(%rax)
jne 0xf65a
addq $0x2, %rax
movq %rax, 0x24450(%rip)     # 0x33a80
callq 0xf3c4
callq 0xf990
movq %rax, %r14
movl $0x8, (%rax)
callq 0xf3c4
movq %rbx, 0x8(%r14)
callq 0xf92d
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0xf613
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf909
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xf8e5
movq 0x10(%rbx), %rdi
callq 0xf8e5
movq %rbx, %rdi
popq %rbx
jmp 0x5040
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf9a2
movq %rax, %rbx
callq 0xf3c4
movq 0x2413b(%rip), %rax     # 0x33a80
cmpb $0x26, (%rax)
jne 0xf985
cmpb $0x26, 0x1(%rax)
jne 0xf985
addq $0x2, %rax
movq %rax, 0x24125(%rip)     # 0x33a80
callq 0xf3c4
callq 0xf990
movq %rax, %r14
movl $0x7, (%rax)
callq 0xf3c4
movq %rbx, 0x8(%r14)
callq 0xf9a2
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0xf93e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfa04
movq %rax, %rbx
callq 0xf3c4
movq 0x240c6(%rip), %rax     # 0x33a80
cmpb $0x7c, (%rax)
jne 0xf9f9
cmpb $0x7c, 0x1(%rax)
je 0xf9f9
incq %rax
movq %rax, 0x240b1(%rip)     # 0x33a80
callq 0xf3c4
callq 0xf990
movq %rax, %r14
movl $0xa, (%rax)
callq 0xf3c4
movq %rbx, 0x8(%r14)
callq 0xfa04
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0xf9b3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfa60
movq %rax, %rbx
callq 0xf3c4
movq 0x24064(%rip), %rax     # 0x33a80
cmpb $0x5e, (%rax)
jne 0xfa55
incq %rax
movq %rax, 0x24055(%rip)     # 0x33a80
callq 0xf3c4
callq 0xf990
movq %rax, %r14
movl $0xb, (%rax)
callq 0xf3c4
movq %rbx, 0x8(%r14)
callq 0xfa60
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0xfa15
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfac2
movq %rax, %rbx
callq 0xf3c4
movq 0x24008(%rip), %rax     # 0x33a80
cmpb $0x26, (%rax)
jne 0xfab7
cmpb $0x26, 0x1(%rax)
je 0xfab7
incq %rax
movq %rax, 0x23ff3(%rip)     # 0x33a80
callq 0xf3c4
callq 0xf990
movq %rax, %r14
movl $0x9, (%rax)
callq 0xf3c4
movq %rbx, 0x8(%r14)
callq 0xfac2
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0xfa71
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfb33
movq %rax, %rbx
callq 0xf3c4
movq 0x23fa6(%rip), %rax     # 0x33a80
movzbl (%rax), %ebp
cmpl $0x3d, %ebp
je 0xfae7
cmpl $0x21, %ebp
jne 0xfb2b
cmpb $0x3d, 0x1(%rax)
jne 0xfb2b
addq $0x2, %rax
movq %rax, 0x23f88(%rip)     # 0x33a80
callq 0xf3c4
callq 0xf990
movq %rax, %r14
xorl %eax, %eax
cmpb $0x21, %bpl
setne %al
addl $0x13, %eax
movl %eax, (%r14)
callq 0xf3c4
movq %rbx, 0x8(%r14)
callq 0xfb33
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0xfad3
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfbd4
movq %rax, %rbx
callq 0xf3c4
xorl %ebp, %ebp
pushq $0x3d
popq %r15
movq 0x23f2b(%rip), %rax     # 0x33a80
movzbl (%rax), %r12d
movl %r12d, %ecx
orl $0x2, %ecx
cmpl $0x3e, %ecx
jne 0xfbc8
movb 0x1(%rax), %cl
cmpb %r12b, %cl
je 0xfbc8
leaq 0x1(%rax), %rdx
addq $0x2, %rax
cmpb $0x3d, %cl
cmovneq %rdx, %rax
movzbl %bpl, %ebp
cmovel %r15d, %ebp
movq %rax, 0x23ef6(%rip)     # 0x33a80
callq 0xf3c4
callq 0xf990
movq %rax, %r14
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 0xf3c4
movq %rbx, 0x8(%r14)
callq 0xfbd4
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0xfb4e
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfc40
movq %rax, %rbx
callq 0xf3c4
movq 0x23e94(%rip), %rax     # 0x33a80
movzbl (%rax), %ebp
movl %ebp, %ecx
orl $0x2, %ecx
cmpl $0x3e, %ecx
jne 0xfc38
cmpb %bpl, 0x1(%rax)
jne 0xfc38
addq $0x2, %rax
movq %rax, 0x23e76(%rip)     # 0x33a80
callq 0xf3c4
callq 0xf990
movq %rax, %r14
xorl %eax, %eax
cmpb $0x3c, %bpl
setne %al
addl $0xd, %eax
movl %eax, (%r14)
movq %rbx, 0x8(%r14)
callq 0xfc40
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0xfbe0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfca2
movq %rax, %rbx
callq 0xf3c4
movq 0x23e28(%rip), %rax     # 0x33a80
movzbl (%rax), %ebp
cmpl $0x2d, %ebp
je 0xfc65
cmpl $0x2b, %ebp
jne 0xfc9a
incq %rax
movq %rax, 0x23e11(%rip)     # 0x33a80
callq 0xf3c4
callq 0xf990
movq %rax, %r14
xorl %eax, %eax
cmpb $0x2b, %bpl
setne %al
movl %eax, (%r14)
movq %rbx, 0x8(%r14)
callq 0xfca2
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0xfc4c
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfd26
movq %rax, %rbx
movabsq $0x842000000000, %r15   # imm = 0x842000000000
pushq $0x2
popq %rbp
callq 0xf3c4
movq 0x23db5(%rip), %rax     # 0x33a80
movzbl (%rax), %r12d
cmpq $0x2f, %r12
ja 0xfd1a
btq %r12, %r15
jae 0xfd1a
incq %rax
movq %rax, 0x23d9b(%rip)     # 0x33a80
callq 0xf3c4
callq 0xf990
movq %rax, %r14
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 0xfd26
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0xfcbf
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x23d4f(%rip), %rax     # 0x33a80
movzbl (%rax), %r14d
cmpq $0x2d, %r14
ja 0xfd4b
movabsq $0x280200000000, %rcx   # imm = 0x280200000000
btq %r14, %rcx
jb 0xfd51
cmpl $0x7e, %r14d
jne 0xfd66
incq %rax
movq %rax, 0x23d25(%rip)     # 0x33a80
callq 0xf3c4
cmpb $0x2b, %r14b
jne 0xfd6f
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfda4
callq 0xf990
movq %rax, %rbx
cmpb $0x21, %r14b
pushq $0xc
popq %rax
pushq $0x6
popq %rcx
cmovel %eax, %ecx
cmpb $0x2d, %r14b
pushq $0x5
popq %rax
cmovnel %ecx, %eax
movl %eax, (%rbx)
callq 0xfda4
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq