LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190925_1MM1_INTRO/EvalContinua.c
// Function: usar_NUMDREAC_buckets()
unsigned int usar_NUMDREAC_buckets()
{
  char bucket[NUMDREAC+1]={0};        /* buckets o cubetas a utilizar */
  int i;
  for(i=0;i<cantidad_de_reactivos_usados;i++){
    bucket[reactivos_usados[i]]=1;
  }
  for(i=1;i<NUMDREAC;i++){
    if(bucket[i]==0){
      return i;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x20d0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x5327(%rip), %rcx      # 0x79e0
cmpl (%rcx), %eax
jae 0x26de
leaq 0x5324(%rip), %rax      # 0x79e8
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movb $0x1, -0x8(%rbp,%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x26af
movl $0x1, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x270e
movslq -0xc(%rbp), %rax
movsbl -0x8(%rbp,%rax), %eax
cmpl $0x0, %eax
jne 0x2701
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2715
jmp 0x2703
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x26e5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190925_1MM1_INTRO/EvalContinua.c
// Function: asignado(unsigned int)
bool asignado(unsigned int candidato)
{
  unsigned int i;
  for(i=0;i<cantidad_de_reactivos_usados;i++){
    if(*(reactivos_usados+i)==candidato){
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x52a8(%rip), %rcx      # 0x79e0
cmpl (%rcx), %eax
jae 0x2764
leaq 0x52a5(%rip), %rax      # 0x79e8
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jne 0x2757
movb $0x1, -0x1(%rbp)
jmp 0x2768
jmp 0x2759
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x272e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190925_1MM1_INTRO/EvalContinua.c
// Function: actualizar_reactivos_usados(unsigned int)
void actualizar_reactivos_usados(unsigned int reactivo_en_uso)
{
  unsigned int i,*tmp=(unsigned int *)malloc(cantidad_de_reactivos_usados*sizeof(unsigned int));
  for(i=0;i<cantidad_de_reactivos_usados;i++){
    *(tmp+i)=reactivos_usados[i];
  }
  reactivos_usados=(unsigned int *)malloc(
                   (cantidad_de_reactivos_usados+1)*sizeof(unsigned int));
  for(i=0;i<cantidad_de_reactivos_usados;i++){
    reactivos_usados[i]=*(tmp+i);
  }
  reactivos_usados[cantidad_de_reactivos_usados]=reactivo_en_uso;
  cantidad_de_reactivos_usados++;
  modificado=true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x525e(%rip), %rax      # 0x79e0
movl (%rax), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x2250
movq %rax, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0x523c(%rip), %rcx      # 0x79e0
cmpl (%rcx), %eax
jae 0x27cd
leaq 0x5239(%rip), %rax      # 0x79e8
movq (%rax), %rax
movl -0x8(%rbp), %ecx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x279a
leaq 0x520c(%rip), %rax      # 0x79e0
movl (%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x2250
movq %rax, %rcx
leaq 0x51f8(%rip), %rax      # 0x79e8
movq %rcx, (%rax)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0x51dc(%rip), %rcx      # 0x79e0
cmpl (%rcx), %eax
jae 0x282d
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %ecx
movl (%rax,%rcx,4), %edx
leaq 0x51cf(%rip), %rax      # 0x79e8
movq (%rax), %rax
movl -0x8(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x27fa
movl -0x4(%rbp), %edx
leaq 0x51b1(%rip), %rax      # 0x79e8
movq (%rax), %rax
leaq 0x519f(%rip), %rcx      # 0x79e0
movl (%rcx), %ecx
movl %edx, (%rax,%rcx,4)
leaq 0x5193(%rip), %rax      # 0x79e0
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x5187(%rip), %rax      # 0x79e0
movl %ecx, (%rax)
leaq 0x518e(%rip), %rax      # 0x79f0
movb $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190925_1MM1_INTRO/test_EvalContinua.c
// Function: main
int main(int argc,char *argv[])
{
  unsigned int indice_de_reactivo,reactivo_index,ret;
  if(argc<2){
    printf("FORMA DE USO:%s <file_index_reactivos_intro>\n",
            argv[0]);
    exit(1);
  }
void run_ctor(char *);
  run_ctor(argv[1]);
unsigned int init_REACTIVO();
   if((ret=init_REACTIVO())==NUMDREAC){
unsigned int siguiente_turno();
     if((reactivo_index=siguiente_turno())>0){
#ifndef NDEBUG
       printf("reactivo_index=%u\n",reactivo_index);
#endif
       indice_de_reactivo=reactivo_index-1;
int show_reactivo(unsigned int);
       show_reactivo(indice_de_reactivo);
void save_reactivos_asignados(unsigned int);
       if(modificado){
         save_reactivos_asignados(reactivo_index);
       }
     }else{ 
       printf("Reactivos YA asignados ...\n");
       return 0;
     }
   }else{
#ifndef NDEBUG
     printf("ret=%u\n",ret);
#endif
     return -1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x2e3b
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x12ca(%rip), %rdi      # 0x40f4
movb $0x0, %al
callq 0x2030
movl $0x1, %edi
callq 0x2210
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2ec0
callq 0x31c0
movl %eax, -0x1c(%rbp)
cmpl $0x3, %eax
jne 0x2ea2
callq 0x2580
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jbe 0x2e89
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x24f0
leaq 0x4b76(%rip), %rax      # 0x79f0
testb $0x1, (%rax)
je 0x2e87
movl -0x18(%rbp), %edi
callq 0x2870
jmp 0x2ea0
leaq 0x1292(%rip), %rdi      # 0x4122
movb $0x0, %al
callq 0x2030
movl $0x0, -0x4(%rbp)
jmp 0x2ea9
jmp 0x2ea9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190925_1MM1_INTRO/ctors.c
// Function: init_REACTIVO()
unsigned int init_REACTIVO()
{
  unsigned int i,j=0;
  FILE *fent;
  int car,res=0;
  char nombre_de_archivo[1024];
  
  for(i=0;i<NUMDREAC;i++){
    sprintf(nombre_de_archivo,"./reactivos/reactivo%d.txt",i+1);
#ifndef NDEBUG
    printf("Abriendo %s\n",nombre_de_archivo);
#endif
    /**Apertura del i-esimo archivo de entrada*/
    fent=fopen(nombre_de_archivo,"r");
    if(fent==NULL){
      fprintf(stderr,"Error abriendo %s\n",nombre_de_archivo);
      return i;
    }
    while((car=fgetc(fent))!=EOF){
      REACTIVO[i][j++]=car;
    }
    j=0;
    /**Cierre del i-esimo archivo*/ 
    fclose(fent);
#ifndef NDEBUG
    printf("%s\n",REACTIVO[i]);
#endif
  }/*end for()*/
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movl $0x0, -0xc(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x3, -0x8(%rbp)
jae 0x32a5
leaq -0x420(%rbp), %rdi
movl -0x8(%rbp), %edx
addl $0x1, %edx
leaq 0xf42(%rip), %rsi       # 0x4140
movb $0x0, %al
callq 0x2050
leaq -0x420(%rbp), %rdi
leaq 0xf48(%rip), %rsi       # 0x415b
callq 0x2200
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x324a
movq 0x2dae(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
leaq -0x420(%rbp), %rdx
leaq 0xf22(%rip), %rsi       # 0x415d
movb $0x0, %al
callq 0x2290
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x32ab
jmp 0x324c
movq -0x18(%rbp), %rdi
callq 0x22f0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x3287
movl -0x1c(%rbp), %eax
movb %al, %dl
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x2f72(%rip), %rax      # 0x61e0
shlq $0xb, %rcx
addq %rcx, %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
jmp 0x324c
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2190
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x31e0
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/cavescroll/cavescroll.c
// Function: data_initialize
static void data_initialize(void)
{
  int i;

  srandom(time(NULL));

  score = 0;
  ammo =  5;

  player_x = 3;
  player_y = CAVE_HEIGHT / 2;

  cave[CAVE_WIDTH - 1].top = CAVE_HEIGHT / 4;
  cave[CAVE_WIDTH - 1].bottom = cave[CAVE_WIDTH - 1].top * 3;

  for (i = 0; i < CAVE_WIDTH - 1; i++) {
    generate_cave();
  }

  atexit(objects_free_all);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x10f0
movl %eax, %edi
callq 0x1050
movl $0x0, 0x3c9a(%rip)      # 0x50fc
movl $0x5, 0x3c88(%rip)      # 0x50f4
movl $0x3, 0x3c82(%rip)      # 0x50f8
movl $0xc, 0x3c70(%rip)      # 0x50f0
movl $0x6, 0x3eee(%rip)      # 0x5378
imull $0x3, 0x3ee7(%rip), %eax # 0x5378
movl %eax, 0x3ee5(%rip)      # 0x537c
movl $0x0, -0x4(%rbp)
cmpl $0x4f, -0x4(%rbp)
jge 0x14b4
callq 0x1840
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x149e
leaq 0x7f5(%rip), %rdi       # 0x1cb0
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/cavescroll/cavescroll.c
// Function: screen_initialize
static void screen_initialize(void)
{
  int maxy, maxx;

  initscr();

  getmaxyx(stdscr, maxy, maxx);
  if (maxx < CAVE_WIDTH || maxy < CAVE_HEIGHT) {
    endwin();
    printf("\nScreen must at least %dx%d.\n", CAVE_WIDTH, CAVE_HEIGHT);
    exit(0);
  }

  atexit(screen_end);
  noecho();
  keypad(stdscr, TRUE);
  timeout(0); /* Non-blocking mode */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1090
xorl %eax, %eax
movq 0x3afa(%rip), %rcx      # 0x4fe0
cmpq (%rcx), %rax
je 0x1501
movq 0x3aee(%rip), %rax      # 0x4fe0
movq (%rax), %rax
movswl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x150b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0xc(%rbp)
jmp 0x150b
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
xorl %eax, %eax
movq 0x3ac6(%rip), %rcx      # 0x4fe0
cmpq (%rcx), %rax
je 0x1535
movq 0x3aba(%rip), %rax      # 0x4fe0
movq (%rax), %rax
movswl 0x6(%rax), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x153f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x10(%rbp)
jmp 0x153f
movl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x50, -0x8(%rbp)
jl 0x1551
cmpl $0x18, -0x4(%rbp)
jge 0x1575
callq 0x1170
leaq 0x1b1b(%rip), %rdi      # 0x3078
movl $0x50, %esi
movl $0x18, %edx
movb $0x0, %al
callq 0x1080
xorl %edi, %edi
callq 0x1160
leaq 0x784(%rip), %rdi       # 0x1d00
callq 0x2060
callq 0x1070
movq 0x3a53(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x10b0
movq 0x3a3f(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
xorl %esi, %esi
callq 0x10e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/cavescroll/cavescroll.c
// Function: screen_update
static void screen_update(void)
{
  int i, j;

  erase();

  /* Main cave. */
  for (i = 0; i < CAVE_WIDTH; i++) {
    for (j = 0; j < cave[i].top; j++) {
      mvaddch(j, i, GRAPHICS_CAVE);
    }
    for (j = cave[i].bottom; j < CAVE_HEIGHT; j++) {
      mvaddch(j, i, GRAPHICS_CAVE);
    }
  }

  /* HUD. */
  mvprintw(0, 0, "Score: %5d Ammo: %3d ", score, ammo);

  objects_draw();

  /* Position cursor on player. */
  mvaddch(player_y, player_x, GRAPHICS_PLAYER);
  move(player_y, player_x);

  refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x3a11(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
cmpl $0x50, -0x4(%rbp)
jge 0x16a0
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movslq -0x4(%rbp), %rdx
leaq 0x3b03(%rip), %rcx      # 0x5100
cmpl (%rcx,%rdx,8), %eax
jge 0x163d
movq 0x39d7(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl -0x8(%rbp), %esi
movl -0x4(%rbp), %edx
callq 0x1130
cmpl $-0x1, %eax
jne 0x161e
jmp 0x1632
movq 0x39bb(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl $0x23, %esi
callq 0x1150
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x15ef
movslq -0x4(%rbp), %rcx
leaq 0x3ab8(%rip), %rax      # 0x5100
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x8(%rbp)
cmpl $0x18, -0x8(%rbp)
jge 0x1690
movq 0x3984(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl -0x8(%rbp), %esi
movl -0x4(%rbp), %edx
callq 0x1130
cmpl $-0x1, %eax
jne 0x1671
jmp 0x1685
movq 0x3968(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl $0x23, %esi
callq 0x1150
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x164f
jmp 0x1692
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x15de
movl 0x3a56(%rip), %ecx      # 0x50fc
movl 0x3a47(%rip), %r8d      # 0x50f4
xorl %esi, %esi
leaq 0x19ec(%rip), %rdx      # 0x30a2
movl %esi, %edi
movb $0x0, %al
callq 0x10d0
callq 0x1d20
movq 0x3915(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl 0x3a1c(%rip), %esi      # 0x50f0
movl 0x3a1e(%rip), %edx      # 0x50f8
callq 0x1130
cmpl $-0x1, %eax
jne 0x16e6
jmp 0x16fa
movq 0x38f3(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl $0x3e, %esi
callq 0x1150
movq 0x38df(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl 0x39e6(%rip), %esi      # 0x50f0
movl 0x39e8(%rip), %edx      # 0x50f8
callq 0x1130
movq 0x38c4(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
callq 0x10a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/cavescroll/cavescroll.c
// Function: object_spawn
static void object_spawn(unsigned char type)
{
  object_t *new, *curr;

  new = (object_t *)malloc(sizeof(object_t));

  if (objects == NULL) {
    objects = new;
  } else {
    for (curr = objects; curr->next != NULL; curr = curr->next)
      ;
    curr->next = new;
  }

  new->type = type;
  new->next = NULL;
  new->removed = 0;

  switch (type) {
  case GRAPHICS_MONEY:
  case GRAPHICS_AMMO:
  case GRAPHICS_ENEMY:
    new->x = CAVE_WIDTH - 1;
    new->y = cave[CAVE_WIDTH - 1].top + 
      (random() % (cave[CAVE_WIDTH - 1].bottom - cave[CAVE_WIDTH - 1].top));
    break;
  case GRAPHICS_SHOT:
    new->x = player_x + 1;
    new->y = player_y;
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl $0x18, %edi
callq 0x1120
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x3c2c(%rip)      # 0x5380
jne 0x1763
movq -0x10(%rbp), %rax
movq %rax, 0x3c1f(%rip)      # 0x5380
jmp 0x1795
movq 0x3c16(%rip), %rax      # 0x5380
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1789
jmp 0x177b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x176e
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movzbl -0x1(%rbp), %eax
addl $-0x24, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x1c, %eax
ja 0x1839
movq -0x20(%rbp), %rax
leaq 0x1832(%rip), %rcx      # 0x3004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movl $0x4f, 0x4(%rax)
movslq 0x3b8b(%rip), %rax      # 0x5378
movq %rax, -0x28(%rbp)
callq 0x1100
movl 0x3b80(%rip), %ecx      # 0x537c
subl 0x3b76(%rip), %ecx      # 0x5378
movslq %ecx, %rcx
cqto
idivq %rcx
movq -0x28(%rbp), %rax
addq %rdx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x1839
movl 0x38d6(%rip), %ecx      # 0x50f8
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl 0x38be(%rip), %ecx      # 0x50f0
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/cavescroll/cavescroll.c
// Function: objects_cleanup
static void objects_cleanup(void)
{
  object_t *curr;

objects_cleanup_again:

  if (objects == NULL)
    return;

  for (curr = objects; curr != NULL; curr = curr->next) {
    if (curr->x < 0 || curr->x > CAVE_WIDTH) {
      object_free(curr);
      /* Need to re-initialize linked list. */
      goto objects_cleanup_again;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x3720(%rip)      # 0x5380
jne 0x1c64
jmp 0x1ca5
movq 0x3715(%rip), %rax      # 0x5380
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1ca5
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x1c8a
movq -0x8(%rbp), %rax
cmpl $0x50, 0x4(%rax)
jle 0x1c95
movq -0x8(%rbp), %rdi
callq 0x1fd0
jmp 0x1c58
jmp 0x1c97
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c6f
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/cavescroll/cavescroll.c
// Function: objects_free_all
static void objects_free_all(void)
{
  object_t *curr, *next;

  if (objects == NULL)
    return;

  curr = objects;
  while (curr != NULL) {
    next = curr->next;
    free(curr);
    curr = next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x36c0(%rip)      # 0x5380
jne 0x1cc4
jmp 0x1cf5
movq 0x36b5(%rip), %rax      # 0x5380
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1cf5
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1ccf
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/cavescroll/cavescroll.c
// Function: objects_draw
static void objects_draw(void)
{
  object_t *curr;

  if (objects == NULL)
    return;

  for (curr = objects; curr != NULL; curr = curr->next) {
    if (curr->removed)
      continue;
    mvaddch(curr->y, curr->x, curr->type);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x3650(%rip)      # 0x5380
jne 0x1d34
jmp 0x1d9a
movq 0x3645(%rip), %rax      # 0x5380
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1d9a
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x1d52
jmp 0x1d8c
movq 0x3287(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
callq 0x1130
cmpl $-0x1, %eax
jne 0x1d76
jmp 0x1d8c
movq 0x3263(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movzbl (%rax), %esi
callq 0x1150
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1d3f
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/cavescroll/cavescroll.c
// Function: objects_shift
static void objects_shift(void)
{
  object_t *curr;

  if (objects == NULL)
    return;

  for (curr = objects; curr != NULL; curr = curr->next)
    curr->x--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x35d4(%rip)      # 0x5380
jne 0x1db0
jmp 0x1ddd
movq 0x35c9(%rip), %rax      # 0x5380
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1ddd
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1dbb
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/cavescroll/cavescroll.c
// Function: object_free
static void object_free(object_t *object)
{
  object_t *curr, *prev;

  if (objects == NULL)
    return;

  prev = NULL;
  for (curr = objects; curr != NULL; curr = curr->next) {
    if (curr == object) {
      if (prev == NULL) {
        objects = curr->next;
      } else {
        prev->next = curr->next;
      }
      free(curr);
      return;
    }
    prev = curr;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x339c(%rip)      # 0x5380
jne 0x1fe8
jmp 0x2055
movq $0x0, -0x18(%rbp)
movq 0x3389(%rip), %rax      # 0x5380
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2055
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x203f
cmpq $0x0, -0x18(%rbp)
jne 0x2024
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x335e(%rip)      # 0x5380
jmp 0x2034
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x1040
jmp 0x2055
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1ffb
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_string_extend
YAML_DECLARE(int)
yaml_string_extend(yaml_char_t **start,
        yaml_char_t **pointer, yaml_char_t **end)
{
    yaml_char_t *new_start = yaml_realloc(*start, (*end - *start)*2);

    if (!new_start) return 0;

    memset(new_start + (*end - *start), 0, *end - *start);

    *pointer = new_start + (*pointer - *start);
    *end = new_start + (*end - *start)*2;
    *start = new_start;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rsi
shlq %rsi
callq 0x2130
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x24eb
movl $0x0, -0x4(%rbp)
jmp 0x256e
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x2120
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rax
shlq %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_string_join
YAML_DECLARE(int)
yaml_string_join(
        yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
        yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end)
{
    if (*b_start == *b_pointer)
        return 1;

    while (*a_end - *a_pointer <= *b_pointer - *b_start) {
        if (!yaml_string_extend(a_start, a_pointer, a_end))
            return 0;
    }

    memcpy(*a_pointer, *b_start, *b_pointer - *b_start);
    *a_pointer += *b_pointer - *b_start;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x25bc
movl $0x1, -0x4(%rbp)
jmp 0x264c
jmp 0x25be
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movq -0x28(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jg 0x2606
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x20a0
cmpl $0x0, %eax
jne 0x2604
movl $0x0, -0x4(%rbp)
jmp 0x264c
jmp 0x25be
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rax
subq %rax, %rdx
callq 0x2180
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq (%rax), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_stack_extend
YAML_DECLARE(int)
yaml_stack_extend(void **start, void **top, void **end)
{
    void *new_start = yaml_realloc(*start, ((char *)*end - (char *)*start)*2);

    if (!new_start) return 0;

    *top = (char *)new_start + ((char *)*top - (char *)*start);
    *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
    *start = new_start;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rsi
shlq %rsi
callq 0x2130
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x26a8
movl $0x0, -0x4(%rbp)
jmp 0x26fb
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rax
shlq %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_queue_extend
YAML_DECLARE(int)
yaml_queue_extend(void **start, void **head, void **tail, void **end)
{
    /* Check if we need to resize the queue. */

    if (*start == *head && *tail == *end) {
        void *new_start = yaml_realloc(*start,
                ((char *)*end - (char *)*start)*2);

        if (!new_start) return 0;

        *head = (char *)new_start + ((char *)*head - (char *)*start);
        *tail = (char *)new_start + ((char *)*tail - (char *)*start);
        *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
        *start = new_start;
    }

    /* Check if we need to move the queue at the beginning of the buffer. */

    if (*tail == *end) {
        if (*head != *tail) {
            memmove(*start, *head, (char *)*tail - (char *)*head);
        }
        *tail = (char *)*tail - (char *)*head + (char *)*start;
        *head = *start;
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x27f2
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x27f2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rsi
shlq %rsi
callq 0x2130
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2787
movl $0x0, -0x4(%rbp)
jmp 0x286a
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rax
shlq %rax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x2863
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
je 0x2836
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
subq %rax, %rdx
callq 0x21e0
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_token_delete
YAML_DECLARE(void)
yaml_token_delete(yaml_token_t *token)
{
    assert(token);  /* Non-NULL token object expected. */

    switch (token->type)
    {
        case YAML_TAG_DIRECTIVE_TOKEN:
            yaml_free(token->data.tag_directive.handle);
            yaml_free(token->data.tag_directive.prefix);
            break;

        case YAML_ALIAS_TOKEN:
            yaml_free(token->data.alias.value);
            break;

        case YAML_ANCHOR_TOKEN:
            yaml_free(token->data.anchor.value);
            break;

        case YAML_TAG_TOKEN:
            yaml_free(token->data.tag.handle);
            yaml_free(token->data.tag.suffix);
            break;

        case YAML_SCALAR_TOKEN:
            yaml_free(token->data.scalar.value);
            break;

        default:
            break;
    }

    memset(token, 0, sizeof(yaml_token_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3145
jmp 0x3164
leaq 0x29038(%rip), %rdi     # 0x2c184
leaq 0x27f1e(%rip), %rsi     # 0x2b071
movl $0x244, %edx            # imm = 0x244
leaq 0x2837e(%rip), %rcx     # 0x2b4dd
callq 0x2100
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x11, %eax
ja 0x31f1
movq -0x10(%rbp), %rax
leaq 0x27e7d(%rip), %rcx     # 0x2b000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2140
jmp 0x31f3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2140
jmp 0x31f3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2140
jmp 0x31f3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2140
jmp 0x31f3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2140
jmp 0x31f3
jmp 0x31f3
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x2120
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_parser_set_input_string
YAML_DECLARE(void)
yaml_parser_set_input_string(yaml_parser_t *parser,
        const unsigned char *input, size_t size)
{
    assert(parser); /* Non-NULL parser object expected. */
    assert(!parser->read_handler);  /* You can set the source only once. */
    assert(input);  /* Non-NULL input string expected. */

    parser->read_handler = yaml_string_read_handler;
    parser->read_handler_data = parser;

    parser->input.string.start = input;
    parser->input.string.current = input;
    parser->input.string.end = input+size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x322d
jmp 0x324c
leaq 0x27e36(%rip), %rdi     # 0x2b06a
leaq 0x27e36(%rip), %rsi     # 0x2b071
movl $0x11e, %edx            # imm = 0x11E
leaq 0x27e85(%rip), %rcx     # 0x2b0cc
callq 0x2100
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x3259
jmp 0x3278
leaq 0x27ebe(%rip), %rdi     # 0x2b11e
leaq 0x27e0a(%rip), %rsi     # 0x2b071
movl $0x11f, %edx            # imm = 0x11F
leaq 0x27e59(%rip), %rcx     # 0x2b0cc
callq 0x2100
cmpq $0x0, -0x10(%rbp)
je 0x3281
jmp 0x32a0
leaq 0x27eac(%rip), %rdi     # 0x2b134
leaq 0x27de2(%rip), %rsi     # 0x2b071
movl $0x120, %edx            # imm = 0x120
leaq 0x27e31(%rip), %rcx     # 0x2b0cc
callq 0x2100
movq -0x8(%rbp), %rax
leaq 0x45(%rip), %rcx        # 0x32f0
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_string_read_handler
static int
yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,
        size_t *size_read)
{
    yaml_parser_t *parser = data;

    if (parser->input.string.current == parser->input.string.end) {
        *size_read = 0;
        return 1;
    }

    if (size > (size_t)(parser->input.string.end
                - parser->input.string.current)) {
        size = parser->input.string.end - parser->input.string.current;
    }

    memcpy(buffer, parser->input.string.current, size);
    parser->input.string.current += size;
    *size_read = size;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jne 0x3336
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x33a0
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x70(%rcx), %rcx
movq -0x30(%rbp), %rdx
movq 0x78(%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x3369
movq -0x30(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x78(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x2180
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
addq 0x78(%rax), %rcx
movq %rcx, 0x78(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_parser_set_input_file
YAML_DECLARE(void)
yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file)
{
    assert(parser); /* Non-NULL parser object expected. */
    assert(!parser->read_handler);  /* You can set the source only once. */
    assert(file);   /* Non-NULL file object expected. */

    parser->read_handler = yaml_file_read_handler;
    parser->read_handler_data = parser;

    parser->input.file = file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x33c9
jmp 0x33e8
leaq 0x27c9a(%rip), %rdi     # 0x2b06a
leaq 0x27c9a(%rip), %rsi     # 0x2b071
movl $0x131, %edx            # imm = 0x131
leaq 0x27d57(%rip), %rcx     # 0x2b13a
callq 0x2100
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x33f5
jmp 0x3414
leaq 0x27d22(%rip), %rdi     # 0x2b11e
leaq 0x27c6e(%rip), %rsi     # 0x2b071
movl $0x132, %edx            # imm = 0x132
leaq 0x27d2b(%rip), %rcx     # 0x2b13a
callq 0x2100
cmpq $0x0, -0x10(%rbp)
je 0x341d
jmp 0x343c
leaq 0x27d4f(%rip), %rdi     # 0x2b173
leaq 0x27c46(%rip), %rsi     # 0x2b071
movl $0x133, %edx            # imm = 0x133
leaq 0x27d03(%rip), %rcx     # 0x2b13a
callq 0x2100
movq -0x8(%rbp), %rax
leaq 0x29(%rip), %rcx        # 0x3470
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_parser_set_input
YAML_DECLARE(void)
yaml_parser_set_input(yaml_parser_t *parser,
        yaml_read_handler_t *handler, void *data)
{
    assert(parser); /* Non-NULL parser object expected. */
    assert(!parser->read_handler);  /* You can set the source only once. */
    assert(handler);    /* Non-NULL read handler expected. */

    parser->read_handler = handler;
    parser->read_handler_data = data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x34fd
jmp 0x351c
leaq 0x27b66(%rip), %rdi     # 0x2b06a
leaq 0x27b66(%rip), %rsi     # 0x2b071
movl $0x143, %edx            # imm = 0x143
leaq 0x27c61(%rip), %rcx     # 0x2b178
callq 0x2100
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x3529
jmp 0x3548
leaq 0x27bee(%rip), %rdi     # 0x2b11e
leaq 0x27b3a(%rip), %rsi     # 0x2b071
movl $0x144, %edx            # imm = 0x144
leaq 0x27c35(%rip), %rcx     # 0x2b178
callq 0x2100
cmpq $0x0, -0x10(%rbp)
je 0x3551
jmp 0x3570
leaq 0x27bd4(%rip), %rdi     # 0x2b12c
leaq 0x27b12(%rip), %rsi     # 0x2b071
movl $0x145, %edx            # imm = 0x145
leaq 0x27c0d(%rip), %rcx     # 0x2b178
callq 0x2100
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_event_delete
YAML_DECLARE(void)
yaml_event_delete(yaml_event_t *event)
{
    yaml_tag_directive_t *tag_directive;

    assert(event);  /* Non-NULL event object expected. */

    switch (event->type)
    {
        case YAML_DOCUMENT_START_EVENT:
            yaml_free(event->data.document_start.version_directive);
            for (tag_directive = event->data.document_start.tag_directives.start;
                    tag_directive != event->data.document_start.tag_directives.end;
                    tag_directive++) {
                yaml_free(tag_directive->handle);
                yaml_free(tag_directive->prefix);
            }
            yaml_free(event->data.document_start.tag_directives.start);
            break;

        case YAML_ALIAS_EVENT:
            yaml_free(event->data.alias.anchor);
            break;

        case YAML_SCALAR_EVENT:
            yaml_free(event->data.scalar.anchor);
            yaml_free(event->data.scalar.tag);
            yaml_free(event->data.scalar.value);
            break;

        case YAML_SEQUENCE_START_EVENT:
            yaml_free(event->data.sequence_start.anchor);
            yaml_free(event->data.sequence_start.tag);
            break;

        case YAML_MAPPING_START_EVENT:
            yaml_free(event->data.mapping_start.anchor);
            yaml_free(event->data.mapping_start.tag);
            break;

        default:
            break;
    }

    memset(event, 0, sizeof(yaml_event_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3cc5
jmp 0x3ce4
leaq 0x27838(%rip), %rdi     # 0x2b504
leaq 0x2739e(%rip), %rsi     # 0x2b071
movl $0x3d7, %edx            # imm = 0x3D7
leaq 0x27c0f(%rip), %rcx     # 0x2b8ee
callq 0x2100
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x6, %eax
ja 0x3ddd
movq -0x18(%rbp), %rax
leaq 0x27341(%rip), %rcx     # 0x2b048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x3d5e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2140
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2140
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0x3d29
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2140
jmp 0x3ddf
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2140
jmp 0x3ddf
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2140
jmp 0x3ddf
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2140
jmp 0x3ddf
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2140
jmp 0x3ddf
jmp 0x3ddf
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x2120
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_emitter_set_output_string
YAML_DECLARE(void)
yaml_emitter_set_output_string(yaml_emitter_t *emitter,
        unsigned char *output, size_t size, size_t *size_written)
{
    assert(emitter);    /* Non-NULL emitter object expected. */
    assert(!emitter->write_handler);    /* You can set the output only once. */
    assert(output);     /* Non-NULL output string expected. */

    emitter->write_handler = yaml_string_write_handler;
    emitter->write_handler_data = emitter;

    emitter->output.string.buffer = output;
    emitter->output.string.size = size;
    emitter->output.string.size_written = size_written;
    *size_written = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e21
jmp 0x3e40
leaq 0x273ed(%rip), %rdi     # 0x2b215
leaq 0x27242(%rip), %rsi     # 0x2b071
movl $0x1c6, %edx            # imm = 0x1C6
leaq 0x2743b(%rip), %rcx     # 0x2b276
callq 0x2100
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3e4d
jmp 0x3e6c
leaq 0x2747b(%rip), %rdi     # 0x2b2cf
leaq 0x27216(%rip), %rsi     # 0x2b071
movl $0x1c7, %edx            # imm = 0x1C7
leaq 0x2740f(%rip), %rcx     # 0x2b276
callq 0x2100
cmpq $0x0, -0x10(%rbp)
je 0x3e75
jmp 0x3e94
leaq 0x2746b(%rip), %rdi     # 0x2b2e7
leaq 0x271ee(%rip), %rsi     # 0x2b071
movl $0x1c8, %edx            # imm = 0x1C8
leaq 0x273e7(%rip), %rcx     # 0x2b276
callq 0x2100
movq -0x8(%rbp), %rax
leaq 0x51(%rip), %rcx        # 0x3ef0
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_string_write_handler
static int
yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)
{
    yaml_emitter_t *emitter = data;

    if (emitter->output.string.size + *emitter->output.string.size_written
            < size) {
        memcpy(emitter->output.string.buffer
                + *emitter->output.string.size_written,
                buffer,
                emitter->output.string.size
                - *emitter->output.string.size_written);
        *emitter->output.string.size_written = emitter->output.string.size;
        return 0;
    }

    memcpy(emitter->output.string.buffer
            + *emitter->output.string.size_written, buffer, size);
    *emitter->output.string.size_written += size;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x30(%rcx), %rcx
addq (%rcx), %rax
cmpq -0x20(%rbp), %rax
jae 0x3f70
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
addq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
subq (%rax), %rdx
callq 0x2180
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3fa9
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
addq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2180
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_emitter_set_output_file
YAML_DECLARE(void)
yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file)
{
    assert(emitter);    /* Non-NULL emitter object expected. */
    assert(!emitter->write_handler);    /* You can set the output only once. */
    assert(file);       /* Non-NULL file object expected. */

    emitter->write_handler = yaml_file_write_handler;
    emitter->write_handler_data = emitter;

    emitter->output.file = file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3fd9
jmp 0x3ff8
leaq 0x27235(%rip), %rdi     # 0x2b215
leaq 0x2708a(%rip), %rsi     # 0x2b071
movl $0x1da, %edx            # imm = 0x1DA
leaq 0x272fb(%rip), %rcx     # 0x2b2ee
callq 0x2100
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4005
jmp 0x4024
leaq 0x272c3(%rip), %rdi     # 0x2b2cf
leaq 0x2705e(%rip), %rsi     # 0x2b071
movl $0x1db, %edx            # imm = 0x1DB
leaq 0x272cf(%rip), %rcx     # 0x2b2ee
callq 0x2100
cmpq $0x0, -0x10(%rbp)
je 0x402d
jmp 0x404c
leaq 0x2713f(%rip), %rdi     # 0x2b173
leaq 0x27036(%rip), %rsi     # 0x2b071
movl $0x1dc, %edx            # imm = 0x1DC
leaq 0x272a7(%rip), %rcx     # 0x2b2ee
callq 0x2100
movq -0x8(%rbp), %rax
leaq 0x29(%rip), %rcx        # 0x4080
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_emitter_set_output
YAML_DECLARE(void)
yaml_emitter_set_output(yaml_emitter_t *emitter,
        yaml_write_handler_t *handler, void *data)
{
    assert(emitter);    /* Non-NULL emitter object expected. */
    assert(!emitter->write_handler);    /* You can set the output only once. */
    assert(handler);    /* Non-NULL handler object expected. */

    emitter->write_handler = handler;
    emitter->write_handler_data = data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x40ed
jmp 0x410c
leaq 0x27121(%rip), %rdi     # 0x2b215
leaq 0x26f76(%rip), %rsi     # 0x2b071
movl $0x1ec, %edx            # imm = 0x1EC
leaq 0x27223(%rip), %rcx     # 0x2b32a
callq 0x2100
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4119
jmp 0x4138
leaq 0x271af(%rip), %rdi     # 0x2b2cf
leaq 0x26f4a(%rip), %rsi     # 0x2b071
movl $0x1ed, %edx            # imm = 0x1ED
leaq 0x271f7(%rip), %rcx     # 0x2b32a
callq 0x2100
cmpq $0x0, -0x10(%rbp)
je 0x4141
jmp 0x4160
leaq 0x26fe4(%rip), %rdi     # 0x2b12c
leaq 0x26f22(%rip), %rsi     # 0x2b071
movl $0x1ee, %edx            # imm = 0x1EE
leaq 0x271cf(%rip), %rcx     # 0x2b32a
callq 0x2100
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_stream_start_event_initialize
YAML_DECLARE(int)
yaml_stream_start_event_initialize(yaml_event_t *event,
        yaml_encoding_t encoding)
{
    yaml_mark_t mark = { 0, 0, 0 };

    assert(event);  /* Non-NULL event object is expected. */

    STREAM_START_EVENT_INIT(*event, encoding, mark, mark);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2120
cmpq $0x0, -0x8(%rbp)
je 0x4408
jmp 0x4427
leaq 0x270f5(%rip), %rdi     # 0x2b504
leaq 0x26c5b(%rip), %rsi     # 0x2b071
movl $0x29c, %edx            # imm = 0x29C
leaq 0x270e8(%rip), %rcx     # 0x2b50a
callq 0x2100
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x2120
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x60(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nop