LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_ataritos.c
// Function: writeexec
static void writeexec(struct GlobalVars *gv,FILE *f)
/* creates a TOS executable file (which is relocatable) */
{
  struct LinkedSection *sections[3];
  int nsyms = tos_initwrite(gv,sections);
  int i;

  tos_header(f,sections[0] ? sections[0]->size+sections[0]->gapsize : 0,
             sections[1] ? sections[1]->filesize : 0,
             (sections[2] ? sections[2]->size : 0) +
             (sections[1] ? sections[1]->gapsize : 0),
             (unsigned long)nsyms*sizeof(struct DRIsym),gv->tosflags);

  for (i=0; i<3; i++)
    calc_relocs(gv,sections[i]);

  if (sections[0])
    fwritex(f,sections[0]->data,sections[0]->size+sections[0]->gapsize);

  if (sections[1])
    fwritex(f,sections[1]->data,sections[1]->filesize);

  if (nsyms)
    tos_symboltable(gv,f,sections);

  tos_writerelocs(gv,f,sections);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x30290
movl %eax, 0x4c(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x2fe6c
movq 0x50(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x50(%rsp), %rcx
addq 0x58(%rcx), %rax
movq %rax, 0x38(%rsp)
jmp 0x2fe75
xorl %eax, %eax
movq %rax, 0x38(%rsp)
jmp 0x2fe75
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x2fe97
movq 0x58(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x2fea0
xorl %eax, %eax
movq %rax, 0x28(%rsp)
jmp 0x2fea0
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x2fec2
movq 0x60(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x2fecb
xorl %eax, %eax
movq %rax, 0x18(%rsp)
jmp 0x2fecb
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x2feed
movq 0x58(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2fef6
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x2fef6
movq 0x20(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
addq %rax, %rcx
movslq 0x4c(%rsp), %rax
imulq $0xe, %rax, %r8
movq 0x70(%rsp), %rax
movl 0x108(%rax), %eax
movl %eax, %r9d
callq 0x303f0
movl $0x0, 0x48(%rsp)
cmpl $0x3, 0x48(%rsp)
jge 0x2ff5e
movq 0x70(%rsp), %rdi
movslq 0x48(%rsp), %rax
movq 0x50(%rsp,%rax,8), %rsi
callq 0x114f0
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x2ff36
cmpq $0x0, 0x50(%rsp)
je 0x2ff8b
movq 0x68(%rsp), %rdi
movq 0x50(%rsp), %rax
movq 0x78(%rax), %rsi
movq 0x50(%rsp), %rax
movq 0x48(%rax), %rdx
movq 0x50(%rsp), %rax
addq 0x58(%rax), %rdx
callq 0x8470
cmpq $0x0, 0x58(%rsp)
je 0x2ffaf
movq 0x68(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x78(%rax), %rsi
movq 0x58(%rsp), %rax
movq 0x50(%rax), %rdx
callq 0x8470
cmpl $0x0, 0x4c(%rsp)
je 0x2ffca
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x304d0
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x2fff0
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_ataritos.c
// Function: tos_initwrite
static int tos_initwrite(struct GlobalVars *gv,
                         struct LinkedSection **sections)
/* find exactly one ST_CODE, ST_DATA and ST_UDATA section, which
   will become .text, .data and .bss,
   then count the number of symbol definitions and references */
{
  static const char *fn = "tos_initwrite(): ";
  struct LinkedSection *ls;
  struct Symbol *sym;
  struct Reloc *xref;
  int i,cnt;

  get_text_data_bss(gv,sections);

  /* count symbols and unresolved references */
  for (i=0,cnt=0; i<3; i++) {
    if (sections[i]) {
      for (sym=(struct Symbol *)sections[i]->symbols.first;
           sym->n.next!=NULL; sym=(struct Symbol *)sym->n.next) {
        if (!discard_symbol(gv,sym)) {
          ++cnt;
          if (strlen(sym->name) > DRI_NAMELEN)
            ++cnt;  /* extra symbol for long name */
        }
      }
      if (gv->dest_object) {
        for (xref=(struct Reloc *)sections[i]->xrefs.first;
             xref->n.next!=NULL; xref=(struct Reloc *)xref->n.next) {
          ++cnt;
          if (strlen(xref->xrefname) > DRI_NAMELEN)
            ++cnt;  /* extra symbol for long name */
        }
      }
    }
  }

  text_data_bss_gaps(sections);  /* calculate gap size between sections */

  return cnt;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x133b0
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
cmpl $0x3, 0xc(%rsp)
jge 0x303d4
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x303c2
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0xb0(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x30353
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x13660
cmpl $0x0, %eax
jne 0x30342
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x50c0
cmpq $0x8, %rax
jbe 0x30340
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x30342
jmp 0x30344
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x302f7
movq 0x30(%rsp), %rax
cmpl $0x0, 0x54(%rax)
je 0x303c0
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x98(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x303be
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x50c0
cmpq $0x8, %rax
jbe 0x303ad
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x303af
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x30378
jmp 0x303c0
jmp 0x303c2
jmp 0x303c4
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x302bd
movq 0x28(%rsp), %rdi
callq 0x13560
movl 0x8(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_ataritos.c
// Function: tos_header
static void tos_header(FILE *f,unsigned long tsize,unsigned long dsize,
                       unsigned long bsize,unsigned long ssize,
                       unsigned long flags)
{
  PH hdr;

  write16be(hdr.ph_branch,0x601a);
  write32be(hdr.ph_tlen,tsize);
  write32be(hdr.ph_dlen,dsize);
  write32be(hdr.ph_blen,bsize);
  write32be(hdr.ph_slen,ssize);
  write32be(hdr.ph_magic,0);
  write32be(hdr.ph_flags,flags);
  write16be(hdr.ph_abs,0);

  fwritex(f,&hdr,sizeof(PH));
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
leaq 0xc(%rsp), %rdi
movl $0x601a, %esi           # imm = 0x601A
callq 0x7ae0
leaq 0xc(%rsp), %rdi
addq $0x2, %rdi
movq 0x48(%rsp), %rax
movl %eax, %esi
callq 0x7b30
leaq 0xc(%rsp), %rdi
addq $0x6, %rdi
movq 0x40(%rsp), %rax
movl %eax, %esi
callq 0x7b30
leaq 0xc(%rsp), %rdi
addq $0xa, %rdi
movq 0x38(%rsp), %rax
movl %eax, %esi
callq 0x7b30
leaq 0xc(%rsp), %rdi
addq $0xe, %rdi
movq 0x30(%rsp), %rax
movl %eax, %esi
callq 0x7b30
leaq 0xc(%rsp), %rdi
addq $0x12, %rdi
xorl %esi, %esi
callq 0x7b30
leaq 0xc(%rsp), %rdi
addq $0x16, %rdi
movq 0x28(%rsp), %rax
movl %eax, %esi
callq 0x7b30
leaq 0xc(%rsp), %rdi
addq $0x1a, %rdi
xorl %esi, %esi
callq 0x7ae0
movq 0x50(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x1c, %edx
callq 0x8470
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_ataritos.c
// Function: write_dri_sym
static void write_dri_sym(FILE *f,const char *name,
                          uint16_t type,uint32_t value)
{
  struct DRIsym stab;
  int longname = strlen(name) > DRI_NAMELEN;

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

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

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

// Assembly:
subq $0x58, %rsp
movw %dx, %ax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movw %ax, 0x46(%rsp)
movl %ecx, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x50c0
cmpq $0x8, %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x2c(%rsp)
leaq 0x32(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl $0x8, %edx
callq 0x5040
leaq 0x32(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x3072b
movzwl 0x46(%rsp), %eax
orl $0x48, %eax
movl %eax, 0xc(%rsp)
jmp 0x30734
movzwl 0x46(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movzwl %ax, %esi
callq 0x7ae0
leaq 0x32(%rsp), %rdi
addq $0xa, %rdi
movl 0x40(%rsp), %esi
callq 0x7b30
movq 0x50(%rsp), %rdi
leaq 0x32(%rsp), %rsi
movl $0xe, %edx
callq 0x8470
cmpl $0x0, 0x2c(%rsp)
je 0x307af
leaq 0x1e(%rsp), %rdi
xorl %esi, %esi
movl $0xe, %edx
callq 0x5100
leaq 0x1e(%rsp), %rdi
movq 0x48(%rsp), %rsi
addq $0x8, %rsi
movl $0xe, %edx
callq 0x5040
movq 0x50(%rsp), %rdi
leaq 0x1e(%rsp), %rsi
movl $0xe, %edx
callq 0x8470
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_rawbin.c
// Function: ihex_write
static void ihex_write(struct GlobalVars *gv,FILE *f)
{
  bool firstsec = TRUE;
  struct LinkedSection *ls;
  unsigned long len,addr;
  uint8_t *p;

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

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

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

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

      if ((((unsigned long)addr)&0xffff)+nbytes > 0xffff)
        nbytes = 0x10000 - (((unsigned long)addr) & 0xffff);
      IHexOut(f,addr,p,nbytes);
      p += nbytes;
      addr += nbytes;
      len -= nbytes;
    }
  }

  fprintf(f,":00000001FF\n");
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl $0x1, 0x34(%rsp)
movq 0x40(%rsp), %rdi
callq 0x30ef0
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x30b13
movq 0x28(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x309dd
movq 0x28(%rsp), %rax
movzbl 0x21(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x309dd
movq 0x28(%rsp), %rax
movzwl 0x24(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x309df
jmp 0x30996
cmpl $0x0, 0x34(%rsp)
je 0x30a20
movq 0x40(%rsp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x30a18
movq 0x40(%rsp), %rax
movq 0xa0(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rdx
leaq 0x76ff(%rip), %rsi      # 0x38110
movb $0x0, %al
callq 0x5150
movl $0x0, 0x34(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x114f0
movq 0x28(%rsp), %rax
movq 0x78(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jbe 0x30b0e
cmpq $0x20, 0x20(%rsp)
jbe 0x30a78
movl $0x20, %eax
movq %rax, (%rsp)
jmp 0x30a81
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
movslq 0xc(%rsp), %rcx
addq %rcx, %rax
cmpq $0xffff, %rax           # imm = 0xFFFF
jbe 0x30abc
movq 0x18(%rsp), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
movl $0x10000, %eax          # imm = 0x10000
subq %rcx, %rax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq 0x313d0
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movslq 0xc(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movslq 0xc(%rsp), %rcx
movq 0x20(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x30a59
jmp 0x30996
movq 0x38(%rsp), %rdi
leaq 0x763e(%rip), %rsi      # 0x3815d
movb $0x0, %al
callq 0x5150
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_rawbin.c
// Function: shex1_write
static void shex1_write(struct GlobalVars *gv,FILE *f)
{
  bool firstsec = TRUE;
  struct LinkedSection *ls;
  unsigned long len,addr;
  uint8_t *p;

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

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

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

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

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

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl $0x1, 0x34(%rsp)
movq 0x40(%rsp), %rdi
callq 0x30ef0
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x30c89
movq 0x28(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x30b8d
movq 0x28(%rsp), %rax
movzbl 0x21(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x30b8d
movq 0x28(%rsp), %rax
movzwl 0x24(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x30b8f
jmp 0x30b46
cmpl $0x0, 0x34(%rsp)
je 0x30bd0
movq 0x40(%rsp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x30bc8
movq 0x40(%rsp), %rax
movq 0xa0(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rdx
leaq 0x754f(%rip), %rsi      # 0x38110
movb $0x0, %al
callq 0x5150
movl $0x0, 0x34(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x114f0
movq 0x28(%rsp), %rax
movq 0x78(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jbe 0x30c84
cmpq $0x20, 0x20(%rsp)
jbe 0x30c24
movl $0x20, %eax
movq %rax, (%rsp)
jmp 0x30c2d
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq 0x31550
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movslq 0xc(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movslq 0xc(%rsp), %rcx
movq 0x20(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x30c09
jmp 0x30b46
movq 0x38(%rsp), %rdi
leaq 0x74fc(%rip), %rsi      # 0x38191
movb $0x0, %al
callq 0x5150
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_rawbin.c
// Function: get_next_section
static struct LinkedSection *get_next_section(struct GlobalVars *gv)
/* returns pointer to next section with lowest base address */
{
  struct LinkedSection *ls = (struct LinkedSection *)gv->lnksec.first;
  struct LinkedSection *nextls,*minls = NULL;

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x1c0(%rax), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x30f64
cmpq $0x0, 0x8(%rsp)
je 0x30f4e
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x30f4c
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x30f58
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x30f13
cmpq $0x0, 0x8(%rsp)
je 0x30f76
movq 0x8(%rsp), %rdi
callq 0x7530
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_rawbin.c
// Function: SRecOut
static void SRecOut(FILE *f,int stype,uint8_t *buf,int len)
{
  uint8_t chksum = 0xff-len-1;

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl $0xff, %eax
subl 0xc(%rsp), %eax
subl $0x1, %eax
movb %al, 0xb(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl 0xc(%rsp), %ecx
addl $0x1, %ecx
leaq 0x6df7(%rip), %rsi      # 0x38154
movb $0x0, %al
callq 0x5150
cmpl $0x0, 0xc(%rsp)
jle 0x313b2
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl (%rax), %edx
leaq 0x6dd9(%rip), %rsi      # 0x38158
movb $0x0, %al
callq 0x5150
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movzbl (%rax), %ecx
movzbl 0xb(%rsp), %eax
subl %ecx, %eax
movb %al, 0xb(%rsp)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x31364
movq 0x20(%rsp), %rdi
movzbl 0xb(%rsp), %edx
leaq 0x6db8(%rip), %rsi      # 0x3817b
movb $0x0, %al
callq 0x5150
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_rawbin.c
// Function: IHexOut
static void IHexOut(FILE *f,unsigned long addr,uint8_t *buf,int len)
{
  static unsigned long hiaddr;
  uint8_t chksum;

  if (((addr&0xffff0000)>>16)!=hiaddr) {
    hiaddr = (addr&0xffff0000) >> 16;
    fprintf(f,":02000004%02X%02X%02X\n",
            (unsigned)(hiaddr>>8)&0xff,
            (unsigned)hiaddr&0xff,
            (unsigned)(-(2+4+(hiaddr>>8)+hiaddr))&0xff);
  }
  fprintf(f,":%02X%02X%02X00",
          (unsigned)len&0xff,(unsigned)(addr>>8)&0xff,(unsigned)addr&0xff);
  chksum = len + (addr>>8) + addr;
  for (; len>0; len--) {
    fprintf(f,"%02X",((unsigned)*buf)&0xff);
    chksum += *buf++;
  }
  fprintf(f,"%02X\n",(-chksum)&0xff);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movabsq $0xffff0000, %rax       # imm = 0xFFFF0000
andq 0x18(%rsp), %rax
shrq $0x10, %rax
cmpq 0x13b4f(%rip), %rax     # 0x44f50
je 0x31477
movabsq $0xffff0000, %rax       # imm = 0xFFFF0000
andq 0x18(%rsp), %rax
shrq $0x10, %rax
movq %rax, 0x13b33(%rip)     # 0x44f50
movq 0x20(%rsp), %rdi
movq 0x13b27(%rip), %rax     # 0x44f50
shrq $0x8, %rax
movl %eax, %edx
andl $0xff, %edx
movq 0x13b14(%rip), %rax     # 0x44f50
movl %eax, %ecx
andl $0xff, %ecx
movq 0x13b05(%rip), %rsi     # 0x44f50
shrq $0x8, %rsi
addq $0x6, %rsi
addq 0x13af6(%rip), %rsi     # 0x44f50
xorl %eax, %eax
subq %rsi, %rax
movl %eax, %r8d
andl $0xff, %r8d
leaq 0x6cfa(%rip), %rsi      # 0x3816a
movb $0x0, %al
callq 0x5150
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %edx
andl $0xff, %edx
movq 0x18(%rsp), %rax
shrq $0x8, %rax
movl %eax, %ecx
andl $0xff, %ecx
movq 0x18(%rsp), %rax
movl %eax, %r8d
andl $0xff, %r8d
leaq 0x6cd4(%rip), %rsi      # 0x38181
movb $0x0, %al
callq 0x5150
movslq 0xc(%rsp), %rax
movq 0x18(%rsp), %rcx
shrq $0x8, %rcx
addq %rcx, %rax
addq 0x18(%rsp), %rax
movb %al, 0xb(%rsp)
cmpl $0x0, 0xc(%rsp)
jle 0x31522
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl (%rax), %edx
andl $0xff, %edx
leaq 0x6c69(%rip), %rsi      # 0x38158
movb $0x0, %al
callq 0x5150
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movzbl (%rax), %ecx
movzbl 0xb(%rsp), %eax
addl %ecx, %eax
movb %al, 0xb(%rsp)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x314ce
movq 0x20(%rsp), %rdi
movzbl 0xb(%rsp), %eax
xorl %edx, %edx
subl %eax, %edx
andl $0xff, %edx
leaq 0x6c3e(%rip), %rsi      # 0x3817b
movb $0x0, %al
callq 0x5150
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_rawbin.c
// Function: SHex1Out
static void SHex1Out(FILE *f,unsigned long addr,uint8_t *buf,int len)
{
  int wordcnt=(len+3)/4;
  int i;

  fprintf(f,"%06lX %d",addr,wordcnt);

  for(i=0;i<len;i++){
    if((i&3)==0)
      fprintf(f," ");
    fprintf(f,"%02X",buf[i]);
  }
  for(i=0;i<wordcnt*4-len;i++)
    fprintf(f,"00");
  fprintf(f,"\n");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl $0x3, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl 0x8(%rsp), %ecx
leaq 0x6c0c(%rip), %rsi      # 0x3819b
movb $0x0, %al
callq 0x5150
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x315f5
movl 0x4(%rsp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x315c7
movq 0x20(%rsp), %rdi
leaq 0x44c2(%rip), %rsi      # 0x35a82
movb $0x0, %al
callq 0x5150
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0x6b77(%rip), %rsi      # 0x38158
movb $0x0, %al
callq 0x5150
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3159e
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl 0x8(%rsp), %ecx
shll $0x2, %ecx
subl 0xc(%rsp), %ecx
cmpl %ecx, %eax
jge 0x31630
movq 0x20(%rsp), %rdi
leaq 0x6b72(%rip), %rsi      # 0x3818e
movb $0x0, %al
callq 0x5150
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x315fd
movq 0x20(%rsp), %rdi
leaq 0x6d2a(%rip), %rsi      # 0x38366
movb $0x0, %al
callq 0x5150
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_vobj.c
// Function: vobj_readconv
static void vobj_readconv(struct GlobalVars *gv,struct LinkFile *lf)
{
  if (lf->type == ID_LIBARCH) {
    if (ar_init(&ai,(char *)lf->data,lf->length,lf->filename)) {
      while (ar_extract(&ai)) {
        lf->objname = allocstring(ai.name);
        vobj_read(gv,lf,(uint8_t *)ai.data);
      }
    }
    else
      ierror("vobj_readconv(): archive %s corrupted since last access",
             lf->pathname);
  }
  else {
    lf->objname = lf->filename;
    vobj_read(gv,lf,lf->data);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl 0x39(%rax), %eax
cmpl $0x8, %eax
jne 0x3174e
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
leaq 0x13876(%rip), %rdi     # 0x44f58
callq 0x13d60
cmpl $0x0, %eax
je 0x31735
jmp 0x316ee
leaq 0x13863(%rip), %rdi     # 0x44f58
callq 0x13e00
cmpl $0x0, %eax
je 0x31733
leaq 0x13852(%rip), %rdi     # 0x44f58
addq $0x20, %rdi
callq 0x72d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x13954(%rip), %rdx     # 0x45080
callq 0x31950
jmp 0x316ee
jmp 0x3174c
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x6b6b(%rip), %rdi      # 0x382b0
movb $0x0, %al
callq 0x8ae0
jmp 0x31778
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdx
callq 0x31950
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_vobj.c
// Function: vobj_identify
static int vobj_identify(char *name,uint8_t *p,unsigned long plen,uint8_t e)
{
  int id = ID_OBJECT;

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

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

  return ID_UNKNOWN;
}

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movb %al, 0x7(%rsp)
movl $0x1, (%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x136d2(%rip), %rdi     # 0x44f58
callq 0x13d60
cmpl $0x0, %eax
je 0x318db
movl $0x8, (%rsp)
leaq 0x136ba(%rip), %rdi     # 0x44f58
callq 0x13e00
cmpl $0x0, %eax
jne 0x318c3
movq 0x18(%rsp), %rsi
movl $0x26, %edi
movb $0x0, %al
callq 0x8c00
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x3193d
movq 0x137b6(%rip), %rax     # 0x45080
movq %rax, 0x10(%rsp)
movq 0x137b2(%rip), %rax     # 0x45088
movq %rax, 0x8(%rsp)
cmpq $0x4, 0x8(%rsp)
jbe 0x31935
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x56, %eax
jne 0x31935
movq 0x10(%rsp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x4f, %eax
jne 0x31935
movq 0x10(%rsp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x42, %eax
jne 0x31935
movq 0x10(%rsp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x4a, %eax
jne 0x31935
movq 0x10(%rsp), %rax
movzbl 0x4(%rax), %eax
movzbl 0x7(%rsp), %ecx
cmpl %ecx, %eax
jne 0x31935
movl (%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x3193d
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_vobj.c
// Function: read_number
static taddr read_number(void)
{
  taddr val;
  uint8_t n,*q;
  int size;

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

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

// Assembly:
subq $0x28, %rsp
movq 0x13195(%rip), %rax     # 0x45090
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x13187(%rip)     # 0x45090
movb (%rax), %al
movb %al, 0x17(%rsp)
movzbl %al, %eax
cmpl $0x7f, %eax
jg 0x31f26
movzbl 0x17(%rsp), %eax
movq %rax, 0x20(%rsp)
jmp 0x31fc8
movq $0x0, 0x18(%rsp)
movzbl 0x17(%rsp), %eax
subl $0x80, %eax
movb %al, 0x17(%rsp)
cmpb $0x0, %al
je 0x31fbe
movzbl 0x17(%rsp), %eax
shll $0x3, %eax
movl %eax, 0x4(%rsp)
movzbl 0x17(%rsp), %ecx
movq 0x13137(%rip), %rax     # 0x45090
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x1312a(%rip)     # 0x45090
movq 0x13123(%rip), %rax     # 0x45090
movq %rax, 0x8(%rsp)
movb 0x17(%rsp), %al
movb %al, %cl
addb $-0x1, %cl
movb %cl, 0x17(%rsp)
cmpb $0x0, %al
je 0x31fab
movq 0x18(%rsp), %rax
shlq $0x8, %rax
movq 0x8(%rsp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, 0x8(%rsp)
movzbl -0x1(%rcx), %ecx
orq %rcx, %rax
movq %rax, 0x18(%rsp)
jmp 0x31f72
movq 0x18(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x89f0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_vobj.c
// Function: read_symbol
static void read_symbol(struct vobj_symbol *vsym)
{
  vsym->name = (char *)p;
  skip_string();
  vsym->type = (int)read_number();
  vsym->flags = (int)read_number();
  vsym->sec = (int)read_number();
  vsym->val = read_number();
  vsym->size = (int)read_number();
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq 0x13064(%rip), %rcx     # 0x45090
movq (%rsp), %rax
movq %rcx, (%rax)
callq 0x31fe0
callq 0x31ef0
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
callq 0x31ef0
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0xc(%rax)
callq 0x31ef0
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x10(%rax)
callq 0x31ef0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
callq 0x31ef0
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x14(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/example3.c
// Function: main
int main(int argc, char *argv[])
{
    te_variable vars[] = {
        {"mysum", my_sum, TE_FUNCTION2}
    };

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

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

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


    return 0;
}

// Assembly:
subq $0x58, %rsp
movl $0x0, 0x54(%rsp)
movl %edi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x4884(%rip), %rax      # 0x5a90
movq %rax, 0x20(%rsp)
movq 0x4880(%rip), %rax      # 0x5a98
movq %rax, 0x28(%rsp)
movq 0x487c(%rip), %rax      # 0x5aa0
movq %rax, 0x30(%rsp)
movq 0x4878(%rip), %rax      # 0x5aa8
movq %rax, 0x38(%rsp)
leaq 0x2df1(%rip), %rax      # 0x402d
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
leaq 0x2dec(%rip), %rdi      # 0x4039
movb $0x0, %al
callq 0x1060
movq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x1, %edx
leaq 0x14(%rsp), %rcx
callq 0x2530
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x12a8
movq 0x8(%rsp), %rdi
callq 0x1990
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
leaq 0x2db5(%rip), %rdi      # 0x404a
movb $0x1, %al
callq 0x1060
movq 0x8(%rsp), %rdi
callq 0x1380
jmp 0x12c4
movl 0x14(%rsp), %esi
subl $0x1, %esi
leaq 0x2da1(%rip), %rdi      # 0x4057
leaq 0x2d69(%rip), %rdx      # 0x4026
movb $0x0, %al
callq 0x1060
xorl %eax, %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/demo/paint.c
// Function: updateAndRedrawAll
void updateAndRedrawAll(int mx, int my) {
    tb_clear();
    if (mx != -1 && my != -1) {
        backbuf[bbw*my+mx].ch = runes[curRune];
        backbuf[bbw*my+mx].fg = colors[curCol];
    }
    memcpy(tb_cell_buffer(), backbuf, sizeof(struct tb_cell)*bbw*bbh);
    int h = tb_height();
    updateAndDrawButtons(&curRune, 0, 0, mx, my, len(runes), runeAttrFunc);
    updateAndDrawButtons(&curCol, 0, h-3, mx, my, len(colors), colorAttrFunc);
    tb_present();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
callq 0x4f80
cmpl $-0x1, -0x4(%rbp)
je 0x36e8
cmpl $-0x1, -0x8(%rbp)
je 0x36e8
movslq 0x72ba(%rip), %rcx      # 0xa950
leaq 0x3973(%rip), %rax      # 0x7010
movl (%rax,%rcx,4), %edx
movq 0x72b1(%rip), %rax      # 0xa958
movl 0x72b3(%rip), %ecx      # 0xa960
imull -0x8(%rbp), %ecx
addl -0x4(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,8)
movslq 0x72a3(%rip), %rcx      # 0xa964
leaq 0x3968(%rip), %rax      # 0x7030
movw (%rax,%rcx,2), %dx
movq 0x7285(%rip), %rax      # 0xa958
movl 0x7287(%rip), %ecx      # 0xa960
imull -0x8(%rbp), %ecx
addl -0x4(%rbp), %ecx
movslq %ecx, %rcx
movw %dx, 0x4(%rax,%rcx,8)
callq 0x4b80
movq %rax, %rdi
movq 0x7261(%rip), %rsi      # 0xa958
movslq 0x7262(%rip), %rdx      # 0xa960
shlq $0x3, %rdx
movslq 0x725f(%rip), %rax      # 0xa968
imulq %rax, %rdx
callq 0x3180
callq 0x4f70
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %ecx
movl -0x8(%rbp), %r8d
leaq 0x7228(%rip), %rdi      # 0xa950
xorl %edx, %edx
movl $0x5, %r9d
leaq -0x147(%rip), %rax      # 0x35f0
movl %edx, %esi
movq %rax, (%rsp)
callq 0x3370
movl -0xc(%rbp), %edx
subl $0x3, %edx
movl -0x4(%rbp), %ecx
movl -0x8(%rbp), %r8d
leaq 0x720e(%rip), %rdi      # 0xa964
xorl %esi, %esi
movl $0x8, %r9d
leaq -0x135(%rip), %rax      # 0x3630
movq %rax, (%rsp)
callq 0x3370
callq 0x42a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/demo/paint.c
// Function: reallocBackBuffer
void reallocBackBuffer(int w, int h) {
    bbw = w;
    bbh = h;
    if (backbuf)
        free(backbuf);
    backbuf = calloc(sizeof(struct tb_cell), w*h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x71c9(%rip)      # 0xa960
movl -0x8(%rbp), %eax
movl %eax, 0x71c8(%rip)      # 0xa968
cmpq $0x0, 0x71b0(%rip)      # 0xa958
je 0x37b6
movq 0x71a7(%rip), %rdi      # 0xa958
callq 0x3040
movl -0x4(%rbp), %eax
imull -0x8(%rbp), %eax
movslq %eax, %rsi
movl $0x8, %edi
callq 0x3150
movq %rax, 0x7187(%rip)      # 0xa958
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/demo/paint.c
// Function: main
int main(int argv, char **argc) {
    (void)argc; (void)argv;
    int code = tb_init();
    if (code < 0) {
        fprintf(stderr, "termbox init failed, code: %d\n", code);
        return -1;
    }

    tb_select_input_mode(TB_INPUT_ESC | TB_INPUT_MOUSE);
    int w = tb_width();
    int h = tb_height();
    reallocBackBuffer(w, h);
    updateAndRedrawAll(-1, -1);
    for (;;) {
        struct tb_event ev;
        int mx = -1;
        int my = -1;
        int t = tb_poll_event(&ev);
        if (t == -1) {
            tb_shutdown();
            fprintf(stderr, "termbox poll event error\n");
            return -1;
        }

        switch (t) {
        case TB_EVENT_KEY:
            if (ev.key == TB_KEY_ESC) {
                tb_shutdown();
                return 0;
            }
            break;
        case TB_EVENT_MOUSE:
            if (ev.key == TB_KEY_MOUSE_LEFT) {
                mx = ev.x;
                my = ev.y;
            }
            break;
        case TB_EVENT_RESIZE:
            reallocBackBuffer(ev.w, ev.h);
            break;
        }
        updateAndRedrawAll(mx, my);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x4010
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x382b
movq 0x67ed(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x3828(%rip), %rsi      # 0x7040
movb $0x0, %al
callq 0x3170
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3910
movl $0x5, %edi
callq 0x4fb0
callq 0x4f60
movl %eax, -0x18(%rbp)
callq 0x4f70
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0x3780
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %esi, %edi
callq 0x3670
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
leaq -0x34(%rbp), %rdi
callq 0x4b90
movl %eax, -0x40(%rbp)
cmpl $-0x1, -0x40(%rbp)
jne 0x38a2
callq 0x4030
movq 0x6770(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x37cd(%rip), %rsi      # 0x705f
movb $0x0, %al
callq 0x3170
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3910
movl -0x40(%rbp), %eax
movl %eax, -0x44(%rbp)
subl $0x1, %eax
je 0x38c3
jmp 0x38af
movl -0x44(%rbp), %eax
subl $0x2, %eax
je 0x38f5
jmp 0x38b9
movl -0x44(%rbp), %eax
subl $0x3, %eax
je 0x38dc
jmp 0x3900
movzwl -0x32(%rbp), %eax
cmpl $0x1b, %eax
jne 0x38da
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0x3910
jmp 0x3900
movzwl -0x32(%rbp), %eax
cmpl $0xffe9, %eax           # imm = 0xFFE9
jne 0x38f3
movl -0x24(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x3900
movl -0x2c(%rbp), %edi
movl -0x28(%rbp), %esi
callq 0x3780
movl -0x38(%rbp), %edi
movl -0x3c(%rbp), %esi
callq 0x3670
jmp 0x385c
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_02/atof.c
// Function: main
int main(void)
{
  char line[MAXLEN];

  get_line(line, MAXLEN);
  printf("%s", line);

  printf("%f", atof(line));

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movl $0x0, -0x4(%rbp)
leaq -0x200(%rbp), %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x11c0
leaq -0x200(%rbp), %rsi
leaq 0xe87(%rip), %rdi       # 0x2018
movb $0x0, %al
callq 0x1030
leaq -0x200(%rbp), %rdi
callq 0x1260
leaq 0xe70(%rip), %rdi       # 0x201b
movb $0x1, %al
callq 0x1030
xorl %eax, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_02/atof.c
// Function: get_line
int get_line(char line[], unsigned int max_line_len)
{
  int i = 0, c;

  while (i < max_line_len - 1 && (c = getchar()) != '\n')
  {
    line[i] = c;
    ++i;
  }

  if (c == '\n')
  {
    line[i++] = c;
  }

  line[i] = '\0';

  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
jae 0x11f9
callq 0x1040
movl %eax, -0x14(%rbp)
cmpl $0xa, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x1202
jmp 0x121d
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11d6
cmpl $0xa, -0x14(%rbp)
jne 0x123d
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_02/loop.c
// Function: main
int main(void)
{
  char s[MAXLINE];

  // int i;
  // int c;
  // for (i = 0; (i < MAXLINE - 1) * ((c = getchar()) != '\n') * (c != EOF); ++i)
  // {
  //   s[i] = c;
  // }

  int i = 0;
  int loop = 1;
  while (loop)
  {
    char c = getchar();

    if (i >= (MAXLINE - 1) || c == '\n' || c == EOF)
    {
      loop = 0;
    }

    s[i++] = c;
  }

  s[i] = '\0';

  printf("%s", s);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp            # imm = 0x400
movl $0x0, -0x4(%rbp)
movl $0x0, -0x3f4(%rbp)
movl $0x1, -0x3f8(%rbp)
cmpl $0x0, -0x3f8(%rbp)
je 0x11da
callq 0x1040
movb %al, -0x3f9(%rbp)
cmpl $0x3e7, -0x3f4(%rbp)    # imm = 0x3E7
jge 0x11ae
movsbl -0x3f9(%rbp), %eax
cmpl $0xa, %eax
je 0x11ae
movsbl -0x3f9(%rbp), %eax
cmpl $-0x1, %eax
jne 0x11b8
movl $0x0, -0x3f8(%rbp)
movb -0x3f9(%rbp), %cl
movl -0x3f4(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x3f4(%rbp)
cltq
movb %cl, -0x3f0(%rbp,%rax)
jmp 0x1176
movslq -0x3f4(%rbp), %rax
movb $0x0, -0x3f0(%rbp,%rax)
leaq -0x3f0(%rbp), %rsi
leaq 0xe0d(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/scca/scca.c
// Function: cipher_init
static void cipher_init(void)
{
  unsigned char c;

  setlocale(LC_ALL, "");

  allowed_char_len = 0;
  for (c = 0; c < UCHAR_MAX; c++) {
    if (isupper(c)) {
      allowed_char[c] = allowed_char_len;
      allowed_char_len++;
    } else {
      allowed_char[c] = -1;
    }
    cipher[c] = ' ';
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x6, %edi
leaq 0x1a65(%rip), %rsi      # 0x3019
callq 0x1120
movl $0x0, 0x3b41(%rip)      # 0x5104
movb $0x0, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0xff, %eax
jge 0x1645
callq 0x11a0
movq (%rax), %rax
movzbl -0x1(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x1616
movl 0x3b0f(%rip), %edx      # 0x5104
movzbl -0x1(%rbp), %eax
movl %eax, %ecx
leaq 0x3c0e(%rip), %rax      # 0x5210
movl %edx, (%rax,%rcx,4)
movl 0x3af9(%rip), %eax      # 0x5104
addl $0x1, %eax
movl %eax, 0x3af0(%rip)      # 0x5104
jmp 0x162a
movzbl -0x1(%rbp), %eax
movl %eax, %ecx
leaq 0x3bed(%rip), %rax      # 0x5210
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movzbl -0x1(%rbp), %eax
movl %eax, %ecx
leaq 0x3ad9(%rip), %rax      # 0x5110
movb $0x20, (%rax,%rcx)
movb -0x1(%rbp), %al
addb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x15c7
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/scca/scca.c
// Function: text_read
static int text_read(char *filename)
{
  int c, n;
  FILE *fh;

  fh = fopen(filename, "r");
  if (! fh) {
    fprintf(stderr, "fopen() failed on file: %s\n", filename);
    return 1;
  }

  setlocale(LC_ALL, "");

  n = 0;
  while ((c = fgetc(fh)) != EOF) {
    if (n > TEXT_MAX)
      break;
    if (c == '\r')
      continue; /* CR causes issues, just strip it. */
    text[n] = toupper(c);
    n++;
  }

  fclose(fh);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x19b3(%rip), %rsi      # 0x301a
callq 0x1130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x169c
movq 0x397a(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1990(%rip), %rsi      # 0x301c
movb $0x0, %al
callq 0x1100
movl $0x1, -0x4(%rbp)
jmp 0x170b
movl $0x6, %edi
leaq 0x1971(%rip), %rsi      # 0x3019
callq 0x1120
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10c0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x16fb
cmpl $0x10000, -0x18(%rbp)   # imm = 0x10000
jle 0x16d0
jmp 0x16fb
cmpl $0xd, -0x14(%rbp)
jne 0x16d8
jmp 0x16b4
movl -0x14(%rbp), %edi
callq 0x1050
movb %al, %dl
movslq -0x18(%rbp), %rcx
leaq 0x3f23(%rip), %rax      # 0x5610
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x16b4
movq -0x20(%rbp), %rdi
callq 0x1070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/scca/scca.c
// Function: screen_init
static void screen_init(void)
{
  initscr();
  atexit((void *)endwin);
  noecho();
  keypad(stdscr, TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x10a0
movq 0x38b8(%rip), %rdi      # 0x4fe8
callq 0x20c0
callq 0x1080
movq 0x388f(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x10d0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/scca/scca.c
// Function: screen_resize
static void screen_resize(void)
{
  endwin(); /* To get new window limits. */
  screen_update();
  flushinp();
  keypad(stdscr, TRUE);
  cipher_pos = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x11b0
callq 0x1750
callq 0x1040
movq 0x34d6(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x10d0
movl $0x0, 0x35ef(%rip)      # 0x5100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/scca/scca.c
// Function: display_help
static void display_help(void)
{
  erase();
  mvprintw(0,  0, "Left:        Move cipher cursor left.");
  mvprintw(1,  0, "Right:       Move ciiper cursor right.");
  mvprintw(2,  0, "Up:          Scroll one line up.");
  mvprintw(3,  0, "Down:        Scroll one line down.");
  mvprintw(4,  0, "Page Up:     Scroll %d lines up.", PAGE_OFFSET_SKIP);
  mvprintw(5,  0, "Page Down:   Scroll %d lines down.", PAGE_OFFSET_SKIP);
  mvprintw(6,  0, "Space:       Erase cipher character.");
  mvprintw(7,  0, "[A-Z]:       Insert cipher character.");
  mvprintw(8,  0, "F1 / F5:     Display this help.");
  mvprintw(9,  0, "F2 / F6:     Display character frequency.");
  mvprintw(10, 0, "F3 / F7:     Reset cipher. (Erase all.)");
  mvprintw(11, 0, "F4 / F8:     Save deciphered text to file.");
  mvprintw(12, 0, "F10:         Quit");
  mvprintw(14, 0, "Press any key to contiue...");
  refresh();

  flushinp();
  getch(); /* Wait for keypress. */
  flushinp();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x34a5(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
callq 0x1030
xorl %esi, %esi
leaq 0x14fc(%rip), %rdx      # 0x3038
movl %esi, %edi
movb $0x0, %al
callq 0x1110
movl $0x1, %edi
xorl %esi, %esi
leaq 0x150b(%rip), %rdx      # 0x305e
movb $0x0, %al
callq 0x1110
movl $0x2, %edi
xorl %esi, %esi
leaq 0x151d(%rip), %rdx      # 0x3085
movb $0x0, %al
callq 0x1110
movl $0x3, %edi
xorl %esi, %esi
leaq 0x1529(%rip), %rdx      # 0x30a6
movb $0x0, %al
callq 0x1110
movl $0x4, %edi
xorl %esi, %esi
leaq 0x1537(%rip), %rdx      # 0x30c9
movl $0xa, %ecx
movb $0x0, %al
callq 0x1110
movl $0x5, %edi
xorl %esi, %esi
leaq 0x153e(%rip), %rdx      # 0x30ea
movl $0xa, %ecx
movb $0x0, %al
callq 0x1110
movl $0x6, %edi
xorl %esi, %esi
leaq 0x1547(%rip), %rdx      # 0x310d
movb $0x0, %al
callq 0x1110
movl $0x7, %edi
xorl %esi, %esi
leaq 0x1557(%rip), %rdx      # 0x3132
movb $0x0, %al
callq 0x1110
movl $0x8, %edi
xorl %esi, %esi
leaq 0x1568(%rip), %rdx      # 0x3158
movb $0x0, %al
callq 0x1110
movl $0x9, %edi
xorl %esi, %esi
leaq 0x1573(%rip), %rdx      # 0x3178
movb $0x0, %al
callq 0x1110
movl $0xa, %edi
xorl %esi, %esi
leaq 0x1588(%rip), %rdx      # 0x31a2
movb $0x0, %al
callq 0x1110
movl $0xb, %edi
xorl %esi, %esi
leaq 0x159b(%rip), %rdx      # 0x31ca
movb $0x0, %al
callq 0x1110
movl $0xc, %edi
xorl %esi, %esi
leaq 0x15b1(%rip), %rdx      # 0x31f5
movb $0x0, %al
callq 0x1110
movl $0xe, %edi
xorl %esi, %esi
leaq 0x15ae(%rip), %rdx      # 0x3207
movb $0x0, %al
callq 0x1110
movq 0x3369(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
callq 0x10b0
callq 0x1040
movq 0x3355(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
callq 0x1060
callq 0x1040
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/scca/scca.c
// Function: text_save
static void text_save(char *old_filename)
{
  int i;
  FILE *fh;
  static char new_filename[PATH_MAX];

  snprintf(new_filename, PATH_MAX, "%s.%s", old_filename, SAVE_EXTENSION);

  erase();

  fh = fopen(new_filename, "w");
  if (fh == NULL) {
    mvprintw(0, 0, "Could not open file for writing: %s", new_filename);
  } else {
    for (i = 0; i < TEXT_MAX; i++) {
      if (text[i] == '\0')
        break;
      fputc(cipher_applied(text[i]), fh);
    }
    mvprintw(0, 0, "Deciphered text saved to: %s", new_filename);
  }
  fclose(fh);

  mvprintw(1, 0, "Press any key to contiue...");
  refresh();

  flushinp();
  getch(); /* Wait for keypress. */
  flushinp();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
leaq 0x136e9(%rip), %rdi     # 0x15610
movl $0x1000, %esi           # imm = 0x1000
leaq 0x12f7(%rip), %rdx      # 0x322a
leaq 0x12f6(%rip), %r8       # 0x3230
movb $0x0, %al
callq 0x1090
movq 0x3088(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
callq 0x1030
leaq 0x136b9(%rip), %rdi     # 0x15610
leaq 0x12d7(%rip), %rsi      # 0x3235
callq 0x1130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1f89
xorl %esi, %esi
leaq 0x12c0(%rip), %rdx      # 0x3237
leaq 0x13692(%rip), %rcx     # 0x15610
movl %esi, %edi
movb $0x0, %al
callq 0x1110
jmp 0x1ff3
movl $0x0, -0xc(%rbp)
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jge 0x1fda
movslq -0xc(%rbp), %rcx
leaq 0x366c(%rip), %rax      # 0x5610
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x1faf
jmp 0x1fda
movslq -0xc(%rbp), %rcx
leaq 0x3656(%rip), %rax      # 0x5610
movzbl (%rax,%rcx), %edi
callq 0x2040
movzbl %al, %edi
movq -0x18(%rbp), %rsi
callq 0x10e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1f90
xorl %esi, %esi
leaq 0x1278(%rip), %rdx      # 0x325b
leaq 0x13626(%rip), %rcx     # 0x15610
movl %esi, %edi
movb $0x0, %al
callq 0x1110
movq -0x18(%rbp), %rdi
callq 0x1070
movl $0x1, %edi
xorl %esi, %esi
leaq 0x11fd(%rip), %rdx      # 0x3207
movb $0x0, %al
callq 0x1110
movq 0x2fb8(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
callq 0x10b0
callq 0x1040
movq 0x2fa4(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
callq 0x1060
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/scca/scca.c
// Function: cipher_applied
static unsigned char cipher_applied(unsigned char plain)
{
  unsigned char c;

  if (isupper(plain)) {
    c = allowed_char[plain];
    if (cipher[c] == ' ') {
      return plain;
    } else {
      return cipher[c];
    }
  } else {
    return plain;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
callq 0x11a0
movq (%rax), %rax
movzbl -0x2(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x20b1
movzbl -0x2(%rbp), %eax
movl %eax, %ecx
leaq 0x3198(%rip), %rax      # 0x5210
movl (%rax,%rcx,4), %eax
movb %al, -0x3(%rbp)
movzbl -0x3(%rbp), %eax
movl %eax, %ecx
leaq 0x3085(%rip), %rax      # 0x5110
movzbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x209c
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x20b7
movzbl -0x3(%rbp), %eax
movl %eax, %ecx
leaq 0x3067(%rip), %rax      # 0x5110
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x20b7
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq