LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/cff.c
// Function: cff_read_header
static int cff_read_header(CFF_FILE *cff) // {{{
{
  const char *buf=cff->font;
  if (cff->length<3) {
    fprintf(stderr,"Not a cff font / too short\n");
    return -1;
  }
  cff->majorVersion=cff_read_Card8(&buf);
  cff->minorVersion=cff_read_Card8(&buf);
  uint8_t hdrSize=cff_read_Card8(&buf);
  cff->absOffSize=cff_read_OffSize(&buf);

  if (hdrSize<4) {
    fprintf(stderr,"cff header not recognized\n");
    return -1;
  }
  if (cff->majorVersion!=1) {
    fprintf(stderr,"Unsupported cff font version\n");
    return -1;
  }
  assert(buf-cff->font<=hdrSize);
  return hdrSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x3, 0x8(%rax)
jae 0x86a6
movq 0x6957(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x23d4(%rip), %rsi      # 0xaa67
movb $0x0, %al
callq 0x4190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x877f
leaq -0x18(%rbp), %rdi
callq 0x8c20
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x14(%rax)
leaq -0x18(%rbp), %rdi
callq 0x8c20
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x15(%rax)
leaq -0x18(%rbp), %rdi
callq 0x8c20
movb %al, -0x19(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8c40
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movzbl -0x19(%rbp), %eax
cmpl $0x4, %eax
jge 0x8712
movq 0x68e8(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x2381(%rip), %rsi      # 0xaa83
movb $0x0, %al
callq 0x4190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x877f
movq -0x10(%rbp), %rax
movzbl 0x14(%rax), %eax
cmpl $0x1, %eax
je 0x8740
movq 0x68ba(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x236e(%rip), %rsi      # 0xaa9e
movb $0x0, %al
callq 0x4190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x877f
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movzbl -0x19(%rbp), %ecx
cmpq %rcx, %rax
jg 0x8759
jmp 0x8778
leaq 0x235c(%rip), %rdi      # 0xaabc
leaq 0x1956(%rip), %rsi      # 0xa0bd
movl $0x1da, %edx            # imm = 0x1DA
leaq 0x2360(%rip), %rcx      # 0xaad3
callq 0x40d0
movzbl -0x19(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/cff.c
// Function: cff_do_load
static int cff_do_load(CFF_FILE *cff,int pos) // {{{
{
  assert(cff);

  pos=cff_load_index(cff,pos,&cff->nameIndex);
  if (pos<0) {
    fprintf(stderr,"Could not load Name INDEX\n");
    return -1;
  }

  pos=cff_load_index(cff,pos,&cff->topDictIndex);
  if (pos<0) {
    fprintf(stderr,"Could not load Top Dict INDEX\n");
    return -1;
  }

  pos=cff_load_index(cff,pos,&cff->stringIndex);
  if (pos<0) {
    fprintf(stderr,"Could not load String INDEX\n");
    return -1;
  }

  pos=cff_load_index(cff,pos,&cff->globalSubrIndex);
  if (pos<0) {
    fprintf(stderr,"Could not load Global Subr INDEX\n");
    return -1;
  }

  // ? encodings (via topIndex)    - or: on first access
  // ? charsets (via topIndex)

  return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x87a8
jmp 0x87c7
leaq 0x1a1f(%rip), %rdi      # 0xa1ce
leaq 0x1907(%rip), %rsi      # 0xa0bd
movl $0x1e2, %edx            # imm = 0x1E2
leaq 0x2331(%rip), %rcx      # 0xaaf3
callq 0x40d0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
addq $0x20, %rdx
callq 0x8c90
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x8808
movq 0x67f5(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x231f(%rip), %rsi      # 0xab14
movb $0x0, %al
callq 0x4190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x88cb
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
addq $0x38, %rdx
callq 0x8c90
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x8849
movq 0x67b4(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x22f9(%rip), %rsi      # 0xab2f
movb $0x0, %al
callq 0x4190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x88cb
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
addq $0x50, %rdx
callq 0x8c90
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x8887
movq 0x6773(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x22d7(%rip), %rsi      # 0xab4e
movb $0x0, %al
callq 0x4190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x88cb
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
addq $0x68, %rdx
callq 0x8c90
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x88c5
movq 0x6735(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x22b6(%rip), %rsi      # 0xab6b
movb $0x0, %al
callq 0x4190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x88cb
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/cff.c
// Function: cff_close
void cff_close(CFF_FILE *cff) // {{{
{
  assert(cff);
  if (cff) {
    cff_index_free_data(&cff->globalSubrIndex);
    cff_index_free_data(&cff->stringIndex);
    cff_index_free_data(&cff->topDictIndex);
    cff_index_free_data(&cff->nameIndex);
    if (cff->flags&CFF_F_FREE_DATA) {
      free((char *)cff->font);
    }
    free(cff);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x88f5
jmp 0x8914
leaq 0x18d2(%rip), %rdi      # 0xa1ce
leaq 0x17ba(%rip), %rsi      # 0xa0bd
movl $0x25b, %edx            # imm = 0x25B
leaq 0x213d(%rip), %rcx      # 0xaa4c
callq 0x40d0
cmpq $0x0, -0x8(%rbp)
je 0x8973
movq -0x8(%rbp), %rdi
addq $0x68, %rdi
callq 0x8b70
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
callq 0x8b70
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x8b70
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x8b70
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x896a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4150
movq -0x8(%rbp), %rdi
callq 0x4150
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/cff.c
// Function: cff_load_file
CFF_FILE *cff_load_file(FILE *f) // {{{
{
#define BLOCKSIZE 1024
  char *buf=NULL;
  int pos=0,len=0;
  while (1) {
    if (pos>=len) {
      len+=BLOCKSIZE;
      char *tmp=realloc(buf,len);
      if (!tmp) {
        fprintf(stderr,"Bad alloc: %s\n", strerror(errno));
        free(buf);
        return NULL;
      }
      buf=tmp;
    }
    size_t res=fread(buf+pos,1,len-pos,f);
    if (res==0) {
      if (!feof(f)) {
        fprintf(stderr,"File read error: %s\n", strerror(errno));
        free(buf);
        return NULL;
      }
      break;
    }
    pos+=res;
  }
  return cff_load2(buf,pos,1);
#undef BLOCKSIZE
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x8a1a
movl -0x20(%rbp), %eax
addl $0x400, %eax            # imm = 0x400
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x41d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8a12
movq 0x660c(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x4030
movl (%rax), %edi
callq 0x4070
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x1878(%rip), %rsi      # 0xa26d
movb $0x0, %al
callq 0x4190
movq -0x18(%rbp), %rdi
callq 0x4150
movq $0x0, -0x8(%rbp)
jmp 0x8ac2
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
movslq %eax, %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x41a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x8a99
movq -0x10(%rbp), %rdi
callq 0x41b0
cmpl $0x0, %eax
jne 0x8a97
movq 0x6584(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
callq 0x4030
movl (%rax), %edi
callq 0x4070
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x1fba(%rip), %rsi      # 0xaa37
movb $0x0, %al
callq 0x4190
movq -0x18(%rbp), %rdi
callq 0x4150
movq $0x0, -0x8(%rbp)
jmp 0x8ac2
jmp 0x8aac
movq -0x30(%rbp), %rcx
movslq -0x1c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
jmp 0x89a2
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movl $0x1, %edx
callq 0x8580
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/cff.c
// Function: cff_load_filename
CFF_FILE *cff_load_filename(const char *filename) // {{{
{
  FILE *f=fopen(filename,"rb");
  if (!f) {
    fprintf(stderr,"Could not open \"%s\": %s\n", filename, strerror(errno));
    return NULL;
  }
  CFF_FILE *ret=cff_load_file(f);
  fclose(f);
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x16eb(%rip), %rsi      # 0xa1d2
callq 0x4140
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8b3c
movq 0x64e2(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x4030
movl (%rax), %edi
callq 0x4070
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0x1779(%rip), %rsi      # 0xa2a4
movb $0x0, %al
callq 0x4190
movq $0x0, -0x8(%rbp)
jmp 0x8b5a
movq -0x18(%rbp), %rdi
callq 0x8980
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4110
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/cff.c
// Function: cff_new
static CFF_FILE *cff_new() // {{{
{
  CFF_FILE *ret=calloc(1,sizeof(CFF_FILE));
  if (!ret) {
    fprintf(stderr,"Bad alloc: %s\n", strerror(errno));
  }
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x80, %esi
callq 0x40e0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8c11
movq 0x63f7(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x4030
movl (%rax), %edi
callq 0x4070
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x1663(%rip), %rsi      # 0xa26d
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/./cff_int.h
// Function: cff_read_OffSize
static inline CFF_OffSize cff_read_OffSize(const char **buf) // {{{
{
  uint8_t res=cff_read_Card8(buf);
  if ( (res<1)||(res>4) ) {
    return OFFERR;
  }
  return (CFF_OffSize)res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8c20
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x1, %eax
jl 0x8c6a
movzbl -0x11(%rbp), %eax
cmpl $0x4, %eax
jle 0x8c73
movl $0x0, -0x4(%rbp)
jmp 0x8c7a
movzbl -0x11(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/./cff_int.h
// Function: cff_read_Card16
static inline uint16_t cff_read_Card16(const char **buf) // {{{
{
  const char *b=*buf;
  uint16_t ret=((unsigned char)b[0]<<8)|((unsigned char)b[1]);
  (*buf)+=2;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movw -0x12(%rbp), %ax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/./cff_int.h
// Function: cff_read_Offset
static inline uint32_t cff_read_Offset(const char **buf,CFF_OffSize offSize) // {{{
{
  switch (offSize) {
  case 1:
    return cff_read_Card8(buf);
  case 2:
    return cff_read_Card16(buf);
  case 3:
    return cff_read_Card24(buf);
  case 4:
    return cff_read_Card32(buf);
  default:
    break;
  }
  assert(0);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x8ff1
movq -0x20(%rbp), %rax
leaq 0x185e(%rip), %rcx      # 0xa808
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0x8c20
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x9012
movq -0x10(%rbp), %rdi
callq 0x8f40
movzwl %ax, %eax
movl %eax, -0x4(%rbp)
jmp 0x9012
movq -0x10(%rbp), %rdi
callq 0x9020
movl %eax, -0x4(%rbp)
jmp 0x9012
movq -0x10(%rbp), %rdi
callq 0x9070
movl %eax, -0x4(%rbp)
jmp 0x9012
jmp 0x8ff3
leaq 0x2ac4(%rip), %rdi      # 0xbabe
leaq 0x1be1(%rip), %rsi      # 0xabe2
movl $0x49, %edx
leaq 0x1be1(%rip), %rcx      # 0xabee
callq 0x40d0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/./cff_int.h
// Function: cff_read_Card24
static inline uint32_t cff_read_Card24(const char **buf) // {{{
{
  const char *b=*buf;
  uint32_t ret=((unsigned char)b[0]<<16)|
               ((unsigned char)b[1]<<8)|
               ((unsigned char)b[2]);
  (*buf)+=3;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x10, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x3, %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/./cff_int.h
// Function: cff_read_Card32
static inline uint32_t cff_read_Card32(const char **buf) // {{{
{
  const char *b=*buf;
  uint32_t ret=((unsigned char)b[0]<<24)|
               ((unsigned char)b[1]<<16)|
               ((unsigned char)b[2]<<8)|
               ((unsigned char)b[3]);
  (*buf)+=4;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x18, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/cff_tables.c
// Function: cffop_get_by_value
const struct CFF_OPS *cffop_get_by_value(int value) // {{{
{
  if ( (value>=0)&&(value<sizeof(cff_ops1)/sizeof(*cff_ops1)) ) {
    return &cff_ops1[value];
  }
  value-=0x0c00;
  if ( (value>=0)&&(value<sizeof(cff_ops2)/sizeof(*cff_ops2)) ) {
    return &cff_ops2[value];
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x90ff
movslq -0xc(%rbp), %rax
cmpq $0x16, %rax
jae 0x90ff
movslq -0xc(%rbp), %rcx
leaq 0x551e(%rip), %rax      # 0xe610
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x913a
movl -0xc(%rbp), %eax
subl $0xc00, %eax            # imm = 0xC00
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x9132
movslq -0xc(%rbp), %rax
cmpq $0x27, %rax
jae 0x9132
movslq -0xc(%rbp), %rcx
leaq 0x57ab(%rip), %rax      # 0xe8d0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x913a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/cff_tables.c
// Function: cff_find_stdstr
int cff_find_stdstr(const char *str) // {{{
{
  // assert(str);
  init_rev_stdstr();
  const char **key=&str;
  const char ***res=bsearch(&key,cff_rev_stdstr,sizeof(cff_rev_stdstr)/sizeof(*cff_rev_stdstr),sizeof(*cff_rev_stdstr),cff_pstrcmp);
  if (!res) {
    return -1;
  }
  return *res-cff_stdstr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x92c0
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
leaq 0x6c8c(%rip), %rsi      # 0xff00
movl $0x187, %edx            # imm = 0x187
movl $0x8, %ecx
leaq -0xb5(%rip), %r8        # 0x91d0
callq 0x4160
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x929e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x92b6
movq -0x20(%rbp), %rax
movq (%rax), %rax
leaq 0x6004(%rip), %rcx      # 0xf2b0
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/cff_tables.c
// Function: init_rev_stdstr
static void init_rev_stdstr() // {{{
{
  if (*cff_rev_stdstr) {
    return;
  }
  int iA;
  for (iA=0;iA<sizeof(cff_stdstr)/sizeof(*cff_stdstr);iA++) {
    cff_rev_stdstr[iA]=cff_stdstr+iA;
  }
  qsort(cff_rev_stdstr,sizeof(cff_rev_stdstr)/sizeof(*cff_rev_stdstr),sizeof(*cff_rev_stdstr),cff_pstrcmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x6c30(%rip)      # 0xff00
je 0x92d4
jmp 0x9330
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x187, %rax            # imm = 0x187
jae 0x9313
movslq -0x4(%rbp), %rax
leaq 0x5fbe(%rip), %rdx      # 0xf2b0
shlq $0x3, %rax
addq %rax, %rdx
movslq -0x4(%rbp), %rcx
leaq 0x6bfc(%rip), %rax      # 0xff00
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x92db
leaq 0x6be6(%rip), %rdi      # 0xff00
movl $0x187, %esi            # imm = 0x187
movl $0x8, %edx
leaq -0x15b(%rip), %rcx      # 0x91d0
callq 0x41e0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/tests/run-emitter.c
// Function: print_output
int print_output(char *name, unsigned char *buffer, size_t size, int count)
{
    FILE *file;
    char data[BUFFER_SIZE];
    size_t data_size = 1;
    size_t total_size = 0;
    if (count >= 0) {
        printf("FAILED (at the event #%d)\nSOURCE:\n", count+1);
    }
    file = fopen(name, "rb");
    assert(file);
    while (data_size > 0) {
        data_size = fread(data, 1, BUFFER_SIZE, file);
        assert(!ferror(file));
        if (!data_size) break;
        assert(fwrite(data, 1, data_size, stdout) == data_size);
        total_size += data_size;
        if (feof(file)) break;
    }
    fclose(file);
    printf("#### (length: %d)\n", total_size);
    printf("OUTPUT:\n%s#### (length: %d)\n", buffer, size);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10040, %rsp          # imm = 0x10040
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq $0x1, -0x10038(%rbp)
movq $0x0, -0x10040(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x1aea
movl -0x1c(%rbp), %esi
addl $0x1, %esi
leaq 0x156f(%rip), %rdi      # 0x3052
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rdi
leaq 0x1580(%rip), %rsi      # 0x3075
callq 0x1200
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1b07
jmp 0x1b26
leaq 0x156a(%rip), %rdi      # 0x3078
leaq 0x1568(%rip), %rsi      # 0x307d
movl $0xc6, %edx
leaq 0x156a(%rip), %rcx      # 0x308b
callq 0x1110
jmp 0x1b28
cmpq $0x0, -0x10038(%rbp)
jbe 0x1c08
leaq -0x10030(%rbp), %rdi
movq -0x28(%rbp), %rcx
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x1090
movq %rax, -0x10038(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1080
cmpl $0x0, %eax
jne 0x1b67
jmp 0x1b86
leaq 0x1554(%rip), %rdi      # 0x30c2
leaq 0x1508(%rip), %rsi      # 0x307d
movl $0xc9, %edx
leaq 0x150a(%rip), %rcx      # 0x308b
callq 0x1110
cmpq $0x0, -0x10038(%rbp)
jne 0x1b92
jmp 0x1c08
leaq -0x10030(%rbp), %rdi
movq -0x10038(%rbp), %rdx
movq 0x3439(%rip), %rax      # 0x4fe0
movq (%rax), %rcx
movl $0x1, %esi
callq 0x1230
cmpq -0x10038(%rbp), %rax
jne 0x1bbf
jmp 0x1bde
leaq 0x150a(%rip), %rdi      # 0x30d0
leaq 0x14b0(%rip), %rsi      # 0x307d
movl $0xcb, %edx
leaq 0x14b2(%rip), %rcx      # 0x308b
callq 0x1110
movq -0x10038(%rbp), %rax
addq -0x10040(%rbp), %rax
movq %rax, -0x10040(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1160
cmpl $0x0, %eax
je 0x1c03
jmp 0x1c08
jmp 0x1b28
movq -0x28(%rbp), %rdi
callq 0x10c0
movq -0x10040(%rbp), %rsi
leaq 0x14eb(%rip), %rdi      # 0x310a
movb $0x0, %al
callq 0x10f0
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x14cb(%rip), %rdi      # 0x3100
movb $0x0, %al
callq 0x10f0
xorl %eax, %eax
addq $0x10040, %rsp          # imm = 0x10040
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/sha256/main.c
// Function: perftest
static int
perftest(void)
{

	/* Report what we're doing. */
	print_hardware("SHA256 time trial");
	fflush(stdout);

	/* Time the function. */
	if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
	    nbytes_warmup, 1, perftest_init, perftest_func, NULL, NULL)) {
		warn0("perftest_buffers");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xab2b(%rip), %rdi      # 0xc00a
callq 0x1770
movq 0xdaed(%rip), %rax      # 0xefd8
movq (%rax), %rdi
callq 0x1160
movl $0x5f5e100, %edi        # imm = 0x5F5E100
leaq 0xaff1(%rip), %rsi      # 0xc4f0
movl $0x3, %edx
movl $0x989680, %ecx         # imm = 0x989680
movl $0x1, %r8d
leaq 0x2da(%rip), %r9        # 0x17f0
leaq 0x323(%rip), %rax       # 0x1840
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0xa770
cmpl $0x0, %eax
je 0x155d
jmp 0x1542
leaq 0xaad3(%rip), %rdi      # 0xc01c
movb $0x0, %al
callq 0xafd0
callq 0x1070
movl $0x0, (%rax)
jmp 0x1566
movl $0x0, -0x4(%rbp)
jmp 0x156d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/sha256/main.c
// Function: selftest
static int
selftest(void)
{
	SHA256_CTX ctx;
	uint8_t hbuf[32];
	char hbuf_hex[65];
	size_t i;
	size_t failures = 0;

	for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
		printf("Computing SHA256 of \"%s\"...", tests[i].s);
		SHA256_Init(&ctx);
		SHA256_Update(&ctx, (const uint8_t *)tests[i].s,
		    strlen(tests[i].s));
		SHA256_Final(hbuf, &ctx);
		hexify(hbuf, hbuf_hex, 32);
		if (strcmp(hbuf_hex, tests[i].o)) {
			printf(" FAILED!\n");
			printf("Computed SHA256: %s\n", hbuf_hex);
			printf("Correct SHA256:  %s\n", tests[i].o);
			failures++;
		} else {
			printf(" PASSED!\n");
		}
	}

	if (failures)
		return (1);
	else
		return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq $0x0, -0xf0(%rbp)
movq $0x0, -0xe8(%rbp)
cmpq $0x9, -0xe8(%rbp)
jae 0x1704
movq -0xe8(%rbp), %rcx
leaq 0xdb43(%rip), %rax      # 0xf100
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0xaaa4(%rip), %rdi      # 0xc072
movb $0x0, %al
callq 0x10d0
leaq -0x70(%rbp), %rdi
callq 0x1a50
movq -0xe8(%rbp), %rcx
leaq 0xdb14(%rip), %rax      # 0xf100
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
movq -0xe8(%rbp), %rcx
leaq 0xdaf5(%rip), %rax      # 0xf100
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x10b0
movq -0xf8(%rbp), %rsi
movq %rax, %rdx
leaq -0x70(%rbp), %rdi
callq 0x1bf0
leaq -0x90(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1dc0
leaq -0x90(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
movl $0x20, %edx
callq 0xa540
leaq -0xe0(%rbp), %rdi
movq -0xe8(%rbp), %rcx
leaq 0xda96(%rip), %rax      # 0xf100
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x1120
cmpl $0x0, %eax
je 0x16dd
leaq 0xaa08(%rip), %rdi      # 0xc08e
movb $0x0, %al
callq 0x10d0
leaq -0xe0(%rbp), %rsi
leaq 0xa9fd(%rip), %rdi      # 0xc098
movb $0x0, %al
callq 0x10d0
movq -0xe8(%rbp), %rcx
leaq 0xda50(%rip), %rax      # 0xf100
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
leaq 0xa9eb(%rip), %rdi      # 0xc0ad
movb $0x0, %al
callq 0x10d0
movq -0xf0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xf0(%rbp)
jmp 0x16eb
leaq 0xa9de(%rip), %rdi      # 0xc0c2
movb $0x0, %al
callq 0x10d0
jmp 0x16ed
movq -0xe8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xe8(%rbp)
jmp 0x15a1
cmpq $0x0, -0xf0(%rbp)
je 0x1717
movl $0x1, -0x4(%rbp)
jmp 0x171e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/sha256/main.c
// Function: print_hardware
static void
print_hardware(const char * str)
{

	/* Inform the user of the general topic... */
	printf("%s", str);

	/* ... and whether we're using hardware acceleration or not. */
#if defined(CPUSUPPORT_CONFIG_FILE)
#if defined(CPUSUPPORT_X86_SHANI) && defined(CPUSUPPORT_X86_SSSE3)
	if (cpusupport_x86_shani() && cpusupport_x86_ssse3())
		printf(" using hardware SHANI.\n");
	else
#endif
#if defined(CPUSUPPORT_X86_SSE2)
	if (cpusupport_x86_sse2())
		printf(" using hardware SSE2.\n");
	else
#endif
#if defined(CPUSUPPORT_ARM_SHA256)
	if (cpusupport_arm_sha256())
		printf(" using hardware ARM SHA256.\n");
	else
#endif
		printf(" using software SHA.\n");
#else
	printf(" with unknown hardware acceleration status.\n");
#endif /* CPUSUPPORT_CONFIG_FILE */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xb36b(%rip), %rdi      # 0xcaf2
movb $0x0, %al
callq 0x10d0
callq 0x18d0
cmpl $0x0, %eax
je 0x17b2
callq 0x1940
cmpl $0x0, %eax
je 0x17b2
leaq 0xa884(%rip), %rdi      # 0xc02d
movb $0x0, %al
callq 0x10d0
jmp 0x17dc
callq 0x19b0
cmpl $0x0, %eax
je 0x17cc
leaq 0xa882(%rip), %rdi      # 0xc045
movb $0x0, %al
callq 0x10d0
jmp 0x17da
leaq 0xa889(%rip), %rdi      # 0xc05c
movb $0x0, %al
callq 0x10d0
jmp 0x17dc
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/sha256/main.c
// Function: perftest_func
static int
perftest_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	SHA256_CTX ctx;
	uint8_t hbuf[32];
	size_t i;

	(void)cookie; /* UNUSED */

	/* Do the hashing. */
	SHA256_Init(&ctx);
	for (i = 0; i < nreps; i++)
		SHA256_Update(&ctx, buf, buflen);
	SHA256_Final(hbuf, &ctx);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1a50
movq $0x0, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x18a7
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x1bf0
movq -0xb8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xb8(%rbp)
jmp 0x1872
leaq -0xb0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1dc0
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch6/limit_cpu.c
// Function: hook
void hook(lua_State *L, lua_Debug *ar) {

  instruction_count += instructions_per_hook;

  if (!do_limit_instructions) return;

  if (instruction_count > instruction_count_limit) {
    lua_pushstring(L, "exceeded allowed cpu time");
    lua_error(L);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x3bc91(%rip), %rax     # 0x41288
addq 0x3bcba(%rip), %rax     # 0x412b8
movq %rax, 0x3bcb3(%rip)     # 0x412b8
cmpl $0x0, 0x3bc74(%rip)     # 0x41280
jne 0x5610
jmp 0x5639
movq 0x3bca1(%rip), %rax     # 0x412b8
cmpq 0x3bc72(%rip), %rax     # 0x41290
jle 0x5639
movq -0x8(%rbp), %rdi
leaq 0x2d9d9(%rip), %rsi     # 0x33004
callq 0x68b0
movq -0x8(%rbp), %rdi
callq 0x8360
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch6/limit_cpu.c
// Function: main
int main() {
  lua_State *L = luaL_newstate();
  luaL_openlibs(L);
  lua_sethook(L, hook, LUA_MASKCOUNT, instructions_per_hook);

  print_status();
  while (accept_and_run_a_line(L)) print_status();

  lua_close(L);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x21380
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21740
movq -0x10(%rbp), %rdi
movq 0x3bbfc(%rip), %rax     # 0x41288
movl %eax, %ecx
leaq -0xb5(%rip), %rsi       # 0x55e0
movl $0x8, %edx
callq 0x8b40
callq 0x5640
movq -0x10(%rbp), %rdi
callq 0x32d90
cmpl $0x0, %eax
je 0x56b9
callq 0x5640
jmp 0x56a4
movq -0x10(%rbp), %rdi
callq 0x15f20
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]skylark/src/chip8.c
// Function: chip8_init
int
chip8_init(struct chip8* chip8)
{
    assert(chip8 != NULL);

    memset(chip8, 0, sizeof(*chip8));
    srand(time(NULL));

    memmove(chip8->mem, CHIP8_FONT, sizeof(CHIP8_FONT));

    return CHIP8_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x27d5
jmp 0x27f4
leaq 0x193f(%rip), %rdi      # 0x411b
leaq 0x1946(%rip), %rsi      # 0x4129
movl $0x29, %edx
leaq 0x1946(%rip), %rcx      # 0x4135
callq 0x20e0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1848, %edx           # imm = 0x1848
callq 0x20c0
xorl %eax, %eax
movl %eax, %edi
callq 0x2110
movl %eax, %edi
callq 0x2130
movq -0x8(%rbp), %rax
movaps 0x19d1(%rip), %xmm0     # 0x41f0
movaps 0x19da(%rip), %xmm1     # 0x4200
movaps 0x19e3(%rip), %xmm2     # 0x4210
movaps 0x19ec(%rip), %xmm3     # 0x4220
movaps 0x19f5(%rip), %xmm4     # 0x4230
movups %xmm4, 0x40(%rax)
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]skylark/src/chip8.c
// Function: chip8_load
int
chip8_load(struct chip8* chip8, const uint8_t* rom, long size)
{
    assert(rom != NULL);

    if (CHIP8_ROM_ADDR + size >= CHIP8_MEM_SIZE) {
        return CHIP8_ERROR_OVERSIZED_ROM;
    }

    memmove(chip8->mem + CHIP8_ROM_ADDR, rom, size);
    chip8->pc = CHIP8_ROM_ADDR;

    return CHIP8_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x287d
jmp 0x289c
leaq 0x18d0(%rip), %rdi      # 0x4154
leaq 0x189e(%rip), %rsi      # 0x4129
movl $0x36, %edx
leaq 0x18c9(%rip), %rcx      # 0x4160
callq 0x20e0
movq -0x20(%rbp), %rax
addq $0x200, %rax            # imm = 0x200
cmpq $0x1000, %rax           # imm = 0x1000
jl 0x28b7
movl $0x1, -0x4(%rbp)
jmp 0x28e3
movq -0x10(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x21c0
movq -0x10(%rbp), %rax
movw $0x200, 0x1012(%rax)    # imm = 0x200
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]skylark/src/chip8.c
// Function: chip8_step
int
chip8_step(struct chip8* chip8)
{
    uint16_t code = chip8->mem[chip8->pc] << 8 | chip8->mem[chip8->pc + 1];

    struct instruction inst = { 0 };
    int rc = instruction_decode(&inst, code);
    if (rc != INSTRUCTION_OK) {
        fprintf(stderr, "attempted to decode a bad instruction\n");
        return CHIP8_ERROR_BAD_INSTRUCTION;
    }

    rc = operation_apply(chip8, &inst);
    if (rc != OPERATION_OK) {
        fprintf(stderr, "attempted to execute a bad operation: %s\n", operation_error_message(rc));
        return CHIP8_ERROR_BAD_OPERATION;
    }

    if (chip8->timer_delay > 0) chip8->timer_delay -= 1;
    if (chip8->timer_sound > 0) chip8->timer_sound -= 1;

    return CHIP8_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl 0x1012(%rcx), %ecx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rdx
movzwl 0x1012(%rdx), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movw %ax, -0x12(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0x20c0
leaq -0x20(%rbp), %rdi
movzwl -0x12(%rbp), %esi
callq 0x2a90
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x297b
movq 0x3682(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
leaq 0x182e(%rip), %rsi      # 0x4196
movb $0x0, %al
callq 0x21a0
movl $0x2, -0x4(%rbp)
jmp 0x2a14
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2bc0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x29c5
movq 0x3648(%rip), %rax      # 0x5fe0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %edi
callq 0x2c50
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x1808(%rip), %rsi      # 0x41bd
movb $0x0, %al
callq 0x21a0
movl $0x3, -0x4(%rbp)
jmp 0x2a14
movq -0x10(%rbp), %rax
movzbl 0x1846(%rax), %eax
cmpl $0x0, %eax
jle 0x29e9
movq -0x10(%rbp), %rax
movzbl 0x1846(%rax), %ecx
subl $0x1, %ecx
movb %cl, 0x1846(%rax)
movq -0x10(%rbp), %rax
movzbl 0x1847(%rax), %eax
cmpl $0x0, %eax
jle 0x2a0d
movq -0x10(%rbp), %rax
movzbl 0x1847(%rax), %ecx
subl $0x1, %ecx
movb %cl, 0x1847(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]skylark/src/chip8.c
// Function: chip8_pixel_on
bool
chip8_pixel_on(const struct chip8* chip8, long x, long y)
{
    if (x < 0 || x >= CHIP8_DISPLAY_WIDTH) return false;
    if (y < 0 || y >= CHIP8_DISPLAY_HEIGHT) return false;

    // row-major ordering
    long index = (y * CHIP8_DISPLAY_WIDTH) + x;
    return chip8->display[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x2a3e
cmpq $0x40, -0x18(%rbp)
jl 0x2a44
movb $0x0, -0x1(%rbp)
jmp 0x2a7c
cmpq $0x0, -0x20(%rbp)
jl 0x2a52
cmpq $0x20, -0x20(%rbp)
jl 0x2a58
movb $0x0, -0x1(%rbp)
jmp 0x2a7c
movq -0x20(%rbp), %rax
shlq $0x6, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb 0x1046(%rax,%rcx), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]skylark/src/inst.c
// Function: instruction_decode
int
instruction_decode(struct instruction* inst, uint16_t code)
{
    // params can be set now since their position is consistent
    inst->opcode = OPCODE_UNDEFINED;
    inst->nnn = code & 0x0fff;
    inst->n = code & 0x000f;
    inst->x = (code & 0x0f00) >> 8;
    inst->y = (code & 0x00f0) >> 4;
    inst->kk = code & 0x00ff;

    // loop through each opcode and try to find a match
    for (int op = OPCODE_UNDEFINED + 1; op < OPCODE_COUNT; op++) {
        // check for a match by masking the code and comparing the values
        if ((code & INSTRUCTION_MASKS[op].mask) == INSTRUCTION_MASKS[op].value) {
            inst->opcode = op;
            return INSTRUCTION_OK;
        }
    }

    // if nothing matched from the above loop then the code is invalid
    return INSTRUCTION_ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movzwl -0x12(%rbp), %eax
andl $0xfff, %eax            # imm = 0xFFF
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x4(%rax)
movzwl -0x12(%rbp), %eax
andl $0xf, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x6(%rax)
movzwl -0x12(%rbp), %eax
andl $0xf00, %eax            # imm = 0xF00
sarl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x7(%rax)
movzwl -0x12(%rbp), %eax
andl $0xf0, %eax
sarl $0x4, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x8(%rax)
movzwl -0x12(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x9(%rax)
movl $0x1, -0x18(%rbp)
cmpl $0x24, -0x18(%rbp)
jge 0x2b5e
movzwl -0x12(%rbp), %eax
movslq -0x18(%rbp), %rdx
leaq 0x171b(%rip), %rcx      # 0x4240
movzwl (%rcx,%rdx,4), %ecx
andl %ecx, %eax
movslq -0x18(%rbp), %rdx
leaq 0x170a(%rip), %rcx      # 0x4240
movzwl 0x2(%rcx,%rdx,4), %ecx
cmpl %ecx, %eax
jne 0x2b51
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x2b65
jmp 0x2b53
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2b10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]skylark/src/op.c
// Function: operation_apply
int
operation_apply(struct chip8* chip8, const struct instruction* inst)
{
    assert(chip8 != NULL);
    assert(inst != NULL);

    operation_func operation = OPERATIONS[inst->opcode];
    return operation(chip8, inst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2bd9
jmp 0x2bf8
leaq 0x153b(%rip), %rdi      # 0x411b
leaq 0x1931(%rip), %rsi      # 0x4518
movl $0x17d, %edx            # imm = 0x17D
leaq 0x192e(%rip), %rcx      # 0x4521
callq 0x20e0
cmpq $0x0, -0x10(%rbp)
je 0x2c01
jmp 0x2c20
leaq 0x1959(%rip), %rdi      # 0x4561
leaq 0x1909(%rip), %rsi      # 0x4518
movl $0x17e, %edx            # imm = 0x17E
leaq 0x1906(%rip), %rcx      # 0x4521
callq 0x20e0
movq -0x10(%rbp), %rax
movslq (%rax), %rcx
leaq 0x35f2(%rip), %rax      # 0x6220
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]skylark/src/op.c
// Function: operation_error_message
const char*
operation_error_message(int error)
{
    switch (error) {
    case OPERATION_OK: return "OK";
    case OPERATION_ERROR_INVALID_INSTRUCTION: return "invalid instruction";
    case OPERATION_ERROR_UNDEFINED_OPERATION: return "undefined operation";
    case OPERATION_ERROR_STACK_OVERFLOW: return "stack overflow";
    case OPERATION_ERROR_STACK_UNDERFLOW: return "stack underflow";
    default: return "unknown error";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x2cb9
movq -0x18(%rbp), %rax
leaq 0x1895(%rip), %rcx      # 0x4504
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x18ef(%rip), %rax      # 0x456e
movq %rax, -0x8(%rbp)
jmp 0x2cc4
leaq 0x18e5(%rip), %rax      # 0x4571
movq %rax, -0x8(%rbp)
jmp 0x2cc4
leaq 0x18ec(%rip), %rax      # 0x4585
movq %rax, -0x8(%rbp)
jmp 0x2cc4
leaq 0x18f3(%rip), %rax      # 0x4599
movq %rax, -0x8(%rbp)
jmp 0x2cc4
leaq 0x18f5(%rip), %rax      # 0x45a8
movq %rax, -0x8(%rbp)
jmp 0x2cc4
leaq 0x18f8(%rip), %rax      # 0x45b8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]skylark/src/op.c
// Function: operation_RET_00EE
static int
operation_RET_00EE(struct chip8* chip8, const struct instruction* inst)
{
    if (chip8->sp <= 0) return OPERATION_ERROR_STACK_UNDERFLOW;

    chip8->sp -= 1;
    chip8->pc = chip8->stack[chip8->sp];
    chip8->pc += 2;
    return OPERATION_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x1034(%rax), %eax
cmpl $0x0, %eax
jg 0x2d65
movl $0x4, -0x4(%rbp)
jmp 0x2db8
movq -0x10(%rbp), %rax
movzwl 0x1034(%rax), %ecx
subl $0x1, %ecx
movw %cx, 0x1034(%rax)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl 0x1034(%rcx), %ecx
movw 0x1014(%rax,%rcx,2), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x1012(%rax)
movq -0x10(%rbp), %rax
movzwl 0x1012(%rax), %ecx
addl $0x2, %ecx
movw %cx, 0x1012(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]skylark/src/op.c
// Function: operation_CALL_2nnn
static int
operation_CALL_2nnn(struct chip8* chip8, const struct instruction* inst)
{
    if (chip8->sp >= CHIP8_STACK_SIZE - 1) return OPERATION_ERROR_STACK_OVERFLOW;

    chip8->stack[chip8->sp] = chip8->pc;
    chip8->sp += 1;
    chip8->pc = inst->nnn;
    return OPERATION_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x1034(%rax), %eax
cmpl $0xf, %eax
jl 0x2e45
movl $0x3, -0x4(%rbp)
jmp 0x2e96
movq -0x10(%rbp), %rax
movw 0x1012(%rax), %dx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl 0x1034(%rcx), %ecx
movw %dx, 0x1014(%rax,%rcx,2)
movq -0x10(%rbp), %rax
movzwl 0x1034(%rax), %ecx
addl $0x1, %ecx
movw %cx, 0x1034(%rax)
movq -0x18(%rbp), %rax
movw 0x4(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x1012(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]skylark/src/op.c
// Function: operation_ADD_8xy4
static int
operation_ADD_8xy4(struct chip8* chip8, const struct instruction* inst)
{
    chip8->reg[CHIP8_REG_VF] = (chip8->reg[inst->x] + chip8->reg[inst->y] > 0xff) ? 1 : 0;
    chip8->reg[inst->x] += chip8->reg[inst->y];
    chip8->pc += 2;
    return OPERATION_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
movzbl 0x1000(%rax,%rcx), %edx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
movzbl 0x1000(%rax,%rcx), %eax
addl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0xff, %edx
cmovgl %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x100f(%rax)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
movzbl 0x1000(%rax,%rcx), %esi
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
movzbl 0x1000(%rax,%rcx), %edx
addl %esi, %edx
movb %dl, 0x1000(%rax,%rcx)
movq -0x8(%rbp), %rax
movzwl 0x1012(%rax), %ecx
addl $0x2, %ecx
movw %cx, 0x1012(%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]skylark/src/op.c
// Function: operation_SUB_8xy5
static int
operation_SUB_8xy5(struct chip8* chip8, const struct instruction* inst)
{
    chip8->reg[CHIP8_REG_VF] = (chip8->reg[inst->x] > chip8->reg[inst->y]) ? 1 : 0;
    chip8->reg[inst->x] -= chip8->reg[inst->y];
    chip8->pc += 2;
    return OPERATION_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
movzbl 0x1000(%rax,%rcx), %edx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
movzbl 0x1000(%rax,%rcx), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovgl %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x100f(%rax)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
movzbl 0x1000(%rax,%rcx), %esi
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
movzbl 0x1000(%rax,%rcx), %edx
subl %esi, %edx
movb %dl, 0x1000(%rax,%rcx)
movq -0x8(%rbp), %rax
movzwl 0x1012(%rax), %ecx
addl $0x2, %ecx
movw %cx, 0x1012(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]skylark/src/op.c
// Function: operation_SHR_8xy6
static int
operation_SHR_8xy6(struct chip8* chip8, const struct instruction* inst)
{
    chip8->reg[CHIP8_REG_VF] = (chip8->reg[inst->x] & 0x1) ? 1 : 0;
    chip8->reg[inst->x] >>= 1;
    chip8->pc += 2;
    return OPERATION_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
movzbl 0x1000(%rax,%rcx), %edx
andl $0x1, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x100f(%rax)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
movzbl 0x1000(%rax,%rcx), %edx
sarl %edx
movb %dl, 0x1000(%rax,%rcx)
movq -0x8(%rbp), %rax
movzwl 0x1012(%rax), %ecx
addl $0x2, %ecx
movw %cx, 0x1012(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]skylark/src/op.c
// Function: operation_SUBN_8xy7
static int
operation_SUBN_8xy7(struct chip8* chip8, const struct instruction* inst)
{
    chip8->reg[CHIP8_REG_VF] = (chip8->reg[inst->y] > chip8->reg[inst->x]) ? 1 : 0;
    chip8->reg[inst->x] = chip8->reg[inst->y] - chip8->reg[inst->x];
    chip8->pc += 2;
    return OPERATION_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
movzbl 0x1000(%rax,%rcx), %edx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
movzbl 0x1000(%rax,%rcx), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovgl %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x100f(%rax)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
movzbl 0x1000(%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
movzbl 0x7(%rdx), %edx
movzbl 0x1000(%rcx,%rdx), %ecx
subl %ecx, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
movb %dl, 0x1000(%rax,%rcx)
movq -0x8(%rbp), %rax
movzwl 0x1012(%rax), %ecx
addl $0x2, %ecx
movw %cx, 0x1012(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]skylark/src/op.c
// Function: operation_SHL_8xyE
static int
operation_SHL_8xyE(struct chip8* chip8, const struct instruction* inst)
{
    chip8->reg[CHIP8_REG_VF] = (chip8->reg[inst->x] & 0x8) ? 1 : 0;
    chip8->reg[inst->x] <<= 1;
    chip8->pc += 2;
    return OPERATION_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
movzbl 0x1000(%rax,%rcx), %edx
andl $0x8, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x100f(%rax)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
movzbl 0x1000(%rax,%rcx), %edx
shll %edx
movb %dl, 0x1000(%rax,%rcx)
movq -0x8(%rbp), %rax
movzwl 0x1012(%rax), %ecx
addl $0x2, %ecx
movw %cx, 0x1012(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)