LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
cmpl $0x1, %edi
jle 0x28aa
movq 0x8(%rsi), %rdi
callq 0x28c4
callq 0x2a74
cmpl $0x3, %eax
jne 0x2890
callq 0x2417
testl %eax, %eax
je 0x2895
movl %eax, %r14d
leal -0x1(%r14), %edi
callq 0x23bc
leaq 0x40e1(%rip), %rax      # 0x6960
xorl %ebx, %ebx
cmpb $0x1, (%rax)
jne 0x28a3
movl %r14d, %edi
callq 0x25da
jmp 0x28a3
pushq $-0x1
popq %rbx
jmp 0x28a3
leaq 0x885(%rip), %rdi       # 0x3121
callq 0x21e0
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rsi), %rsi
leaq 0x83f(%rip), %rdi       # 0x30f3
xorl %eax, %eax
callq 0x2030
pushq $0x1
popq %rdi
callq 0x2170
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
leaq 0x26c1(%rip), %r12      # 0x5150
xorl %r13d, %r13d
cmpq $0x3, %r13
je 0x2afe
leaq 0x1(%r13), %r14
leaq -0x430(%rbp), %rbx
movq %rbx, %rdi
leaq 0x691(%rip), %rsi       # 0x313e
movl %r14d, %edx
xorl %eax, %eax
callq 0x2040
movq %rbx, %rdi
leaq 0x698(%rip), %rsi       # 0x3159
callq 0x2160
testq %rax, %rax
je 0x2b13
movq %rax, %rbx
xorl %r15d, %r15d
shlq $0xb, %r13
movq %rbx, %rdi
callq 0x2210
cmpl $-0x1, %eax
je 0x2af1
movl %r15d, %ecx
incl %r15d
leaq (%r12,%r13), %rdx
movb %al, (%rcx,%rdx)
jmp 0x2ad5
movq %rbx, %rdi
callq 0x2140
movq %r14, %r13
jmp 0x2a92
pushq $0x3
popq %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x24be(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
leaq 0x637(%rip), %rsi       # 0x315b
leaq -0x430(%rbp), %rdx
xorl %eax, %eax
callq 0x21b0
movl %r13d, %eax
jmp 0x2b01
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x2a23(%rip), %r15      # 0x3fe0
movq (%r15), %rdi
callq 0x1030
xorl %ebx, %ebx
leaq 0x2b32(%rip), %r12      # 0x4100
pushq $0x23
popq %rbp
cmpq $0x50, %rbx
je 0x1632
xorl %r14d, %r14d
cmpl (%r12,%rbx,8), %r14d
jge 0x1601
movq (%r15), %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x15fc
movq (%r15), %rdi
movl %ebp, %esi
callq 0x1150
incl %r14d
jmp 0x15da
movl 0x4(%r12,%rbx,8), %r14d
cmpl $0x17, %r14d
jg 0x162d
movq (%r15), %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x1628
movq (%r15), %rdi
movl %ebp, %esi
callq 0x1150
incl %r14d
jmp 0x1606
incq %rbx
jmp 0x15d1
movl 0x2ac4(%rip), %ecx      # 0x40fc
movl 0x2ab5(%rip), %r8d      # 0x40f4
leaq 0x9f8(%rip), %rdx       # 0x203e
xorl %edi, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10d0
movq 0x2d28(%rip), %rbx      # 0x4380
testq %rbx, %rbx
je 0x168c
testq %rbx, %rbx
je 0x168c
cmpl $0x0, 0xc(%rbx)
jne 0x1686
movq (%r15), %rdi
movl 0x4(%rbx), %edx
movl 0x8(%rbx), %esi
callq 0x1130
cmpl $-0x1, %eax
je 0x1686
movq (%r15), %rdi
movzbl (%rbx), %esi
callq 0x1150
movq 0x10(%rbx), %rbx
jmp 0x165d
movq (%r15), %rdi
movl 0x2a5b(%rip), %esi      # 0x40f0
movzbl 0x2a5c(%rip), %eax      # 0x40f8
leal (%rax,%rax,2), %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x16b4
movq (%r15), %rdi
pushq $0x3e
popq %rsi
callq 0x1150
movq (%r15), %rdi
movl 0x2a33(%rip), %esi      # 0x40f0
movzbl 0x2a34(%rip), %eax      # 0x40f8
leal (%rax,%rax,2), %edx
callq 0x1130
movq (%r15), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %edi, %ebp
pushq $0x18
popq %rdi
callq 0x1120
movq %rax, %rbx
movq 0x2c8d(%rip), %rcx      # 0x4380
testq %rcx, %rcx
je 0x170a
movq %rcx, %rax
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x16f8
addq $0x10, %rax
jmp 0x1711
leaq 0x2c6f(%rip), %rax      # 0x4380
movq %rbx, (%rax)
movb %bpl, (%rbx)
andq $0x0, 0x10(%rbx)
andl $0x0, 0xc(%rbx)
cmpb $0x24, %bpl
je 0x1739
movzbl %bpl, %eax
cmpl $0x40, %eax
je 0x1739
cmpl $0x2d, %eax
je 0x1765
cmpl $0x2b, %eax
jne 0x177d
movl $0x4f, 0x4(%rbx)
movl 0x2c32(%rip), %ebp      # 0x4378
callq 0x1100
movslq 0x2c2a(%rip), %rcx      # 0x437c
movslq 0x2c1f(%rip), %rdx      # 0x4378
subq %rdx, %rcx
cqto
idivq %rcx
addl %ebp, %edx
jmp 0x177a
movzbl 0x298c(%rip), %eax      # 0x40f8
leal (%rax,%rax,2), %eax
incl %eax
movl %eax, 0x4(%rbx)
movl 0x2976(%rip), %edx      # 0x40f0
movl %edx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kobolt[P]curses-collection/cavescroll/cavescroll.c
// Function: generate_cave
static void generate_cave(void)
{
  int i;

  /* Shift entire cave. */
  for (i = 0; i < (CAVE_WIDTH - 1); i++) {
    cave[i].top    = cave[i + 1].top;
    cave[i].bottom = cave[i + 1].bottom;
  }

  objects_shift();

  /* Next top. */
  switch (random() % 5) {
  case 0:
    cave[CAVE_WIDTH - 1].top--;
    if (cave[CAVE_WIDTH - 1].top < CAVE_PADDING_TOP) {
      cave[CAVE_WIDTH - 1].top++;
    }
    break;
  case 1:
    cave[CAVE_WIDTH - 1].top++;
    if (cave[CAVE_WIDTH - 1].top >
      cave[CAVE_WIDTH - 1].bottom - CAVE_OPENING_MIN) {
      cave[CAVE_WIDTH - 1].top--;
    }
    break;
  }

  /* Next bottom. */
  switch (random() % 5) {
  case 0:
    cave[CAVE_WIDTH - 1].bottom++;
    if (cave[CAVE_WIDTH - 1].bottom > CAVE_HEIGHT - CAVE_PADDING_BOTTOM) {
      cave[CAVE_WIDTH - 1].bottom--;
    }
    break;
  case 1:
    cave[CAVE_WIDTH - 1].bottom--;
    if (cave[CAVE_WIDTH - 1].bottom <=
      cave[CAVE_WIDTH - 1].top + CAVE_OPENING_MIN) {
      cave[CAVE_WIDTH - 1].bottom++;
    }
    break;
  }

  /* Possible item. */
  switch (random() % 20) {
  case 0:
    object_spawn(GRAPHICS_MONEY);
    break;
  case 1:
    object_spawn(GRAPHICS_AMMO);
    break;
  case 2:
    object_spawn(GRAPHICS_ENEMY);
    break;
  default:
    break;
  }
}

// Assembly:
pushq $0x1
popq %rax
leaq 0x2972(%rip), %rcx      # 0x4100
cmpq $0x50, %rax
je 0x17a2
movq (%rcx,%rax,8), %rdx
movq %rdx, -0x8(%rcx,%rax,8)
incq %rax
jmp 0x178e
pushq %rbx
movq 0x2bd6(%rip), %rax      # 0x4380
testq %rax, %rax
je 0x17bd
testq %rax, %rax
je 0x17bd
decl 0x4(%rax)
movq 0x10(%rax), %rax
jmp 0x17af
callq 0x1100
pushq $0x5
popq %rbx
cqto
idivq %rbx
cmpq $0x1, %rdx
je 0x17e7
testq %rdx, %rdx
jne 0x1805
movl 0x2b9d(%rip), %eax      # 0x4378
xorl %ecx, %ecx
cmpl $0x3, %eax
setge %cl
subl %ecx, %eax
jmp 0x17ff
movl 0x2b8b(%rip), %ecx      # 0x4378
movl 0x2b89(%rip), %edx      # 0x437c
addl $-0x3, %edx
xorl %eax, %eax
cmpl %edx, %ecx
setl %al
addl %ecx, %eax
movl %eax, 0x2b73(%rip)      # 0x4378
callq 0x1100
cqto
idivq %rbx
cmpq $0x1, %rdx
je 0x182c
testq %rdx, %rdx
jne 0x1849
movl 0x2b5c(%rip), %ecx      # 0x437c
xorl %eax, %eax
cmpl $0x16, %ecx
setl %al
addl %ecx, %eax
jmp 0x1843
movl 0x2b4a(%rip), %eax      # 0x437c
leal -0x1(%rax), %ecx
movl 0x2b3d(%rip), %edx      # 0x4378
addl $0x3, %edx
cmpl %edx, %ecx
cmovgl %ecx, %eax
movl %eax, 0x2b33(%rip)      # 0x437c
callq 0x1100
pushq $0x14
popq %rcx
cqto
idivq %rcx
cmpq $0x2, %rdx
popq %rbx
ja 0x1871
shll $0x3, %edx
movl $0x402b24, %eax         # imm = 0x402B24
movl %edx, %ecx
shrl %cl, %eax
movzbl %al, %edi
jmp 0x16dc
retq
// File: /workspace/github_c_makefile_star2_O2/kobolt[P]curses-collection/cavescroll/cavescroll.c
// Function: objects_col_detect
static void objects_col_detect(void)
{
  object_t *curr_a, *curr_b;

  if (objects == NULL)
    return;

  for (curr_a = objects; curr_a != NULL; curr_a = curr_a->next) {
    if (curr_a->removed)
      continue;

    switch (curr_a->type) {
    case GRAPHICS_SHOT:
      if (mvinch(curr_a->y, curr_a->x) == GRAPHICS_CAVE) {
        curr_a->removed = 1;
      }
      for (curr_b = objects; curr_b != NULL; curr_b = curr_b->next) {
        if (curr_b->removed)
          continue;
        if (curr_a == curr_b)
          continue;
        if (curr_a->x == curr_b->x && curr_a->y == curr_b->y) {
          flash();
          if (curr_b->type == GRAPHICS_ENEMY)
            score += 5;
          curr_a->removed = 1;
          curr_b->removed = 1;
        }
      }
      break;

    case GRAPHICS_MONEY:
      if ((curr_a->x == player_x) && (curr_a->y == player_y)) {
        score++;
        curr_a->removed = 1;
      }
      break;

    case GRAPHICS_AMMO:
      if ((curr_a->x == player_x) && (curr_a->y == player_y)) {
        ammo++;
        curr_a->removed = 1;
      }
      break;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x2abf(%rip), %rbx      # 0x4380
testq %rbx, %rbx
je 0x19d2
leaq 0x2823(%rip), %r15      # 0x40f4
movq 0x2708(%rip), %r12      # 0x3fe0
leaq 0x2aa1(%rip), %r14      # 0x4380
pushq $0x1
popq %rbp
testq %rbx, %rbx
je 0x19d2
cmpl $0x0, 0xc(%rbx)
je 0x18f7
movq 0x10(%rbx), %rbx
jmp 0x18e2
movzbl (%rbx), %eax
cmpl $0x24, %eax
je 0x199b
cmpl $0x2b, %eax
je 0x1980
cmpl $0x2d, %eax
jne 0x18f1
movq (%r12), %rdi
movl 0x4(%rbx), %edx
movl 0x8(%rbx), %esi
callq 0x1130
cmpl $-0x1, %eax
je 0x1936
movq (%r12), %rdi
callq 0x1110
cmpl $0x23, %eax
jne 0x1936
movl $0x1, 0xc(%rbx)
movq %r14, %r13
movq (%r13), %r13
testq %r13, %r13
je 0x18f1
cmpq %r13, %rbx
je 0x197a
cmpl $0x0, 0xc(%r13)
jne 0x197a
movl 0x4(%rbx), %eax
cmpl 0x4(%r13), %eax
jne 0x197a
movl 0x8(%rbx), %eax
cmpl 0x8(%r13), %eax
jne 0x197a
callq 0x10c0
cmpb $0x40, (%r13)
jne 0x1973
addl $0x5, 0x2789(%rip)      # 0x40fc
movl %ebp, 0xc(%rbx)
movl %ebp, 0xc(%r13)
addq $0x10, %r13
jmp 0x1939
movzbl 0x2771(%rip), %eax      # 0x40f8
leal (%rax,%rax,2), %eax
cmpl %eax, 0x4(%rbx)
jne 0x18f1
movl 0x8(%rbx), %ecx
movq %r15, %rax
jmp 0x19b8
movzbl 0x2756(%rip), %eax      # 0x40f8
leal (%rax,%rax,2), %eax
cmpl %eax, 0x4(%rbx)
jne 0x18f1
movl 0x8(%rbx), %ecx
leaq 0x2744(%rip), %rax      # 0x40fc
cmpl 0x2732(%rip), %ecx      # 0x40f0
jne 0x18f1
incl (%rax)
movl $0x1, 0xc(%rbx)
jmp 0x18f1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rdx), %rsi
subq %rdi, %rsi
addq %rsi, %rsi
callq 0x2130
testq %rax, %rax
je 0x23cc
movq %rax, %r12
movq (%rbx), %rdx
movq (%r14), %r13
subq %r13, %rdx
leaq (%rax,%rdx), %rdi
xorl %esi, %esi
callq 0x2120
movq (%r15), %rax
subq %r13, %rax
addq %r12, %rax
movq %rax, (%r15)
movq (%rbx), %rax
subq (%r14), %rax
leaq (%r12,%rax,2), %rax
movq %rax, (%rbx)
movq %r12, (%r14)
pushq $0x1
popq %rax
jmp 0x23ce
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rcx), %rax
pushq $0x1
popq %rbx
cmpq (%r8), %rax
je 0x243b
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbp
movq (%r13), %rax
movq (%r15), %rdi
subq %rdi, %rax
movq (%r12), %rdx
movq (%r14), %rsi
subq %rsi, %rdx
cmpq %rdx, %rax
jg 0x242c
movq %rbp, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x20a0
testl %eax, %eax
jne 0x23fd
xorl %ebx, %ebx
jmp 0x243b
callq 0x2170
movq (%r12), %rax
subq (%r14), %rax
addq %rax, (%r15)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rdx), %rsi
subq %rdi, %rsi
addq %rsi, %rsi
callq 0x2130
testq %rax, %rax
je 0x2491
movq (%r15), %rcx
subq (%r14), %rcx
addq %rax, %rcx
movq %rcx, (%r15)
movq (%rbx), %rcx
subq (%r14), %rcx
leaq (%rax,%rcx,2), %rcx
movq %rcx, (%rbx)
movq %rax, (%r14)
pushq $0x1
popq %rax
jmp 0x2493
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
movq (%rsi), %rax
xorq %rdi, %rax
movq (%rdx), %rsi
movq (%rcx), %rdx
movq %rsi, %rcx
xorq %rdx, %rcx
orq %rax, %rcx
jne 0x250b
subq %rdi, %rsi
addq %rsi, %rsi
callq 0x2130
testq %rax, %rax
je 0x252e
movq %rax, %rdi
movq (%rbx), %rax
subq (%r15), %rax
addq %rdi, %rax
movq %rax, (%rbx)
movq (%r14), %rax
subq (%r15), %rax
addq %rdi, %rax
movq %rax, (%r14)
movq (%r12), %rax
subq (%r15), %rax
leaq (%rdi,%rax,2), %rax
movq %rax, (%r12)
movq %rdi, (%r15)
movq (%r14), %rsi
movq (%r12), %rdx
pushq $0x1
popq %rbp
cmpq %rdx, %rsi
jne 0x2544
movq (%rbx), %rsi
cmpq %rdx, %rsi
je 0x2532
subq %rsi, %rdx
callq 0x21e0
movq (%r14), %rax
movq (%rbx), %rdx
movq (%r15), %rdi
jmp 0x2535
xorl %ebp, %ebp
jmp 0x2544
movq %rdx, %rax
subq %rdx, %rax
addq %rdi, %rax
movq %rax, (%r14)
movq (%r15), %rax
movq %rax, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_parser_delete
YAML_DECLARE(void)
yaml_parser_delete(yaml_parser_t *parser)
{
    assert(parser); /* Non-NULL parser object expected. */

    BUFFER_DEL(parser, parser->raw_buffer);
    BUFFER_DEL(parser, parser->buffer);
    while (!QUEUE_EMPTY(parser, parser->tokens)) {
        yaml_token_delete(&DEQUEUE(parser, parser->tokens));
    }
    QUEUE_DEL(parser, parser->tokens);
    STACK_DEL(parser, parser->indents);
    STACK_DEL(parser, parser->simple_keys);
    STACK_DEL(parser, parser->states);
    STACK_DEL(parser, parser->marks);
    while (!STACK_EMPTY(parser, parser->tag_directives)) {
        yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
        yaml_free(tag_directive.handle);
        yaml_free(tag_directive.prefix);
    }
    STACK_DEL(parser, parser->tag_directives);

    memset(parser, 0, sizeof(yaml_parser_t));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x29ff
movq %rdi, %rbx
movq 0xb0(%rdi), %rdi
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, 0xb0(%rbx)
andq $0x0, 0xc0(%rbx)
movq 0x88(%rbx), %rdi
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
andq $0x0, 0x98(%rbx)
movq 0x118(%rbx), %rdi
cmpq 0x120(%rbx), %rdi
je 0x291a
leaq 0x50(%rdi), %rax
movq %rax, 0x118(%rbx)
callq 0x2220
jmp 0x28f8
movq 0x108(%rbx), %rdi
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, 0x118(%rbx)
movups %xmm0, 0x108(%rbx)
movq 0x138(%rbx), %rdi
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, 0x138(%rbx)
andq $0x0, 0x148(%rbx)
movq 0x158(%rbx), %rdi
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, 0x158(%rbx)
andq $0x0, 0x168(%rbx)
movq 0x170(%rbx), %rdi
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, 0x170(%rbx)
andq $0x0, 0x180(%rbx)
movq 0x190(%rbx), %rdi
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, 0x190(%rbx)
andq $0x0, 0x1a0(%rbx)
movq 0x1a8(%rbx), %rdi
movq 0x1b8(%rbx), %rax
cmpq %rax, %rdi
je 0x29e4
leaq -0x10(%rax), %rcx
movq %rcx, 0x1b8(%rbx)
movq -0x10(%rax), %rdi
movq -0x8(%rax), %r14
callq 0x2040
movq %r14, %rdi
callq 0x2040
jmp 0x29af
callq 0x2040
movl $0x1e0, %edx            # imm = 0x1E0
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2120
leaq 0x1362c(%rip), %rdi     # 0x16032
leaq 0x1362c(%rip), %rsi     # 0x16039
leaq 0x13657(%rip), %rcx     # 0x1606b
movl $0xd8, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
testq %rdi, %rdi
je 0x2a73
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x15, %eax
ja 0x2a5b
movl $0x2c0000, %ecx         # imm = 0x2C0000
btl %eax, %ecx
jae 0x2a3c
pushq $0x8
jmp 0x2a51
movl $0x100010, %ecx         # imm = 0x100010
btl %eax, %ecx
jae 0x2a5b
movq 0x8(%rbx), %rdi
callq 0x2040
pushq $0x10
popq %rax
movq (%rbx,%rax), %rdi
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
popq %rbx
retq
leaq 0x146e6(%rip), %rdi     # 0x17160
leaq 0x135b8(%rip), %rsi     # 0x16039
leaq 0x13a1d(%rip), %rcx     # 0x164a5
movl $0x244, %edx            # imm = 0x244
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %rax
testq %rdi, %rdi
je 0x2ac4
cmpq $0x0, 0x58(%rdi)
jne 0x2ae3
testq %rsi, %rsi
je 0x2b02
leaq 0x76(%rip), %rax        # 0x2b21
movq %rax, 0x58(%rdi)
movq %rdi, 0x60(%rdi)
movq %rsi, 0x68(%rdi)
movq %rsi, 0x78(%rdi)
addq %rsi, %rdx
movq %rdx, 0x70(%rdi)
popq %rax
retq
leaq 0x13567(%rip), %rdi     # 0x16032
leaq 0x13567(%rip), %rsi     # 0x16039
leaq 0x135bb(%rip), %rcx     # 0x16094
movl $0x11e, %edx            # imm = 0x11E
callq 0x2100
leaq 0x135fc(%rip), %rdi     # 0x160e6
leaq 0x13548(%rip), %rsi     # 0x16039
leaq 0x1359c(%rip), %rcx     # 0x16094
movl $0x11f, %edx            # imm = 0x11F
callq 0x2100
leaq 0x135f3(%rip), %rdi     # 0x160fc
leaq 0x13529(%rip), %rsi     # 0x16039
leaq 0x1357d(%rip), %rcx     # 0x16094
movl $0x120, %edx            # imm = 0x120
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq 0x70(%rdi), %r14
movq 0x78(%rdi), %rax
cmpq %r14, %rax
je 0x2b57
movq %rdi, %r15
subq %rax, %r14
cmpq %rdx, %r14
cmovaeq %rdx, %r14
movq %rsi, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2170
addq %r14, 0x78(%r15)
jmp 0x2b5a
xorl %r14d, %r14d
movq %r14, (%rbx)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
testq %rdi, %rdi
je 0x2b8d
cmpq $0x0, 0x58(%rdi)
jne 0x2bac
testq %rsi, %rsi
je 0x2bcb
leaq 0x6b(%rip), %rax        # 0x2bea
movq %rax, 0x58(%rdi)
movq %rdi, 0x60(%rdi)
movq %rsi, 0x68(%rdi)
popq %rax
retq
leaq 0x1349e(%rip), %rdi     # 0x16032
leaq 0x1349e(%rip), %rsi     # 0x16039
leaq 0x13560(%rip), %rcx     # 0x16102
movl $0x131, %edx            # imm = 0x131
callq 0x2100
leaq 0x13533(%rip), %rdi     # 0x160e6
leaq 0x1347f(%rip), %rsi     # 0x16039
leaq 0x13541(%rip), %rcx     # 0x16102
movl $0x132, %edx            # imm = 0x132
callq 0x2100
leaq 0x13569(%rip), %rdi     # 0x1613b
leaq 0x13460(%rip), %rsi     # 0x16039
leaq 0x13522(%rip), %rcx     # 0x16102
movl $0x133, %edx            # imm = 0x133
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %rax
testq %rdi, %rdi
je 0x2c3f
cmpq $0x0, 0x58(%rdi)
jne 0x2c5e
testq %rsi, %rsi
je 0x2c7d
movq %rsi, 0x58(%rdi)
movq %rdx, 0x60(%rdi)
popq %rax
retq
leaq 0x133ec(%rip), %rdi     # 0x16032
leaq 0x133ec(%rip), %rsi     # 0x16039
leaq 0x134ec(%rip), %rcx     # 0x16140
movl $0x143, %edx            # imm = 0x143
callq 0x2100
leaq 0x13481(%rip), %rdi     # 0x160e6
leaq 0x133cd(%rip), %rsi     # 0x16039
leaq 0x134cd(%rip), %rcx     # 0x16140
movl $0x144, %edx            # imm = 0x144
callq 0x2100
leaq 0x13470(%rip), %rdi     # 0x160f4
leaq 0x133ae(%rip), %rsi     # 0x16039
leaq 0x134ae(%rip), %rcx     # 0x16140
movl $0x145, %edx            # imm = 0x145
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_emitter_delete
YAML_DECLARE(void)
yaml_emitter_delete(yaml_emitter_t *emitter)
{
    assert(emitter);    /* Non-NULL emitter object expected. */

    BUFFER_DEL(emitter, emitter->buffer);
    BUFFER_DEL(emitter, emitter->raw_buffer);
    STACK_DEL(emitter, emitter->states);
    while (!QUEUE_EMPTY(emitter, emitter->events)) {
        yaml_event_delete(&DEQUEUE(emitter, emitter->events));
    }
    QUEUE_DEL(emitter, emitter->events);
    STACK_DEL(emitter, emitter->indents);
    while (!STACK_EMPTY(empty, emitter->tag_directives)) {
        yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives);
        yaml_free(tag_directive.handle);
        yaml_free(tag_directive.prefix);
    }
    STACK_DEL(emitter, emitter->tag_directives);
    yaml_free(emitter->anchors);

    memset(emitter, 0, sizeof(yaml_emitter_t));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3040
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
andq $0x0, 0x48(%rbx)
movq 0x58(%rbx), %rdi
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
andq $0x0, 0x68(%rbx)
movq 0x90(%rbx), %rdi
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
andq $0x0, 0xa0(%rbx)
movq 0xc0(%rbx), %rdi
cmpq 0xc8(%rbx), %rdi
je 0x2f98
leaq 0x68(%rdi), %rax
movq %rax, 0xc0(%rbx)
callq 0x21f0
jmp 0x2f76
movq 0xb0(%rbx), %rdi
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%rbx)
movups %xmm0, 0xb0(%rbx)
movq 0xd0(%rbx), %rdi
callq 0x2040
leaq 0xe8(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%rbx)
andq $0x0, 0xe0(%rbx)
movq 0xe8(%rbx), %rdi
movq 0xf8(%rbx), %rax
cmpq %rax, %rdi
je 0x300f
leaq -0x10(%rax), %rcx
movq %rcx, 0xf8(%rbx)
movq -0x10(%rax), %rdi
movq -0x8(%rax), %r14
callq 0x2040
movq %r14, %rdi
callq 0x2040
jmp 0x2fda
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq 0x198(%rbx), %rdi
callq 0x2040
movl $0x1b0, %edx            # imm = 0x1B0
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2120
leaq 0x13196(%rip), %rdi     # 0x161dd
leaq 0x12feb(%rip), %rsi     # 0x16039
leaq 0x131be(%rip), %rcx     # 0x16213
movl $0x184, %edx            # imm = 0x184
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3110
movq %rdi, %rbx
movl (%rdi), %eax
addl $-0x3, %eax
cmpl $0x6, %eax
ja 0x30eb
leaq 0x12f8f(%rip), %rcx     # 0x16010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
callq 0x2040
leaq 0x10(%rbx), %r14
jmp 0x30e3
movq 0x8(%rbx), %rdi
callq 0x2040
movq 0x10(%rbx), %rdi
callq 0x2040
leaq 0x18(%rbx), %r14
jmp 0x30e3
movq 0x8(%rbx), %rdi
callq 0x2040
leaq 0x10(%rbx), %r14
movq 0x10(%rbx), %r15
cmpq 0x18(%rbx), %r15
je 0x30e3
movq (%r15), %rdi
callq 0x2040
movq 0x8(%r15), %rdi
callq 0x2040
addq $0x10, %r15
jmp 0x30c2
leaq 0x8(%rbx), %r14
movq (%r14), %rdi
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
andq $0x0, 0x60(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x133b5(%rip), %rdi     # 0x164cc
leaq 0x12f1b(%rip), %rsi     # 0x16039
leaq 0x13791(%rip), %rcx     # 0x168b6
movl $0x3d7, %edx            # imm = 0x3D7
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %rax
testq %rdi, %rdi
je 0x3162
cmpq $0x0, 0x10(%rdi)
jne 0x3181
testq %rsi, %rsi
je 0x31a0
leaq 0x77(%rip), %rax        # 0x31bf
movq %rax, 0x10(%rdi)
movq %rdi, 0x18(%rdi)
movq %rsi, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
andq $0x0, (%rcx)
popq %rax
retq
leaq 0x13074(%rip), %rdi     # 0x161dd
leaq 0x12ec9(%rip), %rsi     # 0x16039
leaq 0x130c7(%rip), %rcx     # 0x1623e
movl $0x1c6, %edx            # imm = 0x1C6
callq 0x2100
leaq 0x1310f(%rip), %rdi     # 0x16297
leaq 0x12eaa(%rip), %rsi     # 0x16039
leaq 0x130a8(%rip), %rcx     # 0x1623e
movl $0x1c7, %edx            # imm = 0x1C7
callq 0x2100
leaq 0x13108(%rip), %rdi     # 0x162af
leaq 0x12e8b(%rip), %rsi     # 0x16039
leaq 0x13089(%rip), %rcx     # 0x1623e
movl $0x1c8, %edx            # imm = 0x1C8
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rdx
movq 0x30(%rdi), %rax
movq (%rax), %rax
leaq (%rax,%rdx), %rcx
movq 0x20(%rdi), %rdi
addq %rax, %rdi
cmpq %r14, %rcx
jae 0x31fb
subq %rax, %rdx
callq 0x2170
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0x320d
movq %r14, %rdx
callq 0x2170
movq 0x30(%rbx), %rax
addq %r14, (%rax)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
testq %rdi, %rdi
je 0x323c
cmpq $0x0, 0x10(%rdi)
jne 0x325b
testq %rsi, %rsi
je 0x327a
leaq 0x6b(%rip), %rax        # 0x3299
movq %rax, 0x10(%rdi)
movq %rdi, 0x18(%rdi)
movq %rsi, 0x20(%rdi)
popq %rax
retq
leaq 0x12f9a(%rip), %rdi     # 0x161dd
leaq 0x12def(%rip), %rsi     # 0x16039
leaq 0x13065(%rip), %rcx     # 0x162b6
movl $0x1da, %edx            # imm = 0x1DA
callq 0x2100
leaq 0x13035(%rip), %rdi     # 0x16297
leaq 0x12dd0(%rip), %rsi     # 0x16039
leaq 0x13046(%rip), %rcx     # 0x162b6
movl $0x1db, %edx            # imm = 0x1DB
callq 0x2100
leaq 0x12eba(%rip), %rdi     # 0x1613b
leaq 0x12db1(%rip), %rsi     # 0x16039
leaq 0x13027(%rip), %rcx     # 0x162b6
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %rax
testq %rdi, %rdi
je 0x32d7
cmpq $0x0, 0x10(%rdi)
jne 0x32f6
testq %rsi, %rsi
je 0x3315
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
popq %rax
retq
leaq 0x12eff(%rip), %rdi     # 0x161dd
leaq 0x12d54(%rip), %rsi     # 0x16039
leaq 0x13006(%rip), %rcx     # 0x162f2
movl $0x1ec, %edx            # imm = 0x1EC
callq 0x2100
leaq 0x12f9a(%rip), %rdi     # 0x16297
leaq 0x12d35(%rip), %rsi     # 0x16039
leaq 0x12fe7(%rip), %rcx     # 0x162f2
movl $0x1ed, %edx            # imm = 0x1ED
callq 0x2100
leaq 0x12dd8(%rip), %rdi     # 0x160f4
leaq 0x12d16(%rip), %rsi     # 0x16039
leaq 0x12fc8(%rip), %rcx     # 0x162f2
movl $0x1ee, %edx            # imm = 0x1EE
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x34af
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x20(%rdi)
andq $0x0, 0x30(%rdi)
movups %xmm0, 0x10(%rdi)
movl $0x1, (%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movl %esi, 0x8(%rdi)
pushq $0x1
popq %rax
retq
pushq %rax
leaq 0x13015(%rip), %rdi     # 0x164cc
leaq 0x12b7b(%rip), %rsi     # 0x16039
leaq 0x1300d(%rip), %rcx     # 0x164d2
movl $0x29c, %edx            # imm = 0x29C
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_stream_end_event_initialize
YAML_DECLARE(int)
yaml_stream_end_event_initialize(yaml_event_t *event)
{
    yaml_mark_t mark = { 0, 0, 0 };

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

    STREAM_END_EVENT_INIT(*event, mark, mark);

    return 1;
}

// Assembly:
testq %rdi, %rdi
je 0x34fd
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movl $0x2, (%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
pushq $0x1
popq %rax
retq
pushq %rax
leaq 0x12fc7(%rip), %rdi     # 0x164cc
leaq 0x12b2d(%rip), %rsi     # 0x16039
leaq 0x13007(%rip), %rcx     # 0x1651a
movl $0x2ac, %edx            # imm = 0x2AC
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_check_utf8
static int
yaml_check_utf8(yaml_char_t *start, size_t length)
{
    yaml_char_t *end = start+length;
    yaml_char_t *pointer = start;

    while (pointer < end) {
        unsigned char octet;
        unsigned int width;
        unsigned int value;
        size_t k;

        octet = pointer[0];
        width = (octet & 0x80) == 0x00 ? 1 :
                (octet & 0xE0) == 0xC0 ? 2 :
                (octet & 0xF0) == 0xE0 ? 3 :
                (octet & 0xF8) == 0xF0 ? 4 : 0;
        value = (octet & 0x80) == 0x00 ? octet & 0x7F :
                (octet & 0xE0) == 0xC0 ? octet & 0x1F :
                (octet & 0xF0) == 0xE0 ? octet & 0x0F :
                (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
        if (!width) return 0;
        if (pointer+width > end) return 0;
        for (k = 1; k < width; k ++) {
            octet = pointer[k];
            if ((octet & 0xC0) != 0x80) return 0;
            value = (value << 6) + (octet & 0x3F);
        }
        if (!((width == 1) ||
            (width == 2 && value >= 0x80) ||
            (width == 3 && value >= 0x800) ||
            (width == 4 && value >= 0x10000))) return 0;

        pointer += width;
    }

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
addq %rdi, %rsi
movl $0x1, %ecx
movabsq $0x1, %rdx
movl $0x2, %r8d
movl $0xf0, %r9d
movl $0x3, %r10d
xorl %r11d, %r11d
cmpq %rsi, %rdi
jae 0x38f1
movzbl (%rdi), %ebx
testb %bl, %bl
js 0x381c
movl %ecx, %eax
jmp 0x386e
movl %ebx, %eax
andl $-0x20, %eax
cmpl $0xc0, %eax
jne 0x3830
andl $0x1f, %ebx
movl %r8d, %eax
jmp 0x386e
movl %ebx, %r14d
andl $-0x10, %r14d
movl %ebx, %ebp
andl $-0x8, %ebp
xorl %eax, %eax
cmpl %r9d, %ebp
sete %al
shll $0x2, %eax
cmpl $0xe0, %r14d
cmovel %r10d, %eax
jne 0x3859
andl $0xf, %ebx
jmp 0x3866
andl $0x7, %ebx
cmpl $0xf0, %ebp
cmovnel %r11d, %ebx
testl %eax, %eax
je 0x38fe
movl %eax, %r15d
leaq (%rdi,%r15), %r14
xorl %eax, %eax
cmpq %rsi, %r14
ja 0x38f3
movq %rdx, %r12
cmpq %r15, %r12
jae 0x38a6
movzbl (%rdi,%r12), %ebp
movl %ebp, %r13d
andl $-0x40, %r13d
cmpl $0x80, %r13d
jne 0x38f3
shll $0x6, %ebx
andl $0x3f, %ebp
orl %ebp, %ebx
incq %r12
jmp 0x387f
movq %r14, %rdi
cmpl $0x1, %r15d
je 0x3808
cmpl $0x2, %r15d
jne 0x38c5
movq %r14, %rdi
cmpl $0x7f, %ebx
ja 0x3808
cmpl $0x3, %r15d
jne 0x38da
movq %r14, %rdi
cmpl $0x7ff, %ebx            # imm = 0x7FF
ja 0x3808
cmpl $0x4, %r15d
jne 0x38f3
movq %r14, %rdi
cmpl $0xffff, %ebx           # imm = 0xFFFF
ja 0x3808
jmp 0x38f3
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x38f3
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_document_end_event_initialize
YAML_DECLARE(int)
yaml_document_end_event_initialize(yaml_event_t *event, int implicit)
{
    yaml_mark_t mark = { 0, 0, 0 };

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

    DOCUMENT_END_EVENT_INIT(*event, implicit, mark, mark);

    return 1;
}

// Assembly:
testq %rdi, %rdi
je 0x3933
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x20(%rdi)
andq $0x0, 0x30(%rdi)
movups %xmm0, 0x10(%rdi)
movl $0x4, (%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movl %esi, 0x8(%rdi)
pushq $0x1
popq %rax
retq
pushq %rax
leaq 0x12b91(%rip), %rdi     # 0x164cc
leaq 0x126f7(%rip), %rsi     # 0x16039
leaq 0x12d19(%rip), %rcx     # 0x16662
movl $0x30b, %edx            # imm = 0x30B
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_alias_event_initialize
YAML_DECLARE(int)
yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor)
{
    yaml_mark_t mark = { 0, 0, 0 };
    yaml_char_t *anchor_copy = NULL;

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

    if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0;

    anchor_copy = yaml_strdup(anchor);
    if (!anchor_copy)
        return 0;

    ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark);

    return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x39c0
movq %rsi, %r14
testq %rsi, %rsi
je 0x39df
movq %rdi, %rbx
movq %r14, %rdi
callq 0x20d0
movq %r14, %rdi
movq %rax, %rsi
callq 0x37d7
xorl %ebp, %ebp
testl %eax, %eax
je 0x39b9
movq %r14, %rdi
callq 0x2230
testq %rax, %rax
je 0x39b9
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movl $0x5, (%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movq %rax, 0x8(%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x12b05(%rip), %rdi     # 0x164cc
leaq 0x1266b(%rip), %rsi     # 0x16039
leaq 0x12cc9(%rip), %rcx     # 0x1669e
movl $0x31c, %edx            # imm = 0x31C
callq 0x2100
leaq 0x13b71(%rip), %rdi     # 0x17557
leaq 0x1264c(%rip), %rsi     # 0x16039
leaq 0x12caa(%rip), %rcx     # 0x1669e
movl $0x31d, %edx            # imm = 0x31D
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_sequence_start_event_initialize
YAML_DECLARE(int)
yaml_sequence_start_event_initialize(yaml_event_t *event,
        yaml_char_t *anchor, yaml_char_t *tag, int implicit,
        yaml_sequence_style_t style)
{
    yaml_mark_t mark = { 0, 0, 0 };
    yaml_char_t *anchor_copy = NULL;
    yaml_char_t *tag_copy = NULL;

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

    if (anchor) {
        if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
        anchor_copy = yaml_strdup(anchor);
        if (!anchor_copy) goto error;
    }

    if (tag) {
        if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
        tag_copy = yaml_strdup(tag);
        if (!tag_copy) goto error;
    }

    SEQUENCE_START_EVENT_INIT(*event, anchor_copy, tag_copy,
            implicit, style, mark, mark);

    return 1;

error:
    yaml_free(anchor_copy);
    yaml_free(tag_copy);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x3c71
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
je 0x3bef
movq %r15, %rdi
callq 0x20d0
movq %r15, %rdi
movq %rax, %rsi
callq 0x37d7
testl %eax, %eax
je 0x3bea
movq %r15, %rdi
callq 0x2230
movq %rax, %r15
testq %rax, %rax
jne 0x3bf2
xorl %r15d, %r15d
jmp 0x3c1b
xorl %r15d, %r15d
testq %r12, %r12
je 0x3c27
movq %r12, %rdi
callq 0x20d0
movq %r12, %rdi
movq %rax, %rsi
callq 0x37d7
testl %eax, %eax
je 0x3c1b
movq %r12, %rdi
callq 0x2230
testq %rax, %rax
jne 0x3c29
movq %r15, %rdi
callq 0x2040
xorl %eax, %eax
jmp 0x3c68
xorl %eax, %eax
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, 0x20(%r14)
andq $0x0, 0x30(%r14)
movl $0x7, (%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
movq %r15, 0x8(%r14)
movq %rax, 0x10(%r14)
movl %ebp, 0x18(%r14)
movl %ebx, 0x1c(%r14)
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12854(%rip), %rdi     # 0x164cc
leaq 0x123ba(%rip), %rsi     # 0x16039
leaq 0x12adf(%rip), %rcx     # 0x16765
movl $0x36d, %edx            # imm = 0x36D
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_sequence_end_event_initialize
YAML_DECLARE(int)
yaml_sequence_end_event_initialize(yaml_event_t *event)
{
    yaml_mark_t mark = { 0, 0, 0 };

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

    SEQUENCE_END_EVENT_INIT(*event, mark, mark);

    return 1;
}

// Assembly:
testq %rdi, %rdi
je 0x3cbe
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movl $0x8, (%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
pushq $0x1
popq %rax
retq
pushq %rax
leaq 0x12806(%rip), %rdi     # 0x164cc
leaq 0x1236c(%rip), %rsi     # 0x16039
leaq 0x12b04(%rip), %rcx     # 0x167d8
movl $0x390, %edx            # imm = 0x390
callq 0x2100