LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq 0x29c8(%rip), %r14      # 0x3fe0
movq (%r14), %rdi
callq 0x1030
xorl %ebx, %ebx
leaq 0x2ad7(%rip), %r15      # 0x4100
cmpl $0x0, (%r15,%rbx,8)
jle 0x1658
xorl %ebp, %ebp
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x1650
movq (%r14), %rdi
movl $0x23, %esi
callq 0x1150
incl %ebp
cmpl (%r15,%rbx,8), %ebp
jl 0x1632
movl 0x4(%r15,%rbx,8), %ebp
cmpl $0x17, %ebp
jg 0x1687
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x1680
movq (%r14), %rdi
movl $0x23, %esi
callq 0x1150
incl %ebp
cmpl $0x18, %ebp
jne 0x1662
incq %rbx
cmpq $0x50, %rbx
jne 0x1629
movl 0x2a66(%rip), %ecx      # 0x40fc
movl 0x2a57(%rip), %r8d      # 0x40f4
leaq 0x99a(%rip), %rdx       # 0x203e
xorl %edi, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10d0
movq 0x2cca(%rip), %rbx      # 0x4380
testq %rbx, %rbx
je 0x16e5
cmpl $0x0, 0xc(%rbx)
jne 0x16df
movq (%r14), %rdi
movl 0x4(%rbx), %edx
movl 0x8(%rbx), %esi
callq 0x1130
cmpl $-0x1, %eax
je 0x16df
movq (%r14), %rdi
movzbl (%rbx), %esi
callq 0x1150
movq 0x10(%rbx), %rbx
jmp 0x16b6
movq (%r14), %rdi
movl 0x2a02(%rip), %esi      # 0x40f0
movzbl 0x2a03(%rip), %eax      # 0x40f8
leal (%rax,%rax,2), %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x170f
movq (%r14), %rdi
movl $0x3e, %esi
callq 0x1150
movq (%r14), %rdi
movl 0x29d8(%rip), %esi      # 0x40f0
movzbl 0x29d9(%rip), %eax      # 0x40f8
leal (%rax,%rax,2), %edx
callq 0x1130
movq (%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x18, %edi
callq 0x1120
movq %rax, %rbx
movq 0x2c2e(%rip), %rcx      # 0x4380
testq %rcx, %rcx
je 0x1769
movq %rcx, %rax
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x1757
addq $0x10, %rax
jmp 0x1770
leaq 0x2c10(%rip), %rax      # 0x4380
movq %rbx, (%rax)
movb %bpl, (%rbx)
movq $0x0, 0x10(%rbx)
movl $0x0, 0xc(%rbx)
movzbl %bpl, %eax
cmpl $0x2c, %eax
jg 0x179a
cmpl $0x24, %eax
je 0x17a4
cmpl $0x2b, %eax
je 0x17a4
jmp 0x17e8
cmpl $0x2d, %eax
je 0x17d0
cmpl $0x40, %eax
jne 0x17e8
movl $0x4f, 0x4(%rbx)
movl 0x2bc7(%rip), %ebp      # 0x4378
callq 0x1100
movslq 0x2bbf(%rip), %rcx      # 0x437c
movslq 0x2bb4(%rip), %rdx      # 0x4378
subq %rdx, %rcx
cqto
idivq %rcx
addl %ebp, %edx
jmp 0x17e5
movzbl 0x2921(%rip), %eax      # 0x40f8
leal (%rax,%rax,2), %eax
incl %eax
movl %eax, 0x4(%rbx)
movl 0x290b(%rip), %edx      # 0x40f0
movl %edx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %ecx, %ecx
leaq 0x2908(%rip), %rax      # 0x4100
movq 0x8(%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
leaq 0x1(%rcx), %rdx
movq %rdx, %rcx
cmpq $0x4f, %rdx
jne 0x17f8
pushq %rbx
movq 0x2b6a(%rip), %rax      # 0x4380
testq %rax, %rax
je 0x1824
decl 0x4(%rax)
movq 0x10(%rax), %rax
jmp 0x1816
callq 0x1100
movq %rax, %rcx
movabsq $0x6666666666666667, %rbx # imm = 0x6666666666666667
imulq %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq %rdx
addq %rax, %rdx
leaq (%rdx,%rdx,4), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
je 0x186a
testq %rcx, %rcx
jne 0x188d
movl 0x2b1a(%rip), %eax      # 0x4378
xorl %ecx, %ecx
cmpl $0x3, %eax
setge %cl
subl %ecx, %eax
jmp 0x1887
movl 0x2b08(%rip), %eax      # 0x4378
leal 0x1(%rax), %ecx
movl %ecx, 0x2aff(%rip)      # 0x4378
movl 0x2afd(%rip), %edx      # 0x437c
addl $-0x3, %edx
cmpl %edx, %eax
cmovll %ecx, %eax
movl %eax, 0x2aeb(%rip)      # 0x4378
callq 0x1100
movq %rax, %rcx
imulq %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq %rdx
addq %rax, %rdx
leaq (%rdx,%rdx,4), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
je 0x18c9
testq %rcx, %rcx
jne 0x18ec
movl 0x2abf(%rip), %ecx      # 0x437c
xorl %eax, %eax
cmpl $0x16, %ecx
setl %al
addl %ecx, %eax
jmp 0x18e6
movl 0x2aad(%rip), %eax      # 0x437c
leal -0x1(%rax), %ecx
movl %ecx, 0x2aa4(%rip)      # 0x437c
movl 0x2a9a(%rip), %edx      # 0x4378
addl $0x3, %edx
cmpl %edx, %ecx
cmovgl %ecx, %eax
movl %eax, 0x2a90(%rip)      # 0x437c
callq 0x1100
movq %rax, %rcx
imulq %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x3, %rdx
addq %rax, %rdx
shlq $0x2, %rdx
leaq (%rdx,%rdx,4), %rax
subq %rax, %rcx
cmpq $0x2, %rcx
popq %rbx
ja 0x1929
shll $0x3, %ecx
movl $0x402b24, %eax         # imm = 0x402B24
shrl %cl, %eax
movzbl %al, %edi
jmp 0x1739
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2a09(%rip), %rbx      # 0x4380
testq %rbx, %rbx
je 0x1a85
leaq 0x2775(%rip), %r14      # 0x40fc
leaq 0x2766(%rip), %r15      # 0x40f4
movq 0x264b(%rip), %r12      # 0x3fe0
movl $0x1, %ebp
cmpl $0x0, 0xc(%rbx)
je 0x19ae
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x199a
jmp 0x1a85
movzbl (%rbx), %eax
cmpl $0x24, %eax
je 0x1a52
cmpl $0x2b, %eax
je 0x1a37
cmpl $0x2d, %eax
jne 0x19a0
movq (%r12), %rdi
movl 0x4(%rbx), %edx
movl 0x8(%rbx), %esi
callq 0x1130
cmpl $-0x1, %eax
je 0x19ed
movq (%r12), %rdi
callq 0x1110
cmpl $0x23, %eax
jne 0x19ed
movl $0x1, 0xc(%rbx)
movq 0x298c(%rip), %r13      # 0x4380
testq %r13, %r13
je 0x19a0
cmpq %r13, %rbx
je 0x1a31
cmpl $0x0, 0xc(%r13)
jne 0x1a31
movl 0x4(%rbx), %eax
cmpl 0x4(%r13), %eax
jne 0x1a31
movl 0x8(%rbx), %eax
cmpl 0x8(%r13), %eax
jne 0x1a31
callq 0x10c0
cmpb $0x40, (%r13)
jne 0x1a2a
addl $0x5, 0x26d2(%rip)      # 0x40fc
movl %ebp, 0xc(%rbx)
movl %ebp, 0xc(%r13)
movq 0x10(%r13), %r13
jmp 0x19f4
movzbl 0x26ba(%rip), %eax      # 0x40f8
leal (%rax,%rax,2), %eax
cmpl %eax, 0x4(%rbx)
jne 0x19a0
movl 0x8(%rbx), %ecx
movq %r15, %rax
jmp 0x1a6b
movzbl 0x269f(%rip), %eax      # 0x40f8
leal (%rax,%rax,2), %eax
cmpl %eax, 0x4(%rbx)
jne 0x19a0
movl 0x8(%rbx), %ecx
movq %r14, %rax
cmpl 0x267f(%rip), %ecx      # 0x40f0
jne 0x19a0
incl (%rax)
movl $0x1, 0xc(%rbx)
jmp 0x19a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x23c6
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)
movl $0x1, %eax
jmp 0x23c8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %ebx
cmpq (%r8), %rax
je 0x2437
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 0x2428
movq %rbp, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x20a0
testl %eax, %eax
jne 0x23f9
xorl %ebx, %ebx
jmp 0x2437
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_O1/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 0x248f
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)
movl $0x1, %eax
jmp 0x2491
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpq (%rsi), %rdi
jne 0x24f6
movq (%r12), %rsi
cmpq %rsi, (%r14)
jne 0x24f6
subq %rdi, %rsi
addq %rsi, %rsi
callq 0x2130
testq %rax, %rax
je 0x2534
movq (%rbx), %rcx
subq (%r15), %rcx
addq %rax, %rcx
movq %rcx, (%rbx)
movq (%r14), %rcx
subq (%r15), %rcx
addq %rax, %rcx
movq %rcx, (%r14)
movq (%r12), %rcx
subq (%r15), %rcx
leaq (%rax,%rcx,2), %rcx
movq %rcx, (%r12)
movq %rax, (%r15)
movq (%r14), %rdx
movl $0x1, %ebp
cmpq (%r12), %rdx
jne 0x2529
movq (%rbx), %rsi
cmpq %rdx, %rsi
je 0x2517
movq (%r15), %rdi
subq %rsi, %rdx
callq 0x21d0
movq (%r14), %rax
subq (%rbx), %rax
addq (%r15), %rax
movq %rax, (%r14)
movq (%r15), %rax
movq %rax, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x2529
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x29d3
movq %rdi, %rbx
leaq 0xb0(%rdi), %r15
movq 0xb0(%rdi), %rdi
testq %rdi, %rdi
je 0x285e
callq 0x2040
leaq 0x88(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x2888
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x118(%rbx), %rdi
cmpq 0x120(%rbx), %rdi
je 0x28b6
leaq 0x50(%rdi), %rax
movq %rax, 0x118(%rbx)
callq 0x2210
jmp 0x2894
leaq 0x108(%rbx), %r15
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x28ce
callq 0x2040
leaq 0x138(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movups %xmm0, (%r15)
movq 0x138(%rbx), %rdi
testq %rdi, %rdi
je 0x28f5
callq 0x2040
xorps %xmm0, %xmm0
leaq 0x158(%rbx), %r15
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x158(%rbx), %rdi
testq %rdi, %rdi
je 0x2919
callq 0x2040
leaq 0x170(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x170(%rbx), %rdi
testq %rdi, %rdi
je 0x2943
callq 0x2040
xorps %xmm0, %xmm0
leaq 0x190(%rbx), %r15
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x190(%rbx), %rdi
testq %rdi, %rdi
je 0x2967
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x1a8(%rbx), %rdi
movq 0x1b8(%rbx), %rax
cmpq %rax, %rdi
je 0x29b5
leaq -0x10(%rax), %rcx
movq %rcx, 0x1b8(%rbx)
movq -0x10(%rax), %rdi
movq -0x8(%rax), %r14
testq %rdi, %rdi
je 0x29a6
callq 0x2040
testq %r14, %r14
je 0x2976
movq %r14, %rdi
callq 0x2040
jmp 0x2976
testq %rdi, %rdi
je 0x29bf
callq 0x2040
movl $0x1e0, %edx            # imm = 0x1E0
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2120
leaq 0x15658(%rip), %rdi     # 0x18032
leaq 0x15658(%rip), %rsi     # 0x18039
leaq 0x15683(%rip), %rcx     # 0x1806b
movl $0xd8, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x2a54
movq %rdi, %rbx
movl (%rdi), %ecx
leal -0x12(%rcx), %eax
cmpl $0x3, %eax
ja 0x2a1b
leaq 0x155f4(%rip), %rcx     # 0x18000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
jmp 0x2a32
cmpl $0x4, %ecx
jne 0x2a3c
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2a2e
callq 0x2040
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2a3c
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 0x16699(%rip), %rdi     # 0x190f4
leaq 0x155d7(%rip), %rsi     # 0x18039
leaq 0x15a3c(%rip), %rcx     # 0x184a5
movl $0x244, %edx            # imm = 0x244
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x2aa5
cmpq $0x0, 0x58(%rdi)
jne 0x2ac4
testq %rsi, %rsi
je 0x2ae3
leaq 0x76(%rip), %rax        # 0x2b02
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 0x15586(%rip), %rdi     # 0x18032
leaq 0x15586(%rip), %rsi     # 0x18039
leaq 0x155da(%rip), %rcx     # 0x18094
movl $0x11e, %edx            # imm = 0x11E
callq 0x2100
leaq 0x1561b(%rip), %rdi     # 0x180e6
leaq 0x15567(%rip), %rsi     # 0x18039
leaq 0x155bb(%rip), %rcx     # 0x18094
movl $0x11f, %edx            # imm = 0x11F
callq 0x2100
leaq 0x15612(%rip), %rdi     # 0x180fc
leaq 0x15548(%rip), %rsi     # 0x18039
leaq 0x1559c(%rip), %rcx     # 0x18094
movl $0x120, %edx            # imm = 0x120
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x2b38
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 0x2b3b
xorl %r14d, %r14d
movq %r14, (%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2b70
cmpq $0x0, 0x58(%rdi)
jne 0x2b8f
testq %rsi, %rsi
je 0x2bae
leaq 0x6b(%rip), %rax        # 0x2bcd
movq %rax, 0x58(%rdi)
movq %rdi, 0x60(%rdi)
movq %rsi, 0x68(%rdi)
popq %rax
retq
leaq 0x154bb(%rip), %rdi     # 0x18032
leaq 0x154bb(%rip), %rsi     # 0x18039
leaq 0x1557d(%rip), %rcx     # 0x18102
movl $0x131, %edx            # imm = 0x131
callq 0x2100
leaq 0x15550(%rip), %rdi     # 0x180e6
leaq 0x1549c(%rip), %rsi     # 0x18039
leaq 0x1555e(%rip), %rcx     # 0x18102
movl $0x132, %edx            # imm = 0x132
callq 0x2100
leaq 0x15586(%rip), %rdi     # 0x1813b
leaq 0x1547d(%rip), %rsi     # 0x18039
leaq 0x1553f(%rip), %rcx     # 0x18102
movl $0x133, %edx            # imm = 0x133
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x2c24
cmpq $0x0, 0x58(%rdi)
jne 0x2c43
testq %rsi, %rsi
je 0x2c62
movq %rsi, 0x58(%rdi)
movq %rdx, 0x60(%rdi)
popq %rax
retq
leaq 0x15407(%rip), %rdi     # 0x18032
leaq 0x15407(%rip), %rsi     # 0x18039
leaq 0x15507(%rip), %rcx     # 0x18140
movl $0x143, %edx            # imm = 0x143
callq 0x2100
leaq 0x1549c(%rip), %rdi     # 0x180e6
leaq 0x153e8(%rip), %rsi     # 0x18039
leaq 0x154e8(%rip), %rcx     # 0x18140
movl $0x144, %edx            # imm = 0x144
callq 0x2100
leaq 0x1548b(%rip), %rdi     # 0x180f4
leaq 0x153c9(%rip), %rsi     # 0x18039
leaq 0x154c9(%rip), %rcx     # 0x18140
movl $0x145, %edx            # imm = 0x145
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x3079
movq %rdi, %rbx
leaq 0x38(%rdi), %r15
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x2f31
callq 0x2040
leaq 0x58(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x2f55
callq 0x2040
xorps %xmm0, %xmm0
leaq 0x90(%rbx), %r15
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x2f79
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0xc0(%rbx), %rdi
cmpq 0xc8(%rbx), %rdi
je 0x2faa
leaq 0x68(%rdi), %rax
movq %rax, 0xc0(%rbx)
callq 0x21e0
jmp 0x2f88
leaq 0xb0(%rbx), %r15
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x2fc2
callq 0x2040
leaq 0xd0(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movups %xmm0, (%r15)
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x2fe9
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0xe8(%rbx), %rdi
movq 0xf8(%rbx), %rax
cmpq %rax, %rdi
je 0x3034
leaq -0x10(%rax), %rcx
movq %rcx, 0xf8(%rbx)
movq -0x10(%rax), %rdi
movq -0x8(%rax), %r14
testq %rdi, %rdi
je 0x3025
callq 0x2040
testq %r14, %r14
je 0x2ff5
movq %r14, %rdi
callq 0x2040
jmp 0x2ff5
leaq 0xe8(%rbx), %r14
testq %rdi, %rdi
je 0x3045
callq 0x2040
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x198(%rbx), %rdi
testq %rdi, %rdi
je 0x3065
callq 0x2040
movl $0x1b0, %edx            # imm = 0x1B0
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2120
leaq 0x1515d(%rip), %rdi     # 0x181dd
leaq 0x14fb2(%rip), %rsi     # 0x18039
leaq 0x15185(%rip), %rcx     # 0x18213
movl $0x184, %edx            # imm = 0x184
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x316d
movq %rdi, %rbx
movl (%rdi), %eax
addl $-0x3, %eax
cmpl $0x6, %eax
ja 0x3143
leaq 0x14f53(%rip), %rcx     # 0x18010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x30d4
callq 0x2040
movq 0x10(%rbx), %rdi
jmp 0x3139
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x30e8
callq 0x2040
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x30f6
callq 0x2040
movq 0x18(%rbx), %rdi
jmp 0x3139
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x310a
callq 0x2040
movq 0x10(%rbx), %r14
cmpq 0x18(%rbx), %r14
je 0x30d4
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3121
callq 0x2040
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x312f
callq 0x2040
addq $0x10, %r14
jmp 0x310e
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3143
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)
movq $0x0, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x15358(%rip), %rdi     # 0x184cc
leaq 0x14ebe(%rip), %rsi     # 0x18039
leaq 0x15734(%rip), %rcx     # 0x188b6
movl $0x3d7, %edx            # imm = 0x3D7
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x31c2
cmpq $0x0, 0x10(%rdi)
jne 0x31e1
testq %rsi, %rsi
je 0x3200
leaq 0x7a(%rip), %rax        # 0x321f
movq %rax, 0x10(%rdi)
movq %rdi, 0x18(%rdi)
movq %rsi, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
movq $0x0, (%rcx)
popq %rax
retq
leaq 0x15014(%rip), %rdi     # 0x181dd
leaq 0x14e69(%rip), %rsi     # 0x18039
leaq 0x15067(%rip), %rcx     # 0x1823e
movl $0x1c6, %edx            # imm = 0x1C6
callq 0x2100
leaq 0x150af(%rip), %rdi     # 0x18297
leaq 0x14e4a(%rip), %rsi     # 0x18039
leaq 0x15048(%rip), %rcx     # 0x1823e
movl $0x1c7, %edx            # imm = 0x1C7
callq 0x2100
leaq 0x150a8(%rip), %rdi     # 0x182af
leaq 0x14e2b(%rip), %rsi     # 0x18039
leaq 0x15029(%rip), %rcx     # 0x1823e
movl $0x1c8, %edx            # imm = 0x1C8
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x325b
subq %rax, %rdx
callq 0x2170
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0x326f
movq %r14, %rdx
callq 0x2170
movq 0x30(%rbx), %rax
addq %r14, (%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x329e
cmpq $0x0, 0x10(%rdi)
jne 0x32bd
testq %rsi, %rsi
je 0x32dc
leaq 0x6b(%rip), %rax        # 0x32fb
movq %rax, 0x10(%rdi)
movq %rdi, 0x18(%rdi)
movq %rsi, 0x20(%rdi)
popq %rax
retq
leaq 0x14f38(%rip), %rdi     # 0x181dd
leaq 0x14d8d(%rip), %rsi     # 0x18039
leaq 0x15003(%rip), %rcx     # 0x182b6
movl $0x1da, %edx            # imm = 0x1DA
callq 0x2100
leaq 0x14fd3(%rip), %rdi     # 0x18297
leaq 0x14d6e(%rip), %rsi     # 0x18039
leaq 0x14fe4(%rip), %rcx     # 0x182b6
movl $0x1db, %edx            # imm = 0x1DB
callq 0x2100
leaq 0x14e58(%rip), %rdi     # 0x1813b
leaq 0x14d4f(%rip), %rsi     # 0x18039
leaq 0x14fc5(%rip), %rcx     # 0x182b6
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x333b
cmpq $0x0, 0x10(%rdi)
jne 0x335a
testq %rsi, %rsi
je 0x3379
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
popq %rax
retq
leaq 0x14e9b(%rip), %rdi     # 0x181dd
leaq 0x14cf0(%rip), %rsi     # 0x18039
leaq 0x14fa2(%rip), %rcx     # 0x182f2
movl $0x1ec, %edx            # imm = 0x1EC
callq 0x2100
leaq 0x14f36(%rip), %rdi     # 0x18297
leaq 0x14cd1(%rip), %rsi     # 0x18039
leaq 0x14f83(%rip), %rcx     # 0x182f2
movl $0x1ed, %edx            # imm = 0x1ED
callq 0x2100
leaq 0x14d74(%rip), %rdi     # 0x180f4
leaq 0x14cb2(%rip), %rsi     # 0x18039
leaq 0x14f64(%rip), %rcx     # 0x182f2
movl $0x1ee, %edx            # imm = 0x1EE
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x3528
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x60(%rdi)
movl $0x1, (%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movl %esi, 0x8(%rdi)
movl $0x1, %eax
retq
pushq %rax
leaq 0x14f9c(%rip), %rdi     # 0x184cc
leaq 0x14b02(%rip), %rsi     # 0x18039
leaq 0x14f94(%rip), %rcx     # 0x184d2
movl $0x29c, %edx            # imm = 0x29C
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x3587
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x60(%rdi)
movl $0x2, (%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movl $0x1, %eax
retq
pushq %rax
leaq 0x14f3d(%rip), %rdi     # 0x184cc
leaq 0x14aa3(%rip), %rsi     # 0x18039
leaq 0x14f7d(%rip), %rcx     # 0x1851a
movl $0x2ac, %edx            # imm = 0x2AC
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
addq %rdi, %rsi
xorl %ecx, %ecx
cmpq %rsi, %rdi
jae 0x3a2e
movzbl (%rdi), %edx
movl $0x1, %r8d
testb %dl, %dl
jns 0x3971
movl %edx, %eax
andl $-0x20, %eax
movl $0x2, %r8d
cmpl $0xc0, %eax
je 0x3971
movl %edx, %eax
andl $-0x10, %eax
movl $0x3, %r8d
cmpl $0xe0, %eax
je 0x3971
movl %edx, %eax
andl $-0x8, %eax
xorl %r8d, %r8d
cmpl $0xf0, %eax
sete %r8b
shll $0x2, %r8d
testb %dl, %dl
jns 0x39a7
movl %edx, %eax
andl $-0x20, %eax
cmpl $0xc0, %eax
jne 0x3986
andl $0x1f, %edx
jmp 0x39a7
movl %edx, %eax
andl $-0x10, %eax
cmpl $0xe0, %eax
jne 0x3997
andl $0xf, %edx
jmp 0x39a7
movl %edx, %eax
andl $-0x8, %eax
andl $0x7, %edx
cmpl $0xf0, %eax
cmovnel %ecx, %edx
xorl %eax, %eax
testl %r8d, %r8d
je 0x39ba
movl %r8d, %r10d
leaq (%rdi,%r10), %r9
cmpq %rsi, %r9
jbe 0x39bf
xorl %r10d, %r10d
jmp 0x3a23
cmpl $0x1, %r8d
je 0x39ed
movl $0x1, %r11d
movzbl (%rdi,%r11), %ebx
movl %ebx, %ebp
andl $-0x40, %ebp
cmpl $0x80, %ebp
jne 0x39ba
shll $0x6, %edx
andl $0x3f, %ebx
orl %ebx, %edx
incq %r11
cmpq %r11, %r10
jne 0x39cb
cmpl $0x1, %r8d
je 0x3a1d
cmpl $0x2, %r8d
jne 0x39fe
cmpl $0x7f, %edx
ja 0x3a1d
cmpl $0x3, %r8d
jne 0x3a0c
cmpl $0x7ff, %edx            # imm = 0x7FF
ja 0x3a1d
xorl %r10d, %r10d
cmpl $0x4, %r8d
jne 0x3a23
cmpl $0x10000, %edx          # imm = 0x10000
jb 0x3a23
movb $0x1, %r10b
movq %r9, %rdi
testb %r10b, %r10b
jne 0x3922
jmp 0x3a33
movl $0x1, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3a78
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x60(%rdi)
movl $0x4, (%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movl %esi, 0x8(%rdi)
movl $0x1, %eax
retq
pushq %rax
leaq 0x14a4c(%rip), %rdi     # 0x184cc
leaq 0x145b2(%rip), %rsi     # 0x18039
leaq 0x14bd4(%rip), %rcx     # 0x18662
movl $0x30b, %edx            # imm = 0x30B
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x3b1a
movq %rsi, %r14
testq %rsi, %rsi
je 0x3b39
movq %rdi, %rbx
movq %r14, %rdi
callq 0x20d0
movq %r14, %rdi
movq %rax, %rsi
callq 0x391b
xorl %ebp, %ebp
testl %eax, %eax
je 0x3b13
movq %r14, %rdi
callq 0x2220
testq %rax, %rax
je 0x3b13
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x60(%rbx)
movl $0x5, (%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movq %rax, 0x8(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x149ab(%rip), %rdi     # 0x184cc
leaq 0x14511(%rip), %rsi     # 0x18039
leaq 0x14b6f(%rip), %rcx     # 0x1869e
movl $0x31c, %edx            # imm = 0x31C
callq 0x2100
leaq 0x159ab(%rip), %rdi     # 0x194eb
leaq 0x144f2(%rip), %rsi     # 0x18039
leaq 0x14b50(%rip), %rcx     # 0x1869e
movl $0x31d, %edx            # imm = 0x31D
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x3e10
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
je 0x3d73
movq %r15, %rdi
callq 0x20d0
movq %r15, %rdi
movq %rax, %rsi
callq 0x391b
testl %eax, %eax
je 0x3d6e
movq %r15, %rdi
callq 0x2220
movq %rax, %r15
testq %rax, %rax
jne 0x3d76
xorl %r15d, %r15d
jmp 0x3d9f
xorl %r15d, %r15d
testq %r12, %r12
je 0x3db0
movq %r12, %rdi
callq 0x20d0
movq %r12, %rdi
movq %rax, %rsi
callq 0x391b
testl %eax, %eax
je 0x3d9f
movq %r12, %rdi
callq 0x2220
testq %rax, %rax
jne 0x3db2
xorl %ebx, %ebx
testq %r15, %r15
je 0x3e05
movq %r15, %rdi
callq 0x2040
jmp 0x3e05
xorl %eax, %eax
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, 0x20(%r14)
movq $0x0, 0x60(%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)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x146b5(%rip), %rdi     # 0x184cc
leaq 0x1421b(%rip), %rsi     # 0x18039
leaq 0x14940(%rip), %rcx     # 0x18765
movl $0x36d, %edx            # imm = 0x36D
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x3e6e
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x60(%rdi)
movl $0x8, (%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movl $0x1, %eax
retq
pushq %rax
leaq 0x14656(%rip), %rdi     # 0x184cc
leaq 0x141bc(%rip), %rsi     # 0x18039
leaq 0x14954(%rip), %rcx     # 0x187d8
movl $0x390, %edx            # imm = 0x390
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_mapping_start_event_initialize
YAML_DECLARE(int)
yaml_mapping_start_event_initialize(yaml_event_t *event,
        yaml_char_t *anchor, yaml_char_t *tag, int implicit,
        yaml_mapping_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;
    }

    MAPPING_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 0x3f7b
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
je 0x3ede
movq %r15, %rdi
callq 0x20d0
movq %r15, %rdi
movq %rax, %rsi
callq 0x391b
testl %eax, %eax
je 0x3ed9
movq %r15, %rdi
callq 0x2220
movq %rax, %r15
testq %rax, %rax
jne 0x3ee1
xorl %r15d, %r15d
jmp 0x3f0a
xorl %r15d, %r15d
testq %r12, %r12
je 0x3f1b
movq %r12, %rdi
callq 0x20d0
movq %r12, %rdi
movq %rax, %rsi
callq 0x391b
testl %eax, %eax
je 0x3f0a
movq %r12, %rdi
callq 0x2220
testq %rax, %rax
jne 0x3f1d
xorl %ebx, %ebx
testq %r15, %r15
je 0x3f70
movq %r15, %rdi
callq 0x2040
jmp 0x3f70
xorl %eax, %eax
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, 0x20(%r14)
movq $0x0, 0x60(%r14)
movl $0x9, (%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)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1454a(%rip), %rdi     # 0x184cc
leaq 0x140b0(%rip), %rsi     # 0x18039
leaq 0x1487f(%rip), %rcx     # 0x1880f
movl $0x3a4, %edx            # imm = 0x3A4
callq 0x2100